1719 lines
68 KiB
Java
1719 lines
68 KiB
Java
|
/*
|
||
|
|
* Copyright (C) 2021 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 android.system.virtualmachine;
|
||
|
|
|
||
|
|
import static android.os.ParcelFileDescriptor.AutoCloseInputStream;
|
||
|
|
import static android.os.ParcelFileDescriptor.MODE_READ_ONLY;
|
||
|
|
import static android.os.ParcelFileDescriptor.MODE_READ_WRITE;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.ERROR_PAYLOAD_CHANGED;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.ERROR_PAYLOAD_INVALID_CONFIG;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.ERROR_PAYLOAD_VERIFICATION_FAILED;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.ERROR_UNKNOWN;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_CRASH;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_HANGUP;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_INFRASTRUCTURE_ERROR;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_KILLED;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_MICRODROID_INVALID_PAYLOAD_CONFIG;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_MICRODROID_PAYLOAD_HAS_CHANGED;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_MICRODROID_PAYLOAD_VERIFICATION_FAILED;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_MICRODROID_UNKNOWN_RUNTIME_ERROR;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_PVM_FIRMWARE_PUBLIC_KEY_MISMATCH;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_REBOOT;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_SHUTDOWN;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_START_FAILED;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_UNKNOWN;
|
||
|
|
import static android.system.virtualmachine.VirtualMachineCallback.STOP_REASON_VIRTUALIZATION_SERVICE_DIED;
|
||
|
|
|
||
|
|
import static java.util.Objects.requireNonNull;
|
||
|
|
|
||
|
|
import android.annotation.FlaggedApi;
|
||
|
|
import android.annotation.CallbackExecutor;
|
||
|
|
import android.annotation.IntDef;
|
||
|
|
import android.annotation.IntRange;
|
||
|
|
import android.annotation.NonNull;
|
||
|
|
import android.annotation.Nullable;
|
||
|
|
import android.annotation.RequiresPermission;
|
||
|
|
import android.annotation.SuppressLint;
|
||
|
|
import android.annotation.SystemApi;
|
||
|
|
import android.annotation.TestApi;
|
||
|
|
import android.annotation.WorkerThread;
|
||
|
|
import android.content.ComponentCallbacks2;
|
||
|
|
import android.content.Context;
|
||
|
|
import android.content.pm.ApplicationInfo;
|
||
|
|
import android.content.pm.PackageManager;
|
||
|
|
import android.content.res.Configuration;
|
||
|
|
import android.os.Binder;
|
||
|
|
import android.os.IBinder;
|
||
|
|
import android.os.ParcelFileDescriptor;
|
||
|
|
import android.os.RemoteException;
|
||
|
|
import android.os.ServiceSpecificException;
|
||
|
|
import android.view.KeyEvent;
|
||
|
|
import android.view.MotionEvent;
|
||
|
|
import android.system.virtualizationcommon.DeathReason;
|
||
|
|
import android.system.virtualizationcommon.ErrorCode;
|
||
|
|
import android.system.virtualizationservice.IVirtualMachine;
|
||
|
|
import android.system.virtualizationservice.IVirtualMachineCallback;
|
||
|
|
import android.system.virtualizationservice.IVirtualizationService;
|
||
|
|
import android.system.virtualizationservice.InputDevice;
|
||
|
|
import android.system.virtualizationservice.MemoryTrimLevel;
|
||
|
|
import android.system.virtualizationservice.PartitionType;
|
||
|
|
import android.system.virtualizationservice.VirtualMachineAppConfig;
|
||
|
|
import android.system.virtualizationservice.VirtualMachineRawConfig;
|
||
|
|
import android.system.virtualizationservice.VirtualMachineState;
|
||
|
|
import android.util.JsonReader;
|
||
|
|
import android.util.Log;
|
||
|
|
|
||
|
|
import com.android.internal.annotations.GuardedBy;
|
||
|
|
import com.android.system.virtualmachine.flags.Flags;
|
||
|
|
|
||
|
|
import libcore.io.IoBridge;
|
||
|
|
|
||
|
|
import java.io.File;
|
||
|
|
import java.io.FileInputStream;
|
||
|
|
import java.io.FileNotFoundException;
|
||
|
|
import java.io.FileOutputStream;
|
||
|
|
import java.io.IOException;
|
||
|
|
import java.io.InputStream;
|
||
|
|
import java.io.InputStreamReader;
|
||
|
|
import java.io.OutputStream;
|
||
|
|
import java.lang.annotation.Retention;
|
||
|
|
import java.lang.annotation.RetentionPolicy;
|
||
|
|
import java.nio.ByteBuffer;
|
||
|
|
import java.nio.ByteOrder;
|
||
|
|
import java.nio.channels.FileChannel;
|
||
|
|
import java.nio.file.FileAlreadyExistsException;
|
||
|
|
import java.nio.file.FileVisitResult;
|
||
|
|
import java.nio.file.Files;
|
||
|
|
import java.nio.file.Path;
|
||
|
|
import java.nio.file.SimpleFileVisitor;
|
||
|
|
import java.nio.file.attribute.BasicFileAttributes;
|
||
|
|
import java.util.Arrays;
|
||
|
|
import java.util.ArrayList;
|
||
|
|
import java.util.Collections;
|
||
|
|
import java.util.List;
|
||
|
|
import java.util.concurrent.Executor;
|
||
|
|
import java.util.concurrent.atomic.AtomicBoolean;
|
||
|
|
import java.util.function.Consumer;
|
||
|
|
import java.util.zip.ZipFile;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Represents an VM instance, with its own configuration and state. Instances are persistent and are
|
||
|
|
* created or retrieved via {@link VirtualMachineManager}.
|
||
|
|
*
|
||
|
|
* <p>The {@link #run} method actually starts up the VM and allows the payload code to execute. It
|
||
|
|
* will continue until it exits or {@link #stop} is called. Updates on the state of the VM can be
|
||
|
|
* received using {@link #setCallback}. The app can communicate with the VM using {@link
|
||
|
|
* #connectToVsockServer} or {@link #connectVsock}.
|
||
|
|
*
|
||
|
|
* <p>The payload code running inside the VM has access to a set of native APIs; see the <a
|
||
|
|
* href="https://cs.android.com/android/platform/superproject/+/master:packages/modules/Virtualization/vm_payload/README.md">README
|
||
|
|
* file</a> for details.
|
||
|
|
*
|
||
|
|
* <p>Each VM has a unique secret, computed from the APK that contains the code running in it, the
|
||
|
|
* VM configuration, and a random per-instance salt. The secret can be accessed by the payload code
|
||
|
|
* running inside the VM (using {@code AVmPayload_getVmInstanceSecret}) but is not made available
|
||
|
|
* outside it.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
public class VirtualMachine implements AutoCloseable {
|
||
|
|
/** The permission needed to create or run a virtual machine. */
|
||
|
|
public static final String MANAGE_VIRTUAL_MACHINE_PERMISSION =
|
||
|
|
"android.permission.MANAGE_VIRTUAL_MACHINE";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The permission needed to create a virtual machine with more advanced configuration options.
|
||
|
|
*/
|
||
|
|
public static final String USE_CUSTOM_VIRTUAL_MACHINE_PERMISSION =
|
||
|
|
"android.permission.USE_CUSTOM_VIRTUAL_MACHINE";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The lowest port number that can be used to communicate with the virtual machine payload.
|
||
|
|
*
|
||
|
|
* @see #connectToVsockServer
|
||
|
|
* @see #connectVsock
|
||
|
|
*/
|
||
|
|
@SuppressLint("MinMaxConstant") // Won't change: see man 7 vsock.
|
||
|
|
public static final long MIN_VSOCK_PORT = 1024;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The highest port number that can be used to communicate with the virtual machine payload.
|
||
|
|
*
|
||
|
|
* @see #connectToVsockServer
|
||
|
|
* @see #connectVsock
|
||
|
|
*/
|
||
|
|
@SuppressLint("MinMaxConstant") // Won't change: see man 7 vsock.
|
||
|
|
public static final long MAX_VSOCK_PORT = (1L << 32) - 1;
|
||
|
|
|
||
|
|
private ParcelFileDescriptor mTouchSock;
|
||
|
|
private ParcelFileDescriptor mKeySock;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Status of a virtual machine
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@Retention(RetentionPolicy.SOURCE)
|
||
|
|
@IntDef(prefix = "STATUS_", value = {
|
||
|
|
STATUS_STOPPED,
|
||
|
|
STATUS_RUNNING,
|
||
|
|
STATUS_DELETED
|
||
|
|
})
|
||
|
|
public @interface Status {}
|
||
|
|
|
||
|
|
/** The virtual machine has just been created, or {@link #stop} was called on it. */
|
||
|
|
public static final int STATUS_STOPPED = 0;
|
||
|
|
|
||
|
|
/** The virtual machine is running. */
|
||
|
|
public static final int STATUS_RUNNING = 1;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The virtual machine has been deleted. This is an irreversible state. Once a virtual machine
|
||
|
|
* is deleted all its secrets are permanently lost, and it cannot be run. A new virtual machine
|
||
|
|
* with the same name and config may be created, with new and different secrets.
|
||
|
|
*/
|
||
|
|
public static final int STATUS_DELETED = 2;
|
||
|
|
|
||
|
|
private static final String TAG = "VirtualMachine";
|
||
|
|
|
||
|
|
/** Name of the directory under the files directory where all VMs created for the app exist. */
|
||
|
|
private static final String VM_DIR = "vm";
|
||
|
|
|
||
|
|
/** Name of the persisted config file for a VM. */
|
||
|
|
private static final String CONFIG_FILE = "config.xml";
|
||
|
|
|
||
|
|
/** Name of the instance image file for a VM. (Not implemented) */
|
||
|
|
private static final String INSTANCE_IMAGE_FILE = "instance.img";
|
||
|
|
|
||
|
|
/** Name of the file for a VM containing Id. */
|
||
|
|
private static final String INSTANCE_ID_FILE = "instance_id";
|
||
|
|
|
||
|
|
/** Name of the idsig file for a VM */
|
||
|
|
private static final String IDSIG_FILE = "idsig";
|
||
|
|
|
||
|
|
/** Name of the idsig files for extra APKs. */
|
||
|
|
private static final String EXTRA_IDSIG_FILE_PREFIX = "extra_idsig_";
|
||
|
|
|
||
|
|
/** Size of the instance image. 10 MB. */
|
||
|
|
private static final long INSTANCE_FILE_SIZE = 10 * 1024 * 1024;
|
||
|
|
|
||
|
|
/** Name of the file backing the encrypted storage */
|
||
|
|
private static final String ENCRYPTED_STORE_FILE = "storage.img";
|
||
|
|
|
||
|
|
/** The package which owns this VM. */
|
||
|
|
@NonNull private final String mPackageName;
|
||
|
|
|
||
|
|
/** Name of this VM within the package. The name should be unique in the package. */
|
||
|
|
@NonNull private final String mName;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Path to the directory containing all the files related to this VM.
|
||
|
|
*/
|
||
|
|
@NonNull private final File mVmRootPath;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Path to the config file for this VM. The config file is where the configuration is persisted.
|
||
|
|
*/
|
||
|
|
@NonNull private final File mConfigFilePath;
|
||
|
|
|
||
|
|
/** Path to the instance image file for this VM. */
|
||
|
|
@NonNull private final File mInstanceFilePath;
|
||
|
|
|
||
|
|
/** Path to the idsig file for this VM. */
|
||
|
|
@NonNull private final File mIdsigFilePath;
|
||
|
|
|
||
|
|
/** File that backs the encrypted storage - Will be null if not enabled. */
|
||
|
|
@Nullable private final File mEncryptedStoreFilePath;
|
||
|
|
|
||
|
|
/** File that contains the Id. This is NULL iff FEATURE_LLPVM is disabled */
|
||
|
|
@Nullable private final File mInstanceIdPath;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Unmodifiable list of extra apks. Apks are specified by the vm config, and corresponding
|
||
|
|
* idsigs are to be generated.
|
||
|
|
*/
|
||
|
|
@NonNull private final List<ExtraApkSpec> mExtraApks;
|
||
|
|
|
||
|
|
private class MemoryManagementCallbacks implements ComponentCallbacks2 {
|
||
|
|
@Override
|
||
|
|
public void onConfigurationChanged(@NonNull Configuration newConfig) {}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void onLowMemory() {}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void onTrimMemory(int level) {
|
||
|
|
@MemoryTrimLevel int vmTrimLevel;
|
||
|
|
|
||
|
|
switch (level) {
|
||
|
|
case ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL:
|
||
|
|
vmTrimLevel = MemoryTrimLevel.TRIM_MEMORY_RUNNING_CRITICAL;
|
||
|
|
break;
|
||
|
|
case ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW:
|
||
|
|
vmTrimLevel = MemoryTrimLevel.TRIM_MEMORY_RUNNING_LOW;
|
||
|
|
break;
|
||
|
|
case ComponentCallbacks2.TRIM_MEMORY_RUNNING_MODERATE:
|
||
|
|
vmTrimLevel = MemoryTrimLevel.TRIM_MEMORY_RUNNING_MODERATE;
|
||
|
|
break;
|
||
|
|
case ComponentCallbacks2.TRIM_MEMORY_BACKGROUND:
|
||
|
|
case ComponentCallbacks2.TRIM_MEMORY_MODERATE:
|
||
|
|
case ComponentCallbacks2.TRIM_MEMORY_COMPLETE:
|
||
|
|
/* Release as much memory as we can. The app is on the LMKD LRU kill list. */
|
||
|
|
vmTrimLevel = MemoryTrimLevel.TRIM_MEMORY_RUNNING_CRITICAL;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
/* Treat unrecognised messages as generic low-memory warnings. */
|
||
|
|
vmTrimLevel = MemoryTrimLevel.TRIM_MEMORY_RUNNING_LOW;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
synchronized (mLock) {
|
||
|
|
try {
|
||
|
|
if (mVirtualMachine != null) {
|
||
|
|
mVirtualMachine.onTrimMemory(vmTrimLevel);
|
||
|
|
}
|
||
|
|
} catch (Exception e) {
|
||
|
|
/* Caller doesn't want our exceptions. Log them instead. */
|
||
|
|
Log.w(TAG, "TrimMemory failed: ", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Running instance of virtmgr that hosts VirtualizationService for this VM. */
|
||
|
|
@NonNull private final VirtualizationService mVirtualizationService;
|
||
|
|
|
||
|
|
@NonNull private final MemoryManagementCallbacks mMemoryManagementCallbacks;
|
||
|
|
|
||
|
|
@NonNull private final Context mContext;
|
||
|
|
|
||
|
|
// A note on lock ordering:
|
||
|
|
// You can take mLock while holding VirtualMachineManager.sCreateLock, but not vice versa.
|
||
|
|
// We never take any other lock while holding mCallbackLock; therefore you can
|
||
|
|
// take mCallbackLock while holding any other lock.
|
||
|
|
|
||
|
|
/** Lock protecting our mutable state (other than callbacks). */
|
||
|
|
private final Object mLock = new Object();
|
||
|
|
|
||
|
|
/** Lock protecting callbacks. */
|
||
|
|
private final Object mCallbackLock = new Object();
|
||
|
|
|
||
|
|
private final boolean mVmOutputCaptured;
|
||
|
|
|
||
|
|
private final boolean mVmConsoleInputSupported;
|
||
|
|
|
||
|
|
/** The configuration that is currently associated with this VM. */
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
@NonNull
|
||
|
|
private VirtualMachineConfig mConfig;
|
||
|
|
|
||
|
|
/** Handle to the "running" VM. */
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
@Nullable
|
||
|
|
private IVirtualMachine mVirtualMachine;
|
||
|
|
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
@Nullable
|
||
|
|
private ParcelFileDescriptor mConsoleOutReader;
|
||
|
|
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
@Nullable
|
||
|
|
private ParcelFileDescriptor mConsoleOutWriter;
|
||
|
|
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
@Nullable
|
||
|
|
private ParcelFileDescriptor mConsoleInReader;
|
||
|
|
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
@Nullable
|
||
|
|
private ParcelFileDescriptor mConsoleInWriter;
|
||
|
|
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
@Nullable
|
||
|
|
private ParcelFileDescriptor mLogReader;
|
||
|
|
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
@Nullable
|
||
|
|
private ParcelFileDescriptor mLogWriter;
|
||
|
|
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
private boolean mWasDeleted = false;
|
||
|
|
|
||
|
|
/** The registered callback */
|
||
|
|
@GuardedBy("mCallbackLock")
|
||
|
|
@Nullable
|
||
|
|
private VirtualMachineCallback mCallback;
|
||
|
|
|
||
|
|
/** The executor on which the callback will be executed */
|
||
|
|
@GuardedBy("mCallbackLock")
|
||
|
|
@Nullable
|
||
|
|
private Executor mCallbackExecutor;
|
||
|
|
|
||
|
|
private static class ExtraApkSpec {
|
||
|
|
public final File apk;
|
||
|
|
public final File idsig;
|
||
|
|
|
||
|
|
ExtraApkSpec(File apk, File idsig) {
|
||
|
|
this.apk = apk;
|
||
|
|
this.idsig = idsig;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static {
|
||
|
|
System.loadLibrary("virtualmachine_jni");
|
||
|
|
}
|
||
|
|
|
||
|
|
private VirtualMachine(
|
||
|
|
@NonNull Context context,
|
||
|
|
@NonNull String name,
|
||
|
|
@NonNull VirtualMachineConfig config,
|
||
|
|
@NonNull VirtualizationService service)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
mPackageName = context.getPackageName();
|
||
|
|
mName = requireNonNull(name, "Name must not be null");
|
||
|
|
mConfig = requireNonNull(config, "Config must not be null");
|
||
|
|
mVirtualizationService = service;
|
||
|
|
|
||
|
|
File thisVmDir = getVmDir(context, mName);
|
||
|
|
mVmRootPath = thisVmDir;
|
||
|
|
mConfigFilePath = new File(thisVmDir, CONFIG_FILE);
|
||
|
|
try {
|
||
|
|
mInstanceIdPath =
|
||
|
|
(mVirtualizationService
|
||
|
|
.getBinder()
|
||
|
|
.isFeatureEnabled(IVirtualizationService.FEATURE_LLPVM_CHANGES))
|
||
|
|
? new File(thisVmDir, INSTANCE_ID_FILE)
|
||
|
|
: null;
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
}
|
||
|
|
mInstanceFilePath = new File(thisVmDir, INSTANCE_IMAGE_FILE);
|
||
|
|
mIdsigFilePath = new File(thisVmDir, IDSIG_FILE);
|
||
|
|
mExtraApks = setupExtraApks(context, config, thisVmDir);
|
||
|
|
mMemoryManagementCallbacks = new MemoryManagementCallbacks();
|
||
|
|
mContext = context;
|
||
|
|
mEncryptedStoreFilePath =
|
||
|
|
(config.isEncryptedStorageEnabled())
|
||
|
|
? new File(thisVmDir, ENCRYPTED_STORE_FILE)
|
||
|
|
: null;
|
||
|
|
|
||
|
|
mVmOutputCaptured = config.isVmOutputCaptured();
|
||
|
|
mVmConsoleInputSupported = config.isVmConsoleInputSupported();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a virtual machine from an {@link VirtualMachineDescriptor} object and associates it
|
||
|
|
* with the given name.
|
||
|
|
*
|
||
|
|
* <p>The new virtual machine will be in the same state as the descriptor indicates.
|
||
|
|
*
|
||
|
|
* <p>Once a virtual machine is imported it is persisted until it is deleted by calling {@link
|
||
|
|
* #delete}. The imported virtual machine is in {@link #STATUS_STOPPED} state. To run the VM,
|
||
|
|
* call {@link #run}.
|
||
|
|
*/
|
||
|
|
@GuardedBy("VirtualMachineManager.sCreateLock")
|
||
|
|
@NonNull
|
||
|
|
static VirtualMachine fromDescriptor(
|
||
|
|
@NonNull Context context,
|
||
|
|
@NonNull String name,
|
||
|
|
@NonNull VirtualMachineDescriptor vmDescriptor)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
File vmDir = createVmDir(context, name);
|
||
|
|
try {
|
||
|
|
VirtualMachine vm;
|
||
|
|
try (vmDescriptor) {
|
||
|
|
VirtualMachineConfig config = VirtualMachineConfig.from(vmDescriptor.getConfigFd());
|
||
|
|
vm = new VirtualMachine(context, name, config, VirtualizationService.getInstance());
|
||
|
|
config.serialize(vm.mConfigFilePath);
|
||
|
|
try {
|
||
|
|
vm.mInstanceFilePath.createNewFile();
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException("failed to create instance image", e);
|
||
|
|
}
|
||
|
|
vm.importInstanceFrom(vmDescriptor.getInstanceImgFd());
|
||
|
|
|
||
|
|
if (vmDescriptor.getEncryptedStoreFd() != null) {
|
||
|
|
try {
|
||
|
|
vm.mEncryptedStoreFilePath.createNewFile();
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException(
|
||
|
|
"failed to create encrypted storage image", e);
|
||
|
|
}
|
||
|
|
vm.importEncryptedStoreFrom(vmDescriptor.getEncryptedStoreFd());
|
||
|
|
}
|
||
|
|
if (vm.mInstanceIdPath != null) {
|
||
|
|
vm.importInstanceIdFrom(vmDescriptor.getInstanceIdFd());
|
||
|
|
vm.claimInstance();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return vm;
|
||
|
|
} catch (VirtualMachineException | RuntimeException e) {
|
||
|
|
// If anything goes wrong, delete any files created so far and the VM's directory
|
||
|
|
try {
|
||
|
|
deleteRecursively(vmDir);
|
||
|
|
} catch (Exception innerException) {
|
||
|
|
e.addSuppressed(innerException);
|
||
|
|
}
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a virtual machine with the given name and config. Once a virtual machine is created
|
||
|
|
* it is persisted until it is deleted by calling {@link #delete}. The created virtual machine
|
||
|
|
* is in {@link #STATUS_STOPPED} state. To run the VM, call {@link #run}.
|
||
|
|
*/
|
||
|
|
@GuardedBy("VirtualMachineManager.sCreateLock")
|
||
|
|
@NonNull
|
||
|
|
static VirtualMachine create(
|
||
|
|
@NonNull Context context, @NonNull String name, @NonNull VirtualMachineConfig config)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
File vmDir = createVmDir(context, name);
|
||
|
|
|
||
|
|
try {
|
||
|
|
VirtualMachine vm =
|
||
|
|
new VirtualMachine(context, name, config, VirtualizationService.getInstance());
|
||
|
|
config.serialize(vm.mConfigFilePath);
|
||
|
|
try {
|
||
|
|
vm.mInstanceFilePath.createNewFile();
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException("failed to create instance image", e);
|
||
|
|
}
|
||
|
|
if (config.isEncryptedStorageEnabled()) {
|
||
|
|
try {
|
||
|
|
vm.mEncryptedStoreFilePath.createNewFile();
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException(
|
||
|
|
"failed to create encrypted storage image", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
IVirtualizationService service = vm.mVirtualizationService.getBinder();
|
||
|
|
|
||
|
|
if (vm.mInstanceIdPath != null) {
|
||
|
|
try (FileOutputStream stream = new FileOutputStream(vm.mInstanceIdPath)) {
|
||
|
|
byte[] id = service.allocateInstanceId();
|
||
|
|
stream.write(id);
|
||
|
|
} catch (FileNotFoundException e) {
|
||
|
|
throw new VirtualMachineException("instance_id file missing", e);
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException("failed to persist instance_id", e);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
} catch (ServiceSpecificException | IllegalArgumentException e) {
|
||
|
|
throw new VirtualMachineException("failed to create instance_id", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
try {
|
||
|
|
service.initializeWritablePartition(
|
||
|
|
ParcelFileDescriptor.open(vm.mInstanceFilePath, MODE_READ_WRITE),
|
||
|
|
INSTANCE_FILE_SIZE,
|
||
|
|
PartitionType.ANDROID_VM_INSTANCE);
|
||
|
|
} catch (FileNotFoundException e) {
|
||
|
|
throw new VirtualMachineException("instance image missing", e);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
} catch (ServiceSpecificException | IllegalArgumentException e) {
|
||
|
|
throw new VirtualMachineException("failed to create instance partition", e);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.isEncryptedStorageEnabled()) {
|
||
|
|
try {
|
||
|
|
service.initializeWritablePartition(
|
||
|
|
ParcelFileDescriptor.open(vm.mEncryptedStoreFilePath, MODE_READ_WRITE),
|
||
|
|
config.getEncryptedStorageBytes(),
|
||
|
|
PartitionType.ENCRYPTEDSTORE);
|
||
|
|
} catch (FileNotFoundException e) {
|
||
|
|
throw new VirtualMachineException("encrypted storage image missing", e);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
} catch (ServiceSpecificException | IllegalArgumentException e) {
|
||
|
|
throw new VirtualMachineException(
|
||
|
|
"failed to create encrypted storage partition", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return vm;
|
||
|
|
} catch (VirtualMachineException | RuntimeException e) {
|
||
|
|
// If anything goes wrong, delete any files created so far and the VM's directory
|
||
|
|
try {
|
||
|
|
vmInstanceCleanup(context, name);
|
||
|
|
} catch (Exception innerException) {
|
||
|
|
e.addSuppressed(innerException);
|
||
|
|
}
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Loads a virtual machine that is already created before. */
|
||
|
|
@GuardedBy("VirtualMachineManager.sCreateLock")
|
||
|
|
@Nullable
|
||
|
|
static VirtualMachine load(@NonNull Context context, @NonNull String name)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
File thisVmDir = getVmDir(context, name);
|
||
|
|
if (!thisVmDir.exists()) {
|
||
|
|
// The VM doesn't exist.
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
File configFilePath = new File(thisVmDir, CONFIG_FILE);
|
||
|
|
VirtualMachineConfig config = VirtualMachineConfig.from(configFilePath);
|
||
|
|
VirtualMachine vm =
|
||
|
|
new VirtualMachine(context, name, config, VirtualizationService.getInstance());
|
||
|
|
|
||
|
|
if (vm.mInstanceIdPath != null && !vm.mInstanceIdPath.exists()) {
|
||
|
|
throw new VirtualMachineException("instance_id file missing");
|
||
|
|
}
|
||
|
|
if (!vm.mInstanceFilePath.exists()) {
|
||
|
|
throw new VirtualMachineException("instance image missing");
|
||
|
|
}
|
||
|
|
if (config.isEncryptedStorageEnabled() && !vm.mEncryptedStoreFilePath.exists()) {
|
||
|
|
throw new VirtualMachineException("Storage image missing");
|
||
|
|
}
|
||
|
|
return vm;
|
||
|
|
}
|
||
|
|
|
||
|
|
@GuardedBy("VirtualMachineManager.sCreateLock")
|
||
|
|
void delete(Context context, String name) throws VirtualMachineException {
|
||
|
|
synchronized (mLock) {
|
||
|
|
checkStopped();
|
||
|
|
// Once we explicitly delete a VM it must remain permanently in the deleted state;
|
||
|
|
// if a new VM is created with the same name (and files) that's unrelated.
|
||
|
|
mWasDeleted = true;
|
||
|
|
}
|
||
|
|
vmInstanceCleanup(context, name);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Delete the full VM directory and notify VirtualizationService to remove this
|
||
|
|
// VM instance for housekeeping.
|
||
|
|
@GuardedBy("VirtualMachineManager.sCreateLock")
|
||
|
|
static void vmInstanceCleanup(Context context, String name) throws VirtualMachineException {
|
||
|
|
File vmDir = getVmDir(context, name);
|
||
|
|
notifyInstanceRemoval(vmDir, VirtualizationService.getInstance());
|
||
|
|
try {
|
||
|
|
deleteRecursively(vmDir);
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static void notifyInstanceRemoval(
|
||
|
|
File vmDirectory, @NonNull VirtualizationService service) {
|
||
|
|
File instanceIdFile = new File(vmDirectory, INSTANCE_ID_FILE);
|
||
|
|
try {
|
||
|
|
byte[] instanceId = Files.readAllBytes(instanceIdFile.toPath());
|
||
|
|
service.getBinder().removeVmInstance(instanceId);
|
||
|
|
} catch (Exception e) {
|
||
|
|
// Deliberately ignoring error in removing VM instance. This potentially leads to
|
||
|
|
// unaccounted instances in the VS' database. But, nothing much can be done by caller.
|
||
|
|
Log.w(TAG, "Failed to notify VS to remove the VM instance", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Claim the instance. This notifies the global VS about the ownership of this
|
||
|
|
// instance_id for housekeeping purpose.
|
||
|
|
void claimInstance() throws VirtualMachineException {
|
||
|
|
if (mInstanceIdPath != null) {
|
||
|
|
IVirtualizationService service = mVirtualizationService.getBinder();
|
||
|
|
try {
|
||
|
|
byte[] instanceId = Files.readAllBytes(mInstanceIdPath.toPath());
|
||
|
|
service.claimVmInstance(instanceId);
|
||
|
|
}
|
||
|
|
catch (IOException e) {
|
||
|
|
throw new VirtualMachineException("failed to read instance_id", e);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@GuardedBy("VirtualMachineManager.sCreateLock")
|
||
|
|
@NonNull
|
||
|
|
private static File createVmDir(@NonNull Context context, @NonNull String name)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
File vmDir = getVmDir(context, name);
|
||
|
|
try {
|
||
|
|
// We don't need to undo this even if VM creation fails.
|
||
|
|
Files.createDirectories(vmDir.getParentFile().toPath());
|
||
|
|
|
||
|
|
// The checking of the existence of this directory and the creation of it is done
|
||
|
|
// atomically. If the directory already exists (i.e. the VM with the same name was
|
||
|
|
// already created), FileAlreadyExistsException is thrown.
|
||
|
|
Files.createDirectory(vmDir.toPath());
|
||
|
|
} catch (FileAlreadyExistsException e) {
|
||
|
|
throw new VirtualMachineException("virtual machine already exists", e);
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException("failed to create directory for VM", e);
|
||
|
|
}
|
||
|
|
return vmDir;
|
||
|
|
}
|
||
|
|
|
||
|
|
@NonNull
|
||
|
|
private static File getVmDir(@NonNull Context context, @NonNull String name) {
|
||
|
|
if (name.contains(File.separator) || name.equals(".") || name.equals("..")) {
|
||
|
|
throw new IllegalArgumentException("Invalid VM name: " + name);
|
||
|
|
}
|
||
|
|
File vmRoot = new File(context.getDataDir(), VM_DIR);
|
||
|
|
return new File(vmRoot, name);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the name of this virtual machine. The name is unique in the package and can't be
|
||
|
|
* changed.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
@NonNull
|
||
|
|
public String getName() {
|
||
|
|
return mName;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the currently selected config of this virtual machine. There can be multiple virtual
|
||
|
|
* machines sharing the same config. Even in that case, the virtual machines are completely
|
||
|
|
* isolated from each other; they have different secrets. It is also possible that a virtual
|
||
|
|
* machine can change its config, which can be done by calling {@link #setConfig}.
|
||
|
|
*
|
||
|
|
* <p>NOTE: This method may block and should not be called on the main thread.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
@WorkerThread
|
||
|
|
@NonNull
|
||
|
|
public VirtualMachineConfig getConfig() {
|
||
|
|
synchronized (mLock) {
|
||
|
|
return mConfig;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the current status of this virtual machine.
|
||
|
|
*
|
||
|
|
* <p>NOTE: This method may block and should not be called on the main thread.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
@WorkerThread
|
||
|
|
@Status
|
||
|
|
public int getStatus() {
|
||
|
|
IVirtualMachine virtualMachine;
|
||
|
|
synchronized (mLock) {
|
||
|
|
if (mWasDeleted) {
|
||
|
|
return STATUS_DELETED;
|
||
|
|
}
|
||
|
|
virtualMachine = mVirtualMachine;
|
||
|
|
}
|
||
|
|
|
||
|
|
int status;
|
||
|
|
if (virtualMachine == null) {
|
||
|
|
status = STATUS_STOPPED;
|
||
|
|
} else {
|
||
|
|
try {
|
||
|
|
status = stateToStatus(virtualMachine.getState());
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (status == STATUS_STOPPED && !mVmRootPath.exists()) {
|
||
|
|
// A VM can quite happily keep running if its backing files have been deleted.
|
||
|
|
// But once it stops, it's gone forever.
|
||
|
|
synchronized (mLock) {
|
||
|
|
dropVm();
|
||
|
|
}
|
||
|
|
return STATUS_DELETED;
|
||
|
|
}
|
||
|
|
return status;
|
||
|
|
}
|
||
|
|
|
||
|
|
private int stateToStatus(@VirtualMachineState int state) {
|
||
|
|
switch (state) {
|
||
|
|
case VirtualMachineState.STARTING:
|
||
|
|
case VirtualMachineState.STARTED:
|
||
|
|
case VirtualMachineState.READY:
|
||
|
|
case VirtualMachineState.FINISHED:
|
||
|
|
return STATUS_RUNNING;
|
||
|
|
case VirtualMachineState.NOT_STARTED:
|
||
|
|
case VirtualMachineState.DEAD:
|
||
|
|
default:
|
||
|
|
return STATUS_STOPPED;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Throw an appropriate exception if we have a running VM, or the VM has been deleted.
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
private void checkStopped() throws VirtualMachineException {
|
||
|
|
if (mWasDeleted || !mVmRootPath.exists()) {
|
||
|
|
throw new VirtualMachineException("VM has been deleted");
|
||
|
|
}
|
||
|
|
if (mVirtualMachine == null) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
if (stateToStatus(mVirtualMachine.getState()) != STATUS_STOPPED) {
|
||
|
|
throw new VirtualMachineException("VM is not in stopped state");
|
||
|
|
}
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
}
|
||
|
|
// It's stopped, but we still have a reference to it - we can fix that.
|
||
|
|
dropVm();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This should only be called when we know our VM has stopped; we no longer need to hold a
|
||
|
|
* reference to it (this allows resources to be GC'd) and we no longer need to be informed of
|
||
|
|
* memory pressure.
|
||
|
|
*/
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
private void dropVm() {
|
||
|
|
mContext.unregisterComponentCallbacks(mMemoryManagementCallbacks);
|
||
|
|
mVirtualMachine = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/** If we have an IVirtualMachine in the running state return it, otherwise throw. */
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
private IVirtualMachine getRunningVm() throws VirtualMachineException {
|
||
|
|
try {
|
||
|
|
if (mVirtualMachine != null
|
||
|
|
&& stateToStatus(mVirtualMachine.getState()) == STATUS_RUNNING) {
|
||
|
|
return mVirtualMachine;
|
||
|
|
} else {
|
||
|
|
if (mWasDeleted || !mVmRootPath.exists()) {
|
||
|
|
throw new VirtualMachineException("VM has been deleted");
|
||
|
|
} else {
|
||
|
|
throw new VirtualMachineException("VM is not in running state");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Registers the callback object to get events from the virtual machine. If a callback was
|
||
|
|
* already registered, it is replaced with the new one.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
public void setCallback(
|
||
|
|
@NonNull @CallbackExecutor Executor executor,
|
||
|
|
@NonNull VirtualMachineCallback callback) {
|
||
|
|
synchronized (mCallbackLock) {
|
||
|
|
mCallback = callback;
|
||
|
|
mCallbackExecutor = executor;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Clears the currently registered callback.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
public void clearCallback() {
|
||
|
|
synchronized (mCallbackLock) {
|
||
|
|
mCallback = null;
|
||
|
|
mCallbackExecutor = null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Executes a callback on the callback executor. */
|
||
|
|
private void executeCallback(Consumer<VirtualMachineCallback> fn) {
|
||
|
|
final VirtualMachineCallback callback;
|
||
|
|
final Executor executor;
|
||
|
|
synchronized (mCallbackLock) {
|
||
|
|
callback = mCallback;
|
||
|
|
executor = mCallbackExecutor;
|
||
|
|
}
|
||
|
|
if (callback == null || executor == null) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
final long restoreToken = Binder.clearCallingIdentity();
|
||
|
|
try {
|
||
|
|
executor.execute(() -> fn.accept(callback));
|
||
|
|
} finally {
|
||
|
|
Binder.restoreCallingIdentity(restoreToken);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private android.system.virtualizationservice.VirtualMachineConfig
|
||
|
|
createVirtualMachineConfigForRawFrom(VirtualMachineConfig vmConfig)
|
||
|
|
throws IllegalStateException, IOException {
|
||
|
|
VirtualMachineRawConfig rawConfig = vmConfig.toVsRawConfig();
|
||
|
|
|
||
|
|
// Handle input devices here
|
||
|
|
List<InputDevice> inputDevices = new ArrayList<>();
|
||
|
|
if (vmConfig.getCustomImageConfig() != null
|
||
|
|
&& rawConfig.displayConfig != null) {
|
||
|
|
if (vmConfig.getCustomImageConfig().useTouch()) {
|
||
|
|
ParcelFileDescriptor[] pfds = ParcelFileDescriptor.createSocketPair();
|
||
|
|
mTouchSock = pfds[0];
|
||
|
|
InputDevice.SingleTouch t = new InputDevice.SingleTouch();
|
||
|
|
t.width = rawConfig.displayConfig.width;
|
||
|
|
t.height = rawConfig.displayConfig.height;
|
||
|
|
t.pfd = pfds[1];
|
||
|
|
inputDevices.add(InputDevice.singleTouch(t));
|
||
|
|
}
|
||
|
|
if (vmConfig.getCustomImageConfig().useKeyboard()) {
|
||
|
|
ParcelFileDescriptor[] pfds = ParcelFileDescriptor.createSocketPair();
|
||
|
|
mKeySock = pfds[0];
|
||
|
|
InputDevice.Keyboard k = new InputDevice.Keyboard();
|
||
|
|
k.pfd = pfds[1];
|
||
|
|
inputDevices.add(InputDevice.keyboard(k));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
rawConfig.inputDevices = inputDevices.toArray(new InputDevice[0]);
|
||
|
|
|
||
|
|
return android.system.virtualizationservice.VirtualMachineConfig.rawConfig(rawConfig);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static record InputEvent(short type, short code, int value) {}
|
||
|
|
|
||
|
|
/** @hide */
|
||
|
|
public boolean sendKeyEvent(KeyEvent event) {
|
||
|
|
if (mKeySock == null) {
|
||
|
|
Log.d(TAG, "mKeySock == null");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
// from include/uapi/linux/input-event-codes.h in the kernel.
|
||
|
|
short EV_SYN = 0x00;
|
||
|
|
short EV_KEY = 0x01;
|
||
|
|
short SYN_REPORT = 0x00;
|
||
|
|
boolean down = event.getAction() != MotionEvent.ACTION_UP;
|
||
|
|
|
||
|
|
return writeEventsToSock(
|
||
|
|
mKeySock,
|
||
|
|
Arrays.asList(
|
||
|
|
new InputEvent(EV_KEY, (short) event.getScanCode(), down ? 1 : 0),
|
||
|
|
new InputEvent(EV_SYN, SYN_REPORT, 0)));
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @hide */
|
||
|
|
public boolean sendSingleTouchEvent(MotionEvent event) {
|
||
|
|
if (mTouchSock == null) {
|
||
|
|
Log.d(TAG, "mTouchSock == null");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
// from include/uapi/linux/input-event-codes.h in the kernel.
|
||
|
|
short EV_SYN = 0x00;
|
||
|
|
short EV_ABS = 0x03;
|
||
|
|
short EV_KEY = 0x01;
|
||
|
|
short BTN_TOUCH = 0x14a;
|
||
|
|
short ABS_X = 0x00;
|
||
|
|
short ABS_Y = 0x01;
|
||
|
|
short SYN_REPORT = 0x00;
|
||
|
|
|
||
|
|
int x = (int) event.getX();
|
||
|
|
int y = (int) event.getY();
|
||
|
|
boolean down = event.getAction() != MotionEvent.ACTION_UP;
|
||
|
|
|
||
|
|
return writeEventsToSock(
|
||
|
|
mTouchSock,
|
||
|
|
Arrays.asList(
|
||
|
|
new InputEvent(EV_ABS, ABS_X, x),
|
||
|
|
new InputEvent(EV_ABS, ABS_Y, y),
|
||
|
|
new InputEvent(EV_KEY, BTN_TOUCH, down ? 1 : 0),
|
||
|
|
new InputEvent(EV_SYN, SYN_REPORT, 0)));
|
||
|
|
}
|
||
|
|
|
||
|
|
private boolean writeEventsToSock(ParcelFileDescriptor sock, List<InputEvent> evtList) {
|
||
|
|
ByteBuffer byteBuffer =
|
||
|
|
ByteBuffer.allocate(8 /* (type: u16 + code: u16 + value: i32) */ * evtList.size());
|
||
|
|
byteBuffer.clear();
|
||
|
|
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
|
||
|
|
for (InputEvent e : evtList) {
|
||
|
|
byteBuffer.putShort(e.type);
|
||
|
|
byteBuffer.putShort(e.code);
|
||
|
|
byteBuffer.putInt(e.value);
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
IoBridge.write(
|
||
|
|
sock.getFileDescriptor(), byteBuffer.array(), 0, byteBuffer.array().length);
|
||
|
|
} catch (IOException e) {
|
||
|
|
Log.d(TAG, "cannot send event", e);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private android.system.virtualizationservice.VirtualMachineConfig
|
||
|
|
createVirtualMachineConfigForAppFrom(
|
||
|
|
VirtualMachineConfig vmConfig, IVirtualizationService service)
|
||
|
|
throws RemoteException, IOException, VirtualMachineException {
|
||
|
|
VirtualMachineAppConfig appConfig = vmConfig.toVsConfig(mContext.getPackageManager());
|
||
|
|
appConfig.instanceImage = ParcelFileDescriptor.open(mInstanceFilePath, MODE_READ_WRITE);
|
||
|
|
appConfig.name = mName;
|
||
|
|
if (mInstanceIdPath != null) {
|
||
|
|
appConfig.instanceId = Files.readAllBytes(mInstanceIdPath.toPath());
|
||
|
|
} else {
|
||
|
|
// FEATURE_LLPVM_CHANGES is disabled, instance_id is not used.
|
||
|
|
appConfig.instanceId = new byte[64];
|
||
|
|
}
|
||
|
|
if (mEncryptedStoreFilePath != null) {
|
||
|
|
appConfig.encryptedStorageImage =
|
||
|
|
ParcelFileDescriptor.open(mEncryptedStoreFilePath, MODE_READ_WRITE);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!vmConfig.getExtraApks().isEmpty()) {
|
||
|
|
// Extra APKs were specified directly, rather than via config file.
|
||
|
|
// We've already populated the file names for the extra APKs and IDSigs
|
||
|
|
// (via setupExtraApks). But we also need to open the APK files and add
|
||
|
|
// fds for them to the payload config.
|
||
|
|
// This isn't needed when the extra APKs are specified in a config file -
|
||
|
|
// then
|
||
|
|
// Virtualization Manager opens them itself.
|
||
|
|
List<ParcelFileDescriptor> extraApkFiles = new ArrayList<>(mExtraApks.size());
|
||
|
|
for (ExtraApkSpec extraApk : mExtraApks) {
|
||
|
|
try {
|
||
|
|
extraApkFiles.add(ParcelFileDescriptor.open(extraApk.apk, MODE_READ_ONLY));
|
||
|
|
} catch (FileNotFoundException e) {
|
||
|
|
throw new VirtualMachineException("Failed to open extra APK", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
appConfig.payload.getPayloadConfig().extraApks = extraApkFiles;
|
||
|
|
}
|
||
|
|
|
||
|
|
try {
|
||
|
|
createIdSigsAndUpdateConfig(service, appConfig);
|
||
|
|
} catch (FileNotFoundException e) {
|
||
|
|
throw new VirtualMachineException("Failed to generate APK signature", e);
|
||
|
|
}
|
||
|
|
return android.system.virtualizationservice.VirtualMachineConfig.appConfig(appConfig);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Runs this virtual machine. The returning of this method however doesn't mean that the VM has
|
||
|
|
* actually started running or the OS has booted there. Such events can be notified by
|
||
|
|
* registering a callback using {@link #setCallback} before calling {@code run()}.
|
||
|
|
*
|
||
|
|
* <p>NOTE: This method may block and should not be called on the main thread.
|
||
|
|
*
|
||
|
|
* @throws VirtualMachineException if the virtual machine is not stopped or could not be
|
||
|
|
* started.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
@WorkerThread
|
||
|
|
@RequiresPermission(MANAGE_VIRTUAL_MACHINE_PERMISSION)
|
||
|
|
public void run() throws VirtualMachineException {
|
||
|
|
synchronized (mLock) {
|
||
|
|
checkStopped();
|
||
|
|
|
||
|
|
try {
|
||
|
|
mIdsigFilePath.createNewFile();
|
||
|
|
for (ExtraApkSpec extraApk : mExtraApks) {
|
||
|
|
extraApk.idsig.createNewFile();
|
||
|
|
}
|
||
|
|
} catch (IOException e) {
|
||
|
|
// If the file already exists, exception is not thrown.
|
||
|
|
throw new VirtualMachineException("Failed to create APK signature file", e);
|
||
|
|
}
|
||
|
|
|
||
|
|
IVirtualizationService service = mVirtualizationService.getBinder();
|
||
|
|
|
||
|
|
try {
|
||
|
|
if (mVmOutputCaptured) {
|
||
|
|
createVmOutputPipes();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mVmConsoleInputSupported) {
|
||
|
|
createVmInputPipes();
|
||
|
|
}
|
||
|
|
|
||
|
|
VirtualMachineConfig vmConfig = getConfig();
|
||
|
|
android.system.virtualizationservice.VirtualMachineConfig vmConfigParcel =
|
||
|
|
vmConfig.getCustomImageConfig() != null
|
||
|
|
? createVirtualMachineConfigForRawFrom(vmConfig)
|
||
|
|
: createVirtualMachineConfigForAppFrom(vmConfig, service);
|
||
|
|
|
||
|
|
mVirtualMachine =
|
||
|
|
service.createVm(
|
||
|
|
vmConfigParcel, mConsoleOutWriter, mConsoleInReader, mLogWriter);
|
||
|
|
mVirtualMachine.registerCallback(new CallbackTranslator(service));
|
||
|
|
mContext.registerComponentCallbacks(mMemoryManagementCallbacks);
|
||
|
|
mVirtualMachine.start();
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException("failed to persist files", e);
|
||
|
|
} catch (IllegalStateException | ServiceSpecificException e) {
|
||
|
|
throw new VirtualMachineException(e);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void createIdSigsAndUpdateConfig(
|
||
|
|
IVirtualizationService service, VirtualMachineAppConfig appConfig)
|
||
|
|
throws RemoteException, FileNotFoundException {
|
||
|
|
// Fill the idsig file by hashing the apk
|
||
|
|
service.createOrUpdateIdsigFile(
|
||
|
|
appConfig.apk, ParcelFileDescriptor.open(mIdsigFilePath, MODE_READ_WRITE));
|
||
|
|
|
||
|
|
for (ExtraApkSpec extraApk : mExtraApks) {
|
||
|
|
service.createOrUpdateIdsigFile(
|
||
|
|
ParcelFileDescriptor.open(extraApk.apk, MODE_READ_ONLY),
|
||
|
|
ParcelFileDescriptor.open(extraApk.idsig, MODE_READ_WRITE));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Re-open idsig files in read-only mode
|
||
|
|
appConfig.idsig = ParcelFileDescriptor.open(mIdsigFilePath, MODE_READ_ONLY);
|
||
|
|
List<ParcelFileDescriptor> extraIdsigs = new ArrayList<>();
|
||
|
|
for (ExtraApkSpec extraApk : mExtraApks) {
|
||
|
|
extraIdsigs.add(ParcelFileDescriptor.open(extraApk.idsig, MODE_READ_ONLY));
|
||
|
|
}
|
||
|
|
appConfig.extraIdsigs = extraIdsigs;
|
||
|
|
}
|
||
|
|
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
private void createVmOutputPipes() throws VirtualMachineException {
|
||
|
|
try {
|
||
|
|
if (mConsoleOutReader == null || mConsoleOutWriter == null) {
|
||
|
|
ParcelFileDescriptor[] pipe = ParcelFileDescriptor.createPipe();
|
||
|
|
mConsoleOutReader = pipe[0];
|
||
|
|
mConsoleOutWriter = pipe[1];
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mLogReader == null || mLogWriter == null) {
|
||
|
|
ParcelFileDescriptor[] pipe = ParcelFileDescriptor.createPipe();
|
||
|
|
mLogReader = pipe[0];
|
||
|
|
mLogWriter = pipe[1];
|
||
|
|
}
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException("Failed to create output stream for VM", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@GuardedBy("mLock")
|
||
|
|
private void createVmInputPipes() throws VirtualMachineException {
|
||
|
|
try {
|
||
|
|
if (mConsoleInReader == null || mConsoleInWriter == null) {
|
||
|
|
ParcelFileDescriptor[] pipe = ParcelFileDescriptor.createPipe();
|
||
|
|
mConsoleInReader = pipe[0];
|
||
|
|
mConsoleInWriter = pipe[1];
|
||
|
|
}
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException("Failed to create input stream for VM", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the stream object representing the console output from the virtual machine. The
|
||
|
|
* console output is only available if the {@link VirtualMachineConfig} specifies that it should
|
||
|
|
* be {@linkplain VirtualMachineConfig#isVmOutputCaptured captured}.
|
||
|
|
*
|
||
|
|
* <p>If you turn on output capture, you must consume data from {@code getConsoleOutput} -
|
||
|
|
* because otherwise the code in the VM may get blocked when the pipe buffer fills up.
|
||
|
|
*
|
||
|
|
* <p>NOTE: This method may block and should not be called on the main thread.
|
||
|
|
*
|
||
|
|
* @throws VirtualMachineException if the stream could not be created, or capturing is turned
|
||
|
|
* off.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
@WorkerThread
|
||
|
|
@NonNull
|
||
|
|
public InputStream getConsoleOutput() throws VirtualMachineException {
|
||
|
|
if (!mVmOutputCaptured) {
|
||
|
|
throw new VirtualMachineException("Capturing vm outputs is turned off");
|
||
|
|
}
|
||
|
|
synchronized (mLock) {
|
||
|
|
createVmOutputPipes();
|
||
|
|
return new FileInputStream(mConsoleOutReader.getFileDescriptor());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the stream object representing the console input to the virtual machine. The console
|
||
|
|
* input is only available if the {@link VirtualMachineConfig} specifies that it should be
|
||
|
|
* {@linkplain VirtualMachineConfig#isVmConsoleInputSupported supported}.
|
||
|
|
*
|
||
|
|
* <p>NOTE: This method may block and should not be called on the main thread.
|
||
|
|
*
|
||
|
|
* @throws VirtualMachineException if the stream could not be created, or console input is not
|
||
|
|
* supported.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@TestApi
|
||
|
|
@WorkerThread
|
||
|
|
@NonNull
|
||
|
|
public OutputStream getConsoleInput() throws VirtualMachineException {
|
||
|
|
if (!mVmConsoleInputSupported) {
|
||
|
|
throw new VirtualMachineException("VM console input is not supported");
|
||
|
|
}
|
||
|
|
synchronized (mLock) {
|
||
|
|
createVmInputPipes();
|
||
|
|
return new FileOutputStream(mConsoleInWriter.getFileDescriptor());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the stream object representing the log output from the virtual machine. The log
|
||
|
|
* output is only available if the VirtualMachineConfig specifies that it should be {@linkplain
|
||
|
|
* VirtualMachineConfig#isVmOutputCaptured captured}.
|
||
|
|
*
|
||
|
|
* <p>If you turn on output capture, you must consume data from {@code getLogOutput} - because
|
||
|
|
* otherwise the code in the VM may get blocked when the pipe buffer fills up.
|
||
|
|
*
|
||
|
|
* <p>NOTE: This method may block and should not be called on the main thread.
|
||
|
|
*
|
||
|
|
* @throws VirtualMachineException if the stream could not be created, or capturing is turned
|
||
|
|
* off.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
@WorkerThread
|
||
|
|
@NonNull
|
||
|
|
public InputStream getLogOutput() throws VirtualMachineException {
|
||
|
|
if (!mVmOutputCaptured) {
|
||
|
|
throw new VirtualMachineException("Capturing vm outputs is turned off");
|
||
|
|
}
|
||
|
|
synchronized (mLock) {
|
||
|
|
createVmOutputPipes();
|
||
|
|
return new FileInputStream(mLogReader.getFileDescriptor());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Stops this virtual machine. Stopping a virtual machine is like pulling the plug on a real
|
||
|
|
* computer; the machine halts immediately. Software running on the virtual machine is not
|
||
|
|
* notified of the event. Writes to {@linkplain
|
||
|
|
* VirtualMachineConfig.Builder#setEncryptedStorageBytes encrypted storage} might not be
|
||
|
|
* persisted, and the instance might be left in an inconsistent state.
|
||
|
|
*
|
||
|
|
* <p>For a graceful shutdown, you could request the payload to call {@code exit()}, e.g. via a
|
||
|
|
* {@linkplain #connectToVsockServer binder request}, and wait for {@link
|
||
|
|
* VirtualMachineCallback#onPayloadFinished} to be called.
|
||
|
|
*
|
||
|
|
* <p>A stopped virtual machine can be re-started by calling {@link #run()}.
|
||
|
|
*
|
||
|
|
* <p>NOTE: This method may block and should not be called on the main thread.
|
||
|
|
*
|
||
|
|
* @throws VirtualMachineException if the virtual machine is not running or could not be
|
||
|
|
* stopped.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
@WorkerThread
|
||
|
|
public void stop() throws VirtualMachineException {
|
||
|
|
synchronized (mLock) {
|
||
|
|
if (mVirtualMachine == null) {
|
||
|
|
throw new VirtualMachineException("VM is not running");
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
mVirtualMachine.stop();
|
||
|
|
dropVm();
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
} catch (ServiceSpecificException e) {
|
||
|
|
throw new VirtualMachineException(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Stops this virtual machine, if it is running.
|
||
|
|
*
|
||
|
|
* <p>NOTE: This method may block and should not be called on the main thread.
|
||
|
|
*
|
||
|
|
* @see #stop()
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
@WorkerThread
|
||
|
|
@Override
|
||
|
|
public void close() {
|
||
|
|
synchronized (mLock) {
|
||
|
|
if (mVirtualMachine == null) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
if (stateToStatus(mVirtualMachine.getState()) == STATUS_RUNNING) {
|
||
|
|
mVirtualMachine.stop();
|
||
|
|
dropVm();
|
||
|
|
}
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
} catch (ServiceSpecificException e) {
|
||
|
|
// Deliberately ignored; this almost certainly means the VM exited just as
|
||
|
|
// we tried to stop it.
|
||
|
|
Log.i(TAG, "Ignoring error on close()", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static void deleteRecursively(File dir) throws IOException {
|
||
|
|
// Note: This doesn't follow symlinks, which is important. Instead they are just deleted
|
||
|
|
// (and Files.delete deletes the link not the target).
|
||
|
|
Files.walkFileTree(dir.toPath(), new SimpleFileVisitor<>() {
|
||
|
|
@Override
|
||
|
|
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
|
||
|
|
throws IOException {
|
||
|
|
Files.delete(file);
|
||
|
|
return FileVisitResult.CONTINUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public FileVisitResult postVisitDirectory(Path dir, IOException e) throws IOException {
|
||
|
|
// Directory is deleted after we've visited (deleted) all its contents, so it
|
||
|
|
// should be empty by now.
|
||
|
|
Files.delete(dir);
|
||
|
|
return FileVisitResult.CONTINUE;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Changes the config of this virtual machine to a new one. This can be used to adjust things
|
||
|
|
* like the number of CPU and size of the RAM, depending on the situation (e.g. the size of the
|
||
|
|
* application to run on the virtual machine, etc.)
|
||
|
|
*
|
||
|
|
* <p>The new config must be {@linkplain VirtualMachineConfig#isCompatibleWith compatible with}
|
||
|
|
* the existing config.
|
||
|
|
*
|
||
|
|
* <p>NOTE: This method may block and should not be called on the main thread.
|
||
|
|
*
|
||
|
|
* @return the old config
|
||
|
|
* @throws VirtualMachineException if the virtual machine is not stopped, or the new config is
|
||
|
|
* incompatible.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
@WorkerThread
|
||
|
|
@NonNull
|
||
|
|
public VirtualMachineConfig setConfig(@NonNull VirtualMachineConfig newConfig)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
synchronized (mLock) {
|
||
|
|
VirtualMachineConfig oldConfig = mConfig;
|
||
|
|
if (!oldConfig.isCompatibleWith(newConfig)) {
|
||
|
|
throw new VirtualMachineException("incompatible config");
|
||
|
|
}
|
||
|
|
checkStopped();
|
||
|
|
|
||
|
|
if (oldConfig != newConfig) {
|
||
|
|
// Delete any existing file before recreating; that ensures any
|
||
|
|
// VirtualMachineDescriptor that refers to the old file does not see the new config.
|
||
|
|
mConfigFilePath.delete();
|
||
|
|
newConfig.serialize(mConfigFilePath);
|
||
|
|
mConfig = newConfig;
|
||
|
|
}
|
||
|
|
return oldConfig;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Nullable
|
||
|
|
private static native IBinder nativeConnectToVsockServer(IBinder vmBinder, int port);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Connect to a VM's binder service via vsock and return the root IBinder object. Guest VMs are
|
||
|
|
* expected to set up vsock servers in their payload. After the host app receives the {@link
|
||
|
|
* VirtualMachineCallback#onPayloadReady}, it can use this method to establish a connection to
|
||
|
|
* the guest VM.
|
||
|
|
*
|
||
|
|
* <p>NOTE: This method may block and should not be called on the main thread.
|
||
|
|
*
|
||
|
|
* @throws VirtualMachineException if the virtual machine is not running or the connection
|
||
|
|
* failed.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
@WorkerThread
|
||
|
|
@NonNull
|
||
|
|
public IBinder connectToVsockServer(
|
||
|
|
@IntRange(from = MIN_VSOCK_PORT, to = MAX_VSOCK_PORT) long port)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
|
||
|
|
synchronized (mLock) {
|
||
|
|
IBinder iBinder =
|
||
|
|
nativeConnectToVsockServer(getRunningVm().asBinder(), validatePort(port));
|
||
|
|
if (iBinder == null) {
|
||
|
|
throw new VirtualMachineException("Failed to connect to vsock server");
|
||
|
|
}
|
||
|
|
return iBinder;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Opens a vsock connection to the VM on the given port.
|
||
|
|
*
|
||
|
|
* <p>The caller is responsible for closing the returned {@code ParcelFileDescriptor}.
|
||
|
|
*
|
||
|
|
* <p>NOTE: This method may block and should not be called on the main thread.
|
||
|
|
*
|
||
|
|
* @throws VirtualMachineException if connecting fails.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
@WorkerThread
|
||
|
|
@NonNull
|
||
|
|
public ParcelFileDescriptor connectVsock(
|
||
|
|
@IntRange(from = MIN_VSOCK_PORT, to = MAX_VSOCK_PORT) long port)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
synchronized (mLock) {
|
||
|
|
try {
|
||
|
|
return getRunningVm().connectVsock(validatePort(port));
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
} catch (ServiceSpecificException e) {
|
||
|
|
throw new VirtualMachineException(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private int validatePort(long port) {
|
||
|
|
// Ports below 1024 are "privileged" (payload code can't bind to these), and port numbers
|
||
|
|
// are 32-bit unsigned numbers at the OS level, even though we pass them as 32-bit signed
|
||
|
|
// numbers internally.
|
||
|
|
if (port < MIN_VSOCK_PORT || port > MAX_VSOCK_PORT) {
|
||
|
|
throw new IllegalArgumentException("Bad port " + port);
|
||
|
|
}
|
||
|
|
return (int) port;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the root directory where all files related to this {@link VirtualMachine} (e.g.
|
||
|
|
* {@code instance.img}, {@code apk.idsig}, etc) are stored.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@TestApi
|
||
|
|
@NonNull
|
||
|
|
public File getRootDir() {
|
||
|
|
return mVmRootPath;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Enables the VM to request attestation in testing mode.
|
||
|
|
*
|
||
|
|
* <p>This function provisions a key pair for the VM attestation testing, a fake certificate
|
||
|
|
* will be associated to the fake key pair when the VM requests attestation in testing mode.
|
||
|
|
*
|
||
|
|
* <p>The provisioned key pair can only be used in subsequent calls to {@link
|
||
|
|
* AVmPayload_requestAttestationForTesting} within a running VM.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@TestApi
|
||
|
|
@RequiresPermission(USE_CUSTOM_VIRTUAL_MACHINE_PERMISSION)
|
||
|
|
@FlaggedApi(Flags.FLAG_AVF_V_TEST_APIS)
|
||
|
|
public void enableTestAttestation() throws VirtualMachineException {
|
||
|
|
try {
|
||
|
|
mVirtualizationService.getBinder().enableTestAttestation();
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
throw e.rethrowAsRuntimeException();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Captures the current state of the VM in a {@link VirtualMachineDescriptor} instance. The VM
|
||
|
|
* needs to be stopped to avoid inconsistency in its state representation.
|
||
|
|
*
|
||
|
|
* <p>The state of the VM is not actually copied until {@link
|
||
|
|
* VirtualMachineManager#importFromDescriptor} is called. It is recommended that the VM not be
|
||
|
|
* started until that operation is complete.
|
||
|
|
*
|
||
|
|
* <p>NOTE: This method may block and should not be called on the main thread.
|
||
|
|
*
|
||
|
|
* @return a {@link VirtualMachineDescriptor} instance that represents the VM's state.
|
||
|
|
* @throws VirtualMachineException if the virtual machine is not stopped, or the state could not
|
||
|
|
* be captured.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@SystemApi
|
||
|
|
@WorkerThread
|
||
|
|
@NonNull
|
||
|
|
public VirtualMachineDescriptor toDescriptor() throws VirtualMachineException {
|
||
|
|
synchronized (mLock) {
|
||
|
|
checkStopped();
|
||
|
|
try {
|
||
|
|
return new VirtualMachineDescriptor(
|
||
|
|
ParcelFileDescriptor.open(mConfigFilePath, MODE_READ_ONLY),
|
||
|
|
mInstanceIdPath != null
|
||
|
|
? ParcelFileDescriptor.open(mInstanceIdPath, MODE_READ_ONLY)
|
||
|
|
: null,
|
||
|
|
ParcelFileDescriptor.open(mInstanceFilePath, MODE_READ_ONLY),
|
||
|
|
mEncryptedStoreFilePath != null
|
||
|
|
? ParcelFileDescriptor.open(mEncryptedStoreFilePath, MODE_READ_ONLY)
|
||
|
|
: null);
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public String toString() {
|
||
|
|
VirtualMachineConfig config = getConfig();
|
||
|
|
String payloadConfigPath = config.getPayloadConfigPath();
|
||
|
|
String payloadBinaryName = config.getPayloadBinaryName();
|
||
|
|
|
||
|
|
StringBuilder result = new StringBuilder();
|
||
|
|
result.append("VirtualMachine(")
|
||
|
|
.append("name:")
|
||
|
|
.append(getName())
|
||
|
|
.append(", ");
|
||
|
|
if (payloadBinaryName != null) {
|
||
|
|
result.append("payload:").append(payloadBinaryName).append(", ");
|
||
|
|
}
|
||
|
|
if (payloadConfigPath != null) {
|
||
|
|
result.append("config:")
|
||
|
|
.append(payloadConfigPath)
|
||
|
|
.append(", ");
|
||
|
|
}
|
||
|
|
result.append("package: ")
|
||
|
|
.append(mPackageName)
|
||
|
|
.append(")");
|
||
|
|
return result.toString();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Reads the payload config inside the application, parses extra APK information, and then
|
||
|
|
* creates corresponding idsig file paths.
|
||
|
|
*/
|
||
|
|
private static List<ExtraApkSpec> setupExtraApks(
|
||
|
|
@NonNull Context context, @NonNull VirtualMachineConfig config, @NonNull File vmDir)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
String configPath = config.getPayloadConfigPath();
|
||
|
|
List<String> extraApks = config.getExtraApks();
|
||
|
|
if (configPath != null) {
|
||
|
|
return setupExtraApksFromConfigFile(context, vmDir, configPath);
|
||
|
|
} else if (!extraApks.isEmpty()) {
|
||
|
|
return setupExtraApksFromList(context, vmDir, extraApks);
|
||
|
|
} else {
|
||
|
|
return Collections.emptyList();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static List<ExtraApkSpec> setupExtraApksFromConfigFile(
|
||
|
|
Context context, File vmDir, String configPath) throws VirtualMachineException {
|
||
|
|
try (ZipFile zipFile = new ZipFile(context.getPackageCodePath())) {
|
||
|
|
InputStream inputStream = zipFile.getInputStream(zipFile.getEntry(configPath));
|
||
|
|
List<String> apkList =
|
||
|
|
parseExtraApkListFromPayloadConfig(
|
||
|
|
new JsonReader(new InputStreamReader(inputStream)));
|
||
|
|
|
||
|
|
List<ExtraApkSpec> extraApks = new ArrayList<>(apkList.size());
|
||
|
|
for (int i = 0; i < apkList.size(); ++i) {
|
||
|
|
extraApks.add(
|
||
|
|
new ExtraApkSpec(
|
||
|
|
new File(apkList.get(i)),
|
||
|
|
new File(vmDir, EXTRA_IDSIG_FILE_PREFIX + i)));
|
||
|
|
}
|
||
|
|
|
||
|
|
return extraApks;
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException("Couldn't parse extra apks from the vm config", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static List<String> parseExtraApkListFromPayloadConfig(JsonReader reader)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
/*
|
||
|
|
* JSON schema from packages/modules/Virtualization/microdroid/payload/config/src/lib.rs:
|
||
|
|
*
|
||
|
|
* <p>{ "extra_apks": [ { "path": "/system/app/foo.apk", }, ... ], ... }
|
||
|
|
*/
|
||
|
|
try {
|
||
|
|
List<String> apks = new ArrayList<>();
|
||
|
|
|
||
|
|
reader.beginObject();
|
||
|
|
while (reader.hasNext()) {
|
||
|
|
if (reader.nextName().equals("extra_apks")) {
|
||
|
|
reader.beginArray();
|
||
|
|
while (reader.hasNext()) {
|
||
|
|
reader.beginObject();
|
||
|
|
String name = reader.nextName();
|
||
|
|
if (name.equals("path")) {
|
||
|
|
apks.add(reader.nextString());
|
||
|
|
} else {
|
||
|
|
reader.skipValue();
|
||
|
|
}
|
||
|
|
reader.endObject();
|
||
|
|
}
|
||
|
|
reader.endArray();
|
||
|
|
} else {
|
||
|
|
reader.skipValue();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
reader.endObject();
|
||
|
|
return apks;
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static List<ExtraApkSpec> setupExtraApksFromList(
|
||
|
|
Context context, File vmDir, List<String> extraApkInfo) throws VirtualMachineException {
|
||
|
|
int count = extraApkInfo.size();
|
||
|
|
List<ExtraApkSpec> extraApks = new ArrayList<>(count);
|
||
|
|
for (int i = 0; i < count; i++) {
|
||
|
|
String packageName = extraApkInfo.get(i);
|
||
|
|
ApplicationInfo appInfo;
|
||
|
|
try {
|
||
|
|
appInfo =
|
||
|
|
context.getPackageManager()
|
||
|
|
.getApplicationInfo(
|
||
|
|
packageName, PackageManager.ApplicationInfoFlags.of(0));
|
||
|
|
} catch (PackageManager.NameNotFoundException e) {
|
||
|
|
throw new VirtualMachineException("Extra APK package not found", e);
|
||
|
|
}
|
||
|
|
|
||
|
|
extraApks.add(
|
||
|
|
new ExtraApkSpec(
|
||
|
|
new File(appInfo.sourceDir),
|
||
|
|
new File(vmDir, EXTRA_IDSIG_FILE_PREFIX + i)));
|
||
|
|
}
|
||
|
|
return extraApks;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void importInstanceIdFrom(@NonNull ParcelFileDescriptor instanceIdFd)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
try (FileChannel idOutput = new FileOutputStream(mInstanceIdPath).getChannel();
|
||
|
|
FileChannel idInput = new AutoCloseInputStream(instanceIdFd).getChannel()) {
|
||
|
|
idOutput.transferFrom(idInput, /*position=*/ 0, idInput.size());
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException("failed to copy instance_id", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void importInstanceFrom(@NonNull ParcelFileDescriptor instanceFd)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
try (FileChannel instance = new FileOutputStream(mInstanceFilePath).getChannel();
|
||
|
|
FileChannel instanceInput = new AutoCloseInputStream(instanceFd).getChannel()) {
|
||
|
|
instance.transferFrom(instanceInput, /*position=*/ 0, instanceInput.size());
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException("failed to transfer instance image", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void importEncryptedStoreFrom(@NonNull ParcelFileDescriptor encryptedStoreFd)
|
||
|
|
throws VirtualMachineException {
|
||
|
|
try (FileChannel storeOutput = new FileOutputStream(mEncryptedStoreFilePath).getChannel();
|
||
|
|
FileChannel storeInput = new AutoCloseInputStream(encryptedStoreFd).getChannel()) {
|
||
|
|
storeOutput.transferFrom(storeInput, /*position=*/ 0, storeInput.size());
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new VirtualMachineException("failed to transfer encryptedstore image", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Map the raw AIDL (& binder) callbacks to what the client expects. */
|
||
|
|
private class CallbackTranslator extends IVirtualMachineCallback.Stub {
|
||
|
|
private final IVirtualizationService mService;
|
||
|
|
private final DeathRecipient mDeathRecipient;
|
||
|
|
|
||
|
|
// The VM should only be observed to die once
|
||
|
|
private final AtomicBoolean mOnDiedCalled = new AtomicBoolean(false);
|
||
|
|
|
||
|
|
public CallbackTranslator(IVirtualizationService service) throws RemoteException {
|
||
|
|
this.mService = service;
|
||
|
|
this.mDeathRecipient = () -> reportStopped(STOP_REASON_VIRTUALIZATION_SERVICE_DIED);
|
||
|
|
service.asBinder().linkToDeath(mDeathRecipient, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void onPayloadStarted(int cid) {
|
||
|
|
executeCallback((cb) -> cb.onPayloadStarted(VirtualMachine.this));
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void onPayloadReady(int cid) {
|
||
|
|
executeCallback((cb) -> cb.onPayloadReady(VirtualMachine.this));
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void onPayloadFinished(int cid, int exitCode) {
|
||
|
|
executeCallback((cb) -> cb.onPayloadFinished(VirtualMachine.this, exitCode));
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void onError(int cid, int errorCode, String message) {
|
||
|
|
int translatedError = getTranslatedError(errorCode);
|
||
|
|
executeCallback((cb) -> cb.onError(VirtualMachine.this, translatedError, message));
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void onDied(int cid, int reason) {
|
||
|
|
int translatedReason = getTranslatedReason(reason);
|
||
|
|
reportStopped(translatedReason);
|
||
|
|
mService.asBinder().unlinkToDeath(mDeathRecipient, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void reportStopped(@VirtualMachineCallback.StopReason int reason) {
|
||
|
|
if (mOnDiedCalled.compareAndSet(false, true)) {
|
||
|
|
executeCallback((cb) -> cb.onStopped(VirtualMachine.this, reason));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@VirtualMachineCallback.ErrorCode
|
||
|
|
private int getTranslatedError(int reason) {
|
||
|
|
switch (reason) {
|
||
|
|
case ErrorCode.PAYLOAD_VERIFICATION_FAILED:
|
||
|
|
return ERROR_PAYLOAD_VERIFICATION_FAILED;
|
||
|
|
case ErrorCode.PAYLOAD_CHANGED:
|
||
|
|
return ERROR_PAYLOAD_CHANGED;
|
||
|
|
case ErrorCode.PAYLOAD_INVALID_CONFIG:
|
||
|
|
return ERROR_PAYLOAD_INVALID_CONFIG;
|
||
|
|
default:
|
||
|
|
return ERROR_UNKNOWN;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@VirtualMachineCallback.StopReason
|
||
|
|
private int getTranslatedReason(int reason) {
|
||
|
|
switch (reason) {
|
||
|
|
case DeathReason.INFRASTRUCTURE_ERROR:
|
||
|
|
return STOP_REASON_INFRASTRUCTURE_ERROR;
|
||
|
|
case DeathReason.KILLED:
|
||
|
|
return STOP_REASON_KILLED;
|
||
|
|
case DeathReason.SHUTDOWN:
|
||
|
|
return STOP_REASON_SHUTDOWN;
|
||
|
|
case DeathReason.START_FAILED:
|
||
|
|
return STOP_REASON_START_FAILED;
|
||
|
|
case DeathReason.REBOOT:
|
||
|
|
return STOP_REASON_REBOOT;
|
||
|
|
case DeathReason.CRASH:
|
||
|
|
return STOP_REASON_CRASH;
|
||
|
|
case DeathReason.PVM_FIRMWARE_PUBLIC_KEY_MISMATCH:
|
||
|
|
return STOP_REASON_PVM_FIRMWARE_PUBLIC_KEY_MISMATCH;
|
||
|
|
case DeathReason.PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED:
|
||
|
|
return STOP_REASON_PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED;
|
||
|
|
case DeathReason.MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE:
|
||
|
|
return STOP_REASON_MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE;
|
||
|
|
case DeathReason.MICRODROID_PAYLOAD_HAS_CHANGED:
|
||
|
|
return STOP_REASON_MICRODROID_PAYLOAD_HAS_CHANGED;
|
||
|
|
case DeathReason.MICRODROID_PAYLOAD_VERIFICATION_FAILED:
|
||
|
|
return STOP_REASON_MICRODROID_PAYLOAD_VERIFICATION_FAILED;
|
||
|
|
case DeathReason.MICRODROID_INVALID_PAYLOAD_CONFIG:
|
||
|
|
return STOP_REASON_MICRODROID_INVALID_PAYLOAD_CONFIG;
|
||
|
|
case DeathReason.MICRODROID_UNKNOWN_RUNTIME_ERROR:
|
||
|
|
return STOP_REASON_MICRODROID_UNKNOWN_RUNTIME_ERROR;
|
||
|
|
case DeathReason.HANGUP:
|
||
|
|
return STOP_REASON_HANGUP;
|
||
|
|
default:
|
||
|
|
return STOP_REASON_UNKNOWN;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|