Merge "Remove userspace reboot" into main am: d374d6870c (89147d41) · Commits · e / os / android_frameworks_base

Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -261,7 +261,6 @@ java_library {
		"devicepolicyprotosnano",
		"ImmutabilityAnnotation",

		"com.android.sysprop.init",
		"com.android.sysprop.localization",
		"PlatformProperties",
		],

services/core/java/com/android/server/OWNERS

+0 −3

Original line number	Diff line number	Diff line
		@@ -10,9 +10,6 @@ per-file DisplayThread.java = michaelwr@google.com, ogunwale@google.com
		# Zram writeback
		per-file ZramWriteback.java = minchan@google.com, rajekumar@google.com

		# Userspace reboot
		per-file UserspaceRebootLogger.java = ioffe@google.com, dvander@google.com

		# ServiceWatcher
		per-file ServiceWatcher.java = sooniln@google.com

services/core/java/com/android/server/UserspaceRebootLogger.java

deleted100644 → 0

+0 −168

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

		import static com.android.internal.util.FrameworkStatsLog.USERSPACE_REBOOT_REPORTED__OUTCOME__FAILED_SHUTDOWN_SEQUENCE_ABORTED;
		import static com.android.internal.util.FrameworkStatsLog.USERSPACE_REBOOT_REPORTED__OUTCOME__FAILED_USERDATA_REMOUNT;
		import static com.android.internal.util.FrameworkStatsLog.USERSPACE_REBOOT_REPORTED__OUTCOME__FAILED_USERSPACE_REBOOT_WATCHDOG_TRIGGERED;
		import static com.android.internal.util.FrameworkStatsLog.USERSPACE_REBOOT_REPORTED__OUTCOME__OUTCOME_UNKNOWN;
		import static com.android.internal.util.FrameworkStatsLog.USERSPACE_REBOOT_REPORTED__OUTCOME__SUCCESS;
		import static com.android.internal.util.FrameworkStatsLog.USERSPACE_REBOOT_REPORTED__USER_ENCRYPTION_STATE__LOCKED;
		import static com.android.internal.util.FrameworkStatsLog.USERSPACE_REBOOT_REPORTED__USER_ENCRYPTION_STATE__UNLOCKED;

		import android.os.PowerManager;
		import android.os.SystemClock;
		import android.os.SystemProperties;
		import android.text.TextUtils;
		import android.util.Slog;

		import com.android.internal.util.FrameworkStatsLog;

		import java.util.concurrent.Executor;

		/**
		* Utility class to help abstract logging {@code UserspaceRebootReported} atom.
		*/
		public final class UserspaceRebootLogger {

		private static final String TAG = "UserspaceRebootLogger";

		private static final String USERSPACE_REBOOT_SHOULD_LOG_PROPERTY =
		"persist.sys.userspace_reboot.log.should_log";
		private static final String USERSPACE_REBOOT_LAST_STARTED_PROPERTY =
		"sys.userspace_reboot.log.last_started";
		private static final String USERSPACE_REBOOT_LAST_FINISHED_PROPERTY =
		"sys.userspace_reboot.log.last_finished";
		private static final String LAST_BOOT_REASON_PROPERTY = "sys.boot.reason.last";

		private UserspaceRebootLogger() {}

		/**
		* Modifies internal state to note that {@code UserspaceRebootReported} atom needs to be
		* logged on the next successful boot.
		*
		* <p>This call should only be made on devices supporting userspace reboot.
		*/
		public static void noteUserspaceRebootWasRequested() {
		if (!PowerManager.isRebootingUserspaceSupportedImpl()) {
		Slog.wtf(TAG, "noteUserspaceRebootWasRequested: Userspace reboot is not supported.");
		return;
		}

		SystemProperties.set(USERSPACE_REBOOT_SHOULD_LOG_PROPERTY, "1");
		SystemProperties.set(USERSPACE_REBOOT_LAST_STARTED_PROPERTY,
		String.valueOf(SystemClock.elapsedRealtime()));
		}

		/**
		* Updates internal state on boot after successful userspace reboot.
		*
		* <p>Should be called right before framework sets {@code sys.boot_completed} property.
		*
		* <p>This call should only be made on devices supporting userspace reboot.
		*/
		public static void noteUserspaceRebootSuccess() {
		if (!PowerManager.isRebootingUserspaceSupportedImpl()) {
		Slog.wtf(TAG, "noteUserspaceRebootSuccess: Userspace reboot is not supported.");
		return;
		}

		SystemProperties.set(USERSPACE_REBOOT_LAST_FINISHED_PROPERTY,
		String.valueOf(SystemClock.elapsedRealtime()));
		}

		/**
		* Returns {@code true} if {@code UserspaceRebootReported} atom should be logged.
		*
		* <p>On devices that do not support userspace reboot this method will always return {@code
		* false}.
		*/
		public static boolean shouldLogUserspaceRebootEvent() {
		if (!PowerManager.isRebootingUserspaceSupportedImpl()) {
		return false;
		}

		return SystemProperties.getBoolean(USERSPACE_REBOOT_SHOULD_LOG_PROPERTY, false);
		}

		/**
		* Asynchronously logs {@code UserspaceRebootReported} on the given {@code executor}.
		*
		* <p>Should be called in the end of {@link
		* com.android.server.am.ActivityManagerService#finishBooting()} method, after framework have
		* tried to proactivelly unlock storage of the primary user.
		*
		* <p>This call should only be made on devices supporting userspace reboot.
		*/
		public static void logEventAsync(boolean userUnlocked, Executor executor) {
		if (!PowerManager.isRebootingUserspaceSupportedImpl()) {
		Slog.wtf(TAG, "logEventAsync: Userspace reboot is not supported.");
		return;
		}

		final int outcome = computeOutcome();
		final long durationMillis;
		if (outcome == USERSPACE_REBOOT_REPORTED__OUTCOME__SUCCESS) {
		durationMillis = SystemProperties.getLong(USERSPACE_REBOOT_LAST_FINISHED_PROPERTY, 0)
		- SystemProperties.getLong(USERSPACE_REBOOT_LAST_STARTED_PROPERTY, 0);
		} else {
		durationMillis = 0;
		}
		final int encryptionState =
		userUnlocked
		? USERSPACE_REBOOT_REPORTED__USER_ENCRYPTION_STATE__UNLOCKED
		: USERSPACE_REBOOT_REPORTED__USER_ENCRYPTION_STATE__LOCKED;
		executor.execute(
		() -> {
		Slog.i(TAG, "Logging UserspaceRebootReported atom: { outcome: " + outcome
		+ " durationMillis: " + durationMillis + " encryptionState: "
		+ encryptionState + " }");
		FrameworkStatsLog.write(FrameworkStatsLog.USERSPACE_REBOOT_REPORTED, outcome,
		durationMillis, encryptionState);
		SystemProperties.set(USERSPACE_REBOOT_SHOULD_LOG_PROPERTY, "");
		});
		}

		private static int computeOutcome() {
		if (SystemProperties.getLong(USERSPACE_REBOOT_LAST_STARTED_PROPERTY, -1) != -1) {
		return USERSPACE_REBOOT_REPORTED__OUTCOME__SUCCESS;
		}
		String reason = TextUtils.emptyIfNull(SystemProperties.get(LAST_BOOT_REASON_PROPERTY, ""));
		if (reason.startsWith("reboot,")) {
		reason = reason.substring("reboot".length());
		}
		if (reason.startsWith("userspace_failed,watchdog_fork")) {
		return USERSPACE_REBOOT_REPORTED__OUTCOME__FAILED_SHUTDOWN_SEQUENCE_ABORTED;
		}
		if (reason.startsWith("userspace_failed,shutdown_aborted")) {
		return USERSPACE_REBOOT_REPORTED__OUTCOME__FAILED_SHUTDOWN_SEQUENCE_ABORTED;
		}
		if (reason.startsWith("mount_userdata_failed")) {
		return USERSPACE_REBOOT_REPORTED__OUTCOME__FAILED_USERDATA_REMOUNT;
		}
		if (reason.startsWith("userspace_failed,init_user0")) {
		return USERSPACE_REBOOT_REPORTED__OUTCOME__FAILED_USERDATA_REMOUNT;
		}
		if (reason.startsWith("userspace_failed,enablefilecrypto")) {
		return USERSPACE_REBOOT_REPORTED__OUTCOME__FAILED_USERDATA_REMOUNT;
		}
		if (reason.startsWith("userspace_failed,watchdog_triggered")) {
		return USERSPACE_REBOOT_REPORTED__OUTCOME__FAILED_USERSPACE_REBOOT_WATCHDOG_TRIGGERED;
		}
		return USERSPACE_REBOOT_REPORTED__OUTCOME__OUTCOME_UNKNOWN;
		}
		}

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

+0 −23

Original line number	Diff line number	Diff line
		@@ -371,7 +371,6 @@ import android.os.storage.StorageManager;
		import android.provider.DeviceConfig;
		import android.provider.Settings;
		import android.server.ServerProtoEnums;
		import android.sysprop.InitProperties;
		import android.system.Os;
		import android.system.OsConstants;
		import android.telephony.TelephonyManager;
		@@ -450,7 +449,6 @@ import com.android.server.SystemConfig;
		import com.android.server.SystemService;
		import com.android.server.SystemServiceManager;
		import com.android.server.ThreadPriorityBooster;
		import com.android.server.UserspaceRebootLogger;
		import com.android.server.Watchdog;
		import com.android.server.am.ComponentAliasResolver.Resolution;
		import com.android.server.am.LowMemDetector.MemFactor;
		@@ -2350,20 +2348,6 @@ public class ActivityManagerService extends IActivityManager.Stub
		}
		}

		private void maybeLogUserspaceRebootEvent() {
		if (!UserspaceRebootLogger.shouldLogUserspaceRebootEvent()) {
		return;
		}
		final int userId = mUserController.getCurrentUserId();
		if (userId != UserHandle.USER_SYSTEM) {
		// Only log for user0.
		return;
		}
		// TODO(b/148767783): should we check all profiles under user0?
		UserspaceRebootLogger.logEventAsync(StorageManager.isCeStorageUnlocked(userId),
		BackgroundThread.getExecutor());
		}

		/**
		* Encapsulates global settings related to hidden API enforcement behaviour, including tracking
		* the latest value via a content observer.
		@@ -5291,12 +5275,6 @@ public class ActivityManagerService extends IActivityManager.Stub
		// Start looking for apps that are abusing wake locks.
		Message nmsg = mHandler.obtainMessage(CHECK_EXCESSIVE_POWER_USE_MSG);
		mHandler.sendMessageDelayed(nmsg, mConstants.POWER_CHECK_INTERVAL);
		// Check if we are performing userspace reboot before setting sys.boot_completed to
		// avoid race with init reseting sys.init.userspace_reboot.in_progress once sys
		// .boot_completed is 1.
		if (InitProperties.userspace_reboot_in_progress().orElse(false)) {
		UserspaceRebootLogger.noteUserspaceRebootSuccess();
		}
		// Tell anyone interested that we are done booting!
		SystemProperties.set("sys.boot_completed", "1");
		SystemProperties.set("dev.bootcomplete", "1");
		@@ -5320,7 +5298,6 @@ public class ActivityManagerService extends IActivityManager.Stub
		}, mConstants.FULL_PSS_MIN_INTERVAL);
		}
		});
		maybeLogUserspaceRebootEvent();
		mUserController.scheduleStartProfiles();
		}
		// UART is on if init's console service is running, send a warning notification.

services/core/java/com/android/server/power/PowerManagerService.java

+1 −5

Original line number	Diff line number	Diff line
		@@ -97,7 +97,6 @@ import android.provider.DeviceConfigInterface;
		import android.provider.Settings;
		import android.provider.Settings.SettingNotFoundException;
		import android.service.dreams.DreamManagerInternal;
		import android.sysprop.InitProperties;
		import android.sysprop.PowerProperties;
		import android.util.ArrayMap;
		import android.util.IntArray;
		@@ -128,7 +127,6 @@ import com.android.server.RescueParty;
		import com.android.server.ServiceThread;
		import com.android.server.SystemService;
		import com.android.server.UiThread;
		import com.android.server.UserspaceRebootLogger;
		import com.android.server.Watchdog;
		import com.android.server.am.BatteryStatsService;
		import com.android.server.display.feature.DeviceConfigParameterProvider;
		@@ -1274,8 +1272,7 @@ public final class PowerManagerService extends SystemService
		mHalInteractiveModeEnabled = true;

		mWakefulnessRaw = WAKEFULNESS_AWAKE;
		sQuiescent = mSystemProperties.get(SYSTEM_PROPERTY_QUIESCENT, "0").equals("1")
		\|\| InitProperties.userspace_reboot_in_progress().orElse(false);
		sQuiescent = mSystemProperties.get(SYSTEM_PROPERTY_QUIESCENT, "0").equals("1");

		mNativeWrapper.nativeInit(this);
		mNativeWrapper.nativeSetAutoSuspend(false);
		@@ -4023,7 +4020,6 @@ public final class PowerManagerService extends SystemService
		throw new UnsupportedOperationException(
		"Attempted userspace reboot on a device that doesn't support it");
		}
		UserspaceRebootLogger.noteUserspaceRebootWasRequested();
		}
		if (mHandler == null \|\| !mSystemReady) {
		if (RescueParty.isRecoveryTriggeredReboot()) {