Merge "[Ravenwood] Cleanup initialization" into main (a39edd4d) · Commits · e / os / android_frameworks_base

core/java/android/util/EventLog_ravenwood.java

+2 −16

Original line number	Diff line number	Diff line
		@@ -15,9 +15,7 @@
		*/
		package android.util;

		import com.android.internal.os.RuntimeInit;

		import java.io.PrintStream;
		import android.platform.test.ravenwood.RavenwoodDriver;

		public class EventLog_ravenwood {
		public static int writeEvent(int tag, int value) {
		@@ -53,19 +51,7 @@ public class EventLog_ravenwood {
		}
		}
		sb.append(']');
		getRealOut().println(sb.toString());
		RavenwoodDriver.sRawStdOut.println(sb.toString());
		return sb.length();
		}

		/**
		* Return the "real" {@code System.out} if it's been swapped by {@code RavenwoodRuleImpl}, so
		* that we don't end up in a recursive loop.
		*/
		private static PrintStream getRealOut() {
		if (RuntimeInit.sOut$ravenwood != null) {
		return RuntimeInit.sOut$ravenwood;
		} else {
		return System.out;
		}
		}
		}

core/java/android/util/Log_ravenwood.java

+10 −32

Original line number	Diff line number	Diff line
		@@ -17,12 +17,12 @@ package android.util;

		import android.annotation.Nullable;
		import android.os.Process;
		import android.platform.test.ravenwood.RavenwoodDriver;
		import android.platform.test.ravenwood.RavenwoodEnvironment;
		import android.util.Log.Level;

		import com.android.internal.annotations.GuardedBy;
		import com.android.internal.os.RuntimeInit;

		import java.io.PrintStream;
		import java.text.SimpleDateFormat;
		import java.util.Date;
		import java.util.HashMap;
		@@ -43,6 +43,8 @@ public class Log_ravenwood {

		private static final Object sLock = new Object();

		public static volatile boolean sUseRealTid = false;

		@GuardedBy("sLock")
		private static int sDefaultLogLevel;

		@@ -147,7 +149,7 @@ public class Log_ravenwood {

		String leading = sTimestampFormat.format(new Date())
		+ " %-6d %-6d %s %-8s: ".formatted(getPid(), getTid(), prio, tag);
		var out = getRealOut();
		var out = RavenwoodDriver.sRawStdOut;
		for (String s : msg.split("\\n")) {
		out.print(leading);
		out.println(s);
		@@ -159,40 +161,16 @@ public class Log_ravenwood {
		return 4068; // [ravenwood] This is what people use in various places.
		}

		/**
		* Return the "real" {@code System.out} if it's been swapped by {@code RavenwoodRuleImpl}, so
		* that we don't end up in a recursive loop.
		*/
		public static PrintStream getRealOut() {
		if (RuntimeInit.sOut$ravenwood != null) {
		return RuntimeInit.sOut$ravenwood;
		} else {
		return System.out;
		}
		}

		/**
		* PID. Set from RavenwoodDriver
		*/
		private static volatile int sPid = 0;

		private static ThreadLocal<Integer> sTid = ThreadLocal.withInitial(Process::myTid);

		/**
		* Call it when PID is available.
		*/
		public static void setPid(int pid) {
		sPid = pid;
		}

		private static int getPid() {
		return sPid;
		return RavenwoodEnvironment.getInstance().getPid();
		}

		private static int getTid() {
		if (sPid == 0) {
		return 0; // Native methods not ready yet.
		}
		private static long getTid() {
		if (sUseRealTid) {
		return sTid.get();
		}
		return 0;
		}
		}

core/java/com/android/internal/os/RuntimeInit.java

+13 −40

Original line number	Diff line number	Diff line
		@@ -29,6 +29,9 @@ import android.os.IBinder;
		import android.os.Process;
		import android.os.SystemProperties;
		import android.os.Trace;
		import android.ravenwood.annotation.RavenwoodIgnore;
		import android.ravenwood.annotation.RavenwoodKeep;
		import android.ravenwood.annotation.RavenwoodKeepPartialClass;
		import android.util.Log;
		import android.util.Slog;

		@@ -39,7 +42,6 @@ import dalvik.system.VMRuntime;

		import libcore.content.type.MimeMap;

		import java.io.PrintStream;
		import java.lang.reflect.InvocationTargetException;
		import java.lang.reflect.Method;
		import java.lang.reflect.Modifier;
		@@ -51,7 +53,7 @@ import java.util.logging.LogManager;
		* public consumption.
		* @hide
		*/
		@android.ravenwood.annotation.RavenwoodKeepPartialClass
		@RavenwoodKeepPartialClass
		public class RuntimeInit {
		final static String TAG = "AndroidRuntime";
		final static boolean DEBUG = false;
		@@ -69,13 +71,6 @@ public class RuntimeInit {

		private static volatile ApplicationWtfHandler sDefaultApplicationWtfHandler;

		/**
		* Stored values of System.out and System.err before they've been replaced by
		* redirectLogStreams(). Kept open here for other Ravenwood internals to use.
		*/
		public static PrintStream sOut$ravenwood;
		public static PrintStream sErr$ravenwood;

		private static final native void nativeFinishInit();

		private static final native void nativeSetExitWithoutCleanup(boolean exitWithoutCleanup);
		@@ -394,38 +389,21 @@ public class RuntimeInit {
		return findStaticMain(args.startClass, args.startArgs, classLoader);
		}

		/**
		* Redirect System.out and System.err to the Android log.
		*/
		@android.ravenwood.annotation.RavenwoodReplace
		public static void redirectLogStreams() {
		@RavenwoodIgnore(reason = "We keep a backup of the original stdout and stderr")
		private static void closeLogStreams() {
		System.out.close();
		System.setOut(new AndroidPrintStream(Log.INFO, "System.out"));
		System.err.close();
		System.setErr(new AndroidPrintStream(Log.WARN, "System.err"));
		}

		public static void redirectLogStreams$ravenwood() {
		if (sOut$ravenwood != null && sErr$ravenwood != null) {
		return; // Already initialized.
		}

		// Make sure the Log class is loaded and the JNI methods are hooked up,
		// before redirecting System.out/err.
		// Otherwise, because ClassLoadHook tries to write to System.out, this would cause
		// a circular initialization problem and would cause a UnsatisfiedLinkError
		// on the JNI methods.
		Log.isLoggable("X", Log.VERBOSE);

		if (sOut$ravenwood == null) {
		sOut$ravenwood = System.out;
		/**
		* Redirect System.out and System.err to the Android log.
		*/
		@RavenwoodKeep
		public static void redirectLogStreams() {
		closeLogStreams();
		System.setOut(new AndroidPrintStream(Log.INFO, "System.out"));
		}
		if (sErr$ravenwood == null) {
		sErr$ravenwood = System.err;
		System.setErr(new AndroidPrintStream(Log.WARN, "System.err"));
		}
		}

		/**
		* Report a serious error in the current process. May or may not cause
		@@ -434,7 +412,7 @@ public class RuntimeInit {
		* @param tag to record with the error
		* @param t exception describing the error site and conditions
		*/
		@android.ravenwood.annotation.RavenwoodReplace
		@RavenwoodIgnore
		public static void wtf(String tag, Throwable t, boolean system) {
		try {
		boolean exit = false;
		@@ -472,11 +450,6 @@ public class RuntimeInit {
		}
		}

		public static void wtf$ravenwood(String tag, Throwable t, boolean system) {
		// We've already emitted to logs, so there's nothing more to do here,
		// as we don't have a DropBox pipeline configured
		}

		/**
		* Set the default {@link ApplicationWtfHandler}, in case the ActivityManager is not ready yet.
		*/

ravenwood/junit-impl-src/android/platform/test/ravenwood/RavenwoodDriver.java

+19 −12

Original line number	Diff line number	Diff line
		@@ -64,7 +64,6 @@ import java.util.HashMap;
		import java.util.Locale;
		import java.util.Map;
		import java.util.Objects;
		import java.util.Random;
		import java.util.regex.Pattern;
		import java.util.stream.Collectors;

		@@ -81,8 +80,8 @@ public class RavenwoodDriver {
		* The following 2 PrintStreams is a backup of the original stdin/stdout streams.
		* System.out/err will be modified after calling {@link RuntimeInit#redirectLogStreams()}.
		*/
		static final PrintStream sRawStdOut = System.out;
		static final PrintStream sRawStdErr = System.err;
		public static final PrintStream sRawStdOut = System.out;
		public static final PrintStream sRawStdErr = System.err;

		/**
		* The current directory when the test started.
		@@ -170,6 +169,12 @@ public class RavenwoodDriver {
		// We haven't initialized liblog yet, so directly write to System.out here.
		RavenwoodInternalUtils.log(TAG, "globalInitInner()");

		// Parse ravenwood properties and initialize the "environment".
		// This also unlocks the ability to use android.util.Log.
		var mainThread = new HandlerThread(RavenwoodEnvironment.MAIN_THREAD_NAME);
		RavenwoodEnvironment.init(mainThread);
		Log_ravenwood.setLogLevels(getLogTags());

		// Set up global error handling infrastructure
		RavenwoodErrorHandler.init();

		@@ -183,6 +188,7 @@ public class RavenwoodDriver {
		// Redirect stdout/stdin to the Log API.
		RuntimeInit.redirectLogStreams();

		dumpRavenwoodProperties();
		dumpCommandLineArgs();
		dumpEnvironment();
		dumpJavaProperties();
		@@ -194,19 +200,12 @@ public class RavenwoodDriver {
		// Make sure libravenwood_runtime is loaded.
		System.load(RavenwoodInternalUtils.getJniLibraryPath(RAVENWOOD_NATIVE_RUNTIME_NAME));

		// TODO: Why do we use a random PID? We can get the real PID via JNI. Why not use that?
		final int pid = new Random().nextInt(100, 32768);
		Log_ravenwood.setPid(pid);
		Log_ravenwood.setLogLevels(getLogTags());
		// We can start to use native code
		Log_ravenwood.sUseRealTid = true;

		// Do the basic set up for the android sysprops.
		RavenwoodSystemProperties.initialize();

		var mainThread = new HandlerThread(RavenwoodEnvironment.MAIN_THREAD_NAME);

		// Initialize the "environment".
		RavenwoodEnvironment.init(pid, mainThread);

		// Set ICU data file
		String icuData = getRavenwoodRuntimePath()
		+ "ravenwood-data/"
		@@ -366,6 +365,14 @@ public class RavenwoodDriver {
		}
		}

		private static void dumpRavenwoodProperties() {
		Log.i(TAG, "Ravenwood properties:");
		var env = RavenwoodEnvironment.getInstance();
		Log.i(TAG, " targetPackageName=" + env.getTargetPackageName());
		Log.i(TAG, " testPackageName=" + env.getInstPackageName());
		Log.i(TAG, " targetSdkLevel=" + env.getTargetSdkLevel());
		}

		private static void dumpJavaProperties() {
		Log.i(TAG, "JVM properties:");
		dumpMap(System.getProperties());

ravenwood/junit-impl-src/android/platform/test/ravenwood/RavenwoodEnvironment.java

+5 −6

Original line number	Diff line number	Diff line
		@@ -31,7 +31,6 @@ import android.app.ResourcesManager;
		import android.content.res.Resources;
		import android.os.Build;
		import android.os.HandlerThread;
		import android.util.Log;
		import android.view.DisplayAdjustments;

		import com.android.internal.annotations.GuardedBy;
		@@ -44,6 +43,7 @@ import java.nio.file.Files;
		import java.util.HashMap;
		import java.util.Map;
		import java.util.Objects;
		import java.util.Random;
		import java.util.concurrent.atomic.AtomicReference;

		/**
		@@ -159,18 +159,17 @@ public final class RavenwoodEnvironment {

		mRootDir = Files.createTempDirectory("ravenwood-root-dir-").toFile();
		mRootDir.mkdirs();

		Log.i(TAG, "TargetPackageName=" + mTargetPackageName);
		Log.i(TAG, "TestPackageName=" + mInstPackageName);
		Log.i(TAG, "TargetSdkLevel=" + mTargetSdkLevel);
		}

		/**
		* Create and initialize the singleton instance. Also initializes {@link RavenwoodVmState}.
		*/
		public static void init(int pid, HandlerThread mainThread) throws IOException {
		public static void init(HandlerThread mainThread) throws IOException {
		final var props = RavenwoodSystemProperties.readProperties("ravenwood.properties");

		// TODO: Why do we use a random PID? We can get the real PID via JNI. Why not use that?
		final int pid = new Random().nextInt(100, 32768);

		// TODO(b/377765941) Read them from the manifest too?
		var targetSdkLevel = withDefault(
		parseNullableInt(props.get("targetSdkVersionInt")), DEFAULT_TARGET_SDK_LEVEL);