dalvik/src/main/java/dalvik/system/Zygote.java - platform/libcore-snapshot - Git at Google

 /*
  * Copyright (C) 2006 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 dalvik.system;

 import java.io.File;

 /**
  * Provides access to the Dalvik "zygote" feature, which allows a VM instance to
  * be partially initialized and then fork()'d from the partially initialized
  * state.
  *
  * @hide
  */
 public class Zygote {
     /*
      * Bit values for "debugFlags" argument.  The definitions are duplicated
      * in the native code.
      */
     /** enable debugging over JDWP */
     public static final int DEBUG_ENABLE_DEBUGGER   = 1;
     /** enable JNI checks */
     public static final int DEBUG_ENABLE_CHECKJNI   = 1 << 1;
     /** enable Java programming language "assert" statements */
     public static final int DEBUG_ENABLE_ASSERT     = 1 << 2;
     /** disable the JIT compiler */
     public static final int DEBUG_ENABLE_SAFEMODE   = 1 << 3;
     /** Enable logging of third-party JNI activity. */
     public static final int DEBUG_ENABLE_JNI_LOGGING = 1 << 4;

     /**
      * When set by the system server, all subsequent apps will be launched in
      * VM safe mode.
      */
     public static boolean systemInSafeMode = false;

     private Zygote() {}

     private static void preFork() {
         Daemons.stop();
         waitUntilAllThreadsStopped();
     }

     /**
      * We must not fork until we're single-threaded again. Wait until /proc shows we're
      * down to just one thread.
      */
     private static void waitUntilAllThreadsStopped() {
         File tasks = new File("/proc/self/task");
         while (tasks.list().length > 1) {
             try {
                 // Experimentally, booting and playing about with a stingray, I never saw us
                 // go round this loop more than once with a 10ms sleep.
                 Thread.sleep(10);
             } catch (InterruptedException ignored) {
             }
         }
     }

     private static void postFork() {
         Daemons.start();
     }

     /**
      * Forks a new Zygote instance, but does not leave the zygote mode.
      * The current VM must have been started with the -Xzygote flag. The
      * new child is expected to eventually call forkAndSpecialize()
      *
      * @return 0 if this is the child, pid of the child
      * if this is the parent, or -1 on error
      */
     public static int fork() {
         preFork();
         int pid = nativeFork();
         postFork();
         return pid;
     }

     native public static int nativeFork();

     /**
      * Forks a new VM instance.  The current VM must have been started
      * with the -Xzygote flag. <b>NOTE: new instance keeps all
      * root capabilities. The new process is expected to call capset()</b>.
      *
      * @param uid the UNIX uid that the new process should setuid() to after
      * fork()ing and and before spawning any threads.
      * @param gid the UNIX gid that the new process should setgid() to after
      * fork()ing and and before spawning any threads.
      * @param gids null-ok; a list of UNIX gids that the new process should
      * setgroups() to after fork and before spawning any threads.
      * @param debugFlags bit flags that enable debugging features.
      * @param rlimits null-ok an array of rlimit tuples, with the second
      * dimension having a length of 3 and representing
      * (resource, rlim_cur, rlim_max). These are set via the posix
      * setrlimit(2) call.
      *
      * @return 0 if this is the child, pid of the child
      * if this is the parent, or -1 on error.
      */
     public static int forkAndSpecialize(int uid, int gid, int[] gids,
             int debugFlags, int[][] rlimits) {
         preFork();
         int pid = nativeForkAndSpecialize(uid, gid, gids, debugFlags, rlimits);
         postFork();
         return pid;
     }

     native public static int nativeForkAndSpecialize(int uid, int gid,
             int[] gids, int debugFlags, int[][] rlimits);

     /**
      * Forks a new VM instance.
      * @deprecated use {@link Zygote#forkAndSpecialize(int, int, int[], int, int[][])}
      */
     @Deprecated
     public static int forkAndSpecialize(int uid, int gid, int[] gids,
             boolean enableDebugger, int[][] rlimits) {
         int debugFlags = enableDebugger ? DEBUG_ENABLE_DEBUGGER : 0;
         return forkAndSpecialize(uid, gid, gids, debugFlags, rlimits);
     }

     /**
      * Special method to start the system server process. In addition to the
      * common actions performed in forkAndSpecialize, the pid of the child
      * process is recorded such that the death of the child process will cause
      * zygote to exit.
      *
      * @param uid the UNIX uid that the new process should setuid() to after
      * fork()ing and and before spawning any threads.
      * @param gid the UNIX gid that the new process should setgid() to after
      * fork()ing and and before spawning any threads.
      * @param gids null-ok; a list of UNIX gids that the new process should
      * setgroups() to after fork and before spawning any threads.
      * @param debugFlags bit flags that enable debugging features.
      * @param rlimits null-ok an array of rlimit tuples, with the second
      * dimension having a length of 3 and representing
      * (resource, rlim_cur, rlim_max). These are set via the posix
      * setrlimit(2) call.
      * @param permittedCapabilities argument for setcap()
      * @param effectiveCapabilities argument for setcap()
      *
      * @return 0 if this is the child, pid of the child
      * if this is the parent, or -1 on error.
      */
     public static int forkSystemServer(int uid, int gid, int[] gids,
             int debugFlags, int[][] rlimits,
             long permittedCapabilities, long effectiveCapabilities) {
         preFork();
         int pid = nativeForkSystemServer(uid, gid, gids, debugFlags, rlimits,
                                          permittedCapabilities,
                                          effectiveCapabilities);
         postFork();
         return pid;
     }

     /**
      * Special method to start the system server process.
      * @deprecated use {@link Zygote#forkSystemServer(int, int, int[], int, int[][])}
      */
     @Deprecated
     public static int forkSystemServer(int uid, int gid, int[] gids,
             boolean enableDebugger, int[][] rlimits) {
         int debugFlags = enableDebugger ? DEBUG_ENABLE_DEBUGGER : 0;
         return forkAndSpecialize(uid, gid, gids, debugFlags, rlimits);
     }

     native public static int nativeForkSystemServer(int uid, int gid,
             int[] gids, int debugFlags, int[][] rlimits,
             long permittedCapabilities, long effectiveCapabilities);

     /**
      * Executes "/system/bin/sh -c &lt;command&gt;" using the exec() system call.
      * This method never returns.
      *
      * @param command The shell command to execute.
      */
     public static void execShell(String command) {
         nativeExecShell(command);
     }

     /**
      * Appends quotes shell arguments to the specified string builder.
      * The arguments are quoted using single-quotes, escaped if necessary,
      * prefixed with a space, and appended to the command.
      *
      * @param command A string builder for the shell command being constructed.
      * @param args An array of argument strings to be quoted and appended to the command.
      * @see #execShell(String)
      */
     public static void appendQuotedShellArgs(StringBuilder command, String[] args) {
         for (String arg : args) {
             command.append(" '").append(arg.replace("'", "'\\''")).append("'");
         }
     }

     native private static void nativeExecShell(String command);
 }
	/*
	* Copyright (C) 2006 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 dalvik.system;

	import java.io.File;

	/**
	* Provides access to the Dalvik "zygote" feature, which allows a VM instance to
	* be partially initialized and then fork()'d from the partially initialized
	* state.
	*
	* @hide
	*/
	public class Zygote {
	/*
	* Bit values for "debugFlags" argument. The definitions are duplicated
	* in the native code.
	*/
	/** enable debugging over JDWP */
	public static final int DEBUG_ENABLE_DEBUGGER = 1;
	/** enable JNI checks */
	public static final int DEBUG_ENABLE_CHECKJNI = 1 << 1;
	/** enable Java programming language "assert" statements */
	public static final int DEBUG_ENABLE_ASSERT = 1 << 2;
	/** disable the JIT compiler */
	public static final int DEBUG_ENABLE_SAFEMODE = 1 << 3;
	/** Enable logging of third-party JNI activity. */
	public static final int DEBUG_ENABLE_JNI_LOGGING = 1 << 4;

	/**
	* When set by the system server, all subsequent apps will be launched in
	* VM safe mode.
	*/
	public static boolean systemInSafeMode = false;

	private Zygote() {}

	private static void preFork() {
	Daemons.stop();
	waitUntilAllThreadsStopped();
	}

	/**
	* We must not fork until we're single-threaded again. Wait until /proc shows we're
	* down to just one thread.
	*/
	private static void waitUntilAllThreadsStopped() {
	File tasks = new File("/proc/self/task");
	while (tasks.list().length > 1) {
	try {
	// Experimentally, booting and playing about with a stingray, I never saw us
	// go round this loop more than once with a 10ms sleep.
	Thread.sleep(10);
	} catch (InterruptedException ignored) {
	}
	}
	}

	private static void postFork() {
	Daemons.start();
	}

	/**
	* Forks a new Zygote instance, but does not leave the zygote mode.
	* The current VM must have been started with the -Xzygote flag. The
	* new child is expected to eventually call forkAndSpecialize()
	*
	* @return 0 if this is the child, pid of the child
	* if this is the parent, or -1 on error
	*/
	public static int fork() {
	preFork();
	int pid = nativeFork();
	postFork();
	return pid;
	}

	native public static int nativeFork();

	/**
	* Forks a new VM instance. The current VM must have been started
	* with the -Xzygote flag. <b>NOTE: new instance keeps all
	* root capabilities. The new process is expected to call capset()</b>.
	*
	* @param uid the UNIX uid that the new process should setuid() to after
	* fork()ing and and before spawning any threads.
	* @param gid the UNIX gid that the new process should setgid() to after
	* fork()ing and and before spawning any threads.
	* @param gids null-ok; a list of UNIX gids that the new process should
	* setgroups() to after fork and before spawning any threads.
	* @param debugFlags bit flags that enable debugging features.
	* @param rlimits null-ok an array of rlimit tuples, with the second
	* dimension having a length of 3 and representing
	* (resource, rlim_cur, rlim_max). These are set via the posix
	* setrlimit(2) call.
	*
	* @return 0 if this is the child, pid of the child
	* if this is the parent, or -1 on error.
	*/
	public static int forkAndSpecialize(int uid, int gid, int[] gids,
	int debugFlags, int[][] rlimits) {
	preFork();
	int pid = nativeForkAndSpecialize(uid, gid, gids, debugFlags, rlimits);
	postFork();
	return pid;
	}

	native public static int nativeForkAndSpecialize(int uid, int gid,
	int[] gids, int debugFlags, int[][] rlimits);

	/**
	* Forks a new VM instance.
	* @deprecated use {@link Zygote#forkAndSpecialize(int, int, int[], int, int[][])}
	*/
	@Deprecated
	public static int forkAndSpecialize(int uid, int gid, int[] gids,
	boolean enableDebugger, int[][] rlimits) {
	int debugFlags = enableDebugger ? DEBUG_ENABLE_DEBUGGER : 0;
	return forkAndSpecialize(uid, gid, gids, debugFlags, rlimits);
	}

	/**
	* Special method to start the system server process. In addition to the
	* common actions performed in forkAndSpecialize, the pid of the child
	* process is recorded such that the death of the child process will cause
	* zygote to exit.
	*
	* @param uid the UNIX uid that the new process should setuid() to after
	* fork()ing and and before spawning any threads.
	* @param gid the UNIX gid that the new process should setgid() to after
	* fork()ing and and before spawning any threads.
	* @param gids null-ok; a list of UNIX gids that the new process should
	* setgroups() to after fork and before spawning any threads.
	* @param debugFlags bit flags that enable debugging features.
	* @param rlimits null-ok an array of rlimit tuples, with the second
	* dimension having a length of 3 and representing
	* (resource, rlim_cur, rlim_max). These are set via the posix
	* setrlimit(2) call.
	* @param permittedCapabilities argument for setcap()
	* @param effectiveCapabilities argument for setcap()
	*
	* @return 0 if this is the child, pid of the child
	* if this is the parent, or -1 on error.
	*/
	public static int forkSystemServer(int uid, int gid, int[] gids,
	int debugFlags, int[][] rlimits,
	long permittedCapabilities, long effectiveCapabilities) {
	preFork();
	int pid = nativeForkSystemServer(uid, gid, gids, debugFlags, rlimits,
	permittedCapabilities,
	effectiveCapabilities);
	postFork();
	return pid;
	}

	/**
	* Special method to start the system server process.
	* @deprecated use {@link Zygote#forkSystemServer(int, int, int[], int, int[][])}
	*/
	@Deprecated
	public static int forkSystemServer(int uid, int gid, int[] gids,
	boolean enableDebugger, int[][] rlimits) {
	int debugFlags = enableDebugger ? DEBUG_ENABLE_DEBUGGER : 0;
	return forkAndSpecialize(uid, gid, gids, debugFlags, rlimits);
	}

	native public static int nativeForkSystemServer(int uid, int gid,
	int[] gids, int debugFlags, int[][] rlimits,
	long permittedCapabilities, long effectiveCapabilities);

	/**
	* Executes "/system/bin/sh -c <command>" using the exec() system call.
	* This method never returns.
	*
	* @param command The shell command to execute.
	*/
	public static void execShell(String command) {
	nativeExecShell(command);
	}

	/**
	* Appends quotes shell arguments to the specified string builder.
	* The arguments are quoted using single-quotes, escaped if necessary,
	* prefixed with a space, and appended to the command.
	*
	* @param command A string builder for the shell command being constructed.
	* @param args An array of argument strings to be quoted and appended to the command.
	* @see #execShell(String)
	*/
	public static void appendQuotedShellArgs(StringBuilder command, String[] args) {
	for (String arg : args) {
	command.append(" '").append(arg.replace("'", "'\\''")).append("'");
	}
	}

	native private static void nativeExecShell(String command);
	}