Merge changes from topic "lmkd-vm-integration"
* changes:
Implement a memory reclaim microdroid benchmark test
Plumb onTrimMemory app callback to virtualizationservice
diff --git a/javalib/src/android/system/virtualmachine/VirtualMachine.java b/javalib/src/android/system/virtualmachine/VirtualMachine.java
index ffcdc51..63b5628 100644
--- a/javalib/src/android/system/virtualmachine/VirtualMachine.java
+++ b/javalib/src/android/system/virtualmachine/VirtualMachine.java
@@ -49,7 +49,9 @@
import android.annotation.Nullable;
import android.annotation.RequiresPermission;
import android.annotation.SystemApi;
+import android.content.ComponentCallbacks2;
import android.content.Context;
+import android.content.res.Configuration;
import android.os.Binder;
import android.os.IBinder;
import android.os.ParcelFileDescriptor;
@@ -61,6 +63,7 @@
import android.system.virtualizationservice.IVirtualMachine;
import android.system.virtualizationservice.IVirtualMachineCallback;
import android.system.virtualizationservice.IVirtualizationService;
+import android.system.virtualizationservice.MemoryTrimLevel;
import android.system.virtualizationservice.PartitionType;
import android.system.virtualizationservice.VirtualMachineAppConfig;
import android.system.virtualizationservice.VirtualMachineState;
@@ -193,6 +196,56 @@
*/
@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);
+ }
+ }
+ }
+ }
+
+ @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
@@ -268,6 +321,8 @@
mInstanceFilePath = new File(thisVmDir, INSTANCE_IMAGE_FILE);
mIdsigFilePath = new File(thisVmDir, IDSIG_FILE);
mExtraApks = setupExtraApks(context, config, thisVmDir);
+ mMemoryManagementCallbacks = new MemoryManagementCallbacks();
+ mContext = context;
}
/**
@@ -696,6 +751,7 @@
executeCallback((cb) -> cb.onRamdump(VirtualMachine.this, ramdump));
}
});
+ mContext.registerComponentCallbacks(mMemoryManagementCallbacks);
service.asBinder().linkToDeath(deathRecipient, 0);
mVirtualMachine.start();
} catch (IOException | IllegalStateException | ServiceSpecificException e) {
@@ -772,6 +828,7 @@
}
try {
mVirtualMachine.stop();
+ mContext.unregisterComponentCallbacks(mMemoryManagementCallbacks);
mVirtualMachine = null;
} catch (RemoteException e) {
throw e.rethrowAsRuntimeException();
@@ -797,6 +854,7 @@
try {
if (stateToStatus(mVirtualMachine.getState()) == STATUS_RUNNING) {
mVirtualMachine.stop();
+ mContext.unregisterComponentCallbacks(mMemoryManagementCallbacks);
mVirtualMachine = null;
}
} catch (RemoteException e) {
diff --git a/tests/aidl/com/android/microdroid/testservice/IBenchmarkService.aidl b/tests/aidl/com/android/microdroid/testservice/IBenchmarkService.aidl
index 16e4893..c8c8660 100644
--- a/tests/aidl/com/android/microdroid/testservice/IBenchmarkService.aidl
+++ b/tests/aidl/com/android/microdroid/testservice/IBenchmarkService.aidl
@@ -30,6 +30,9 @@
/** Returns an entry from /proc/meminfo. */
long getMemInfoEntry(String name);
+ /** Allocates anonymous memory and returns the raw pointer. */
+ long allocAnonMemory(long mb);
+
/**
* Initializes the vsock server on VM.
* @return the server socket file descriptor.
diff --git a/tests/benchmark/src/java/com/android/microdroid/benchmark/MicrodroidBenchmarks.java b/tests/benchmark/src/java/com/android/microdroid/benchmark/MicrodroidBenchmarks.java
index 14a0e39..3c3faf2 100644
--- a/tests/benchmark/src/java/com/android/microdroid/benchmark/MicrodroidBenchmarks.java
+++ b/tests/benchmark/src/java/com/android/microdroid/benchmark/MicrodroidBenchmarks.java
@@ -27,6 +27,7 @@
import android.app.Instrumentation;
import android.os.Bundle;
import android.os.ParcelFileDescriptor;
+import android.os.Process;
import android.os.RemoteException;
import android.system.virtualmachine.VirtualMachine;
import android.system.virtualmachine.VirtualMachineConfig;
@@ -279,6 +280,58 @@
return runInShell(TAG, mInstrumentation.getUiAutomation(), command);
}
+ private static class CrosvmStats {
+ public final long mHostRss;
+ public final long mHostPss;
+ public final long mGuestRss;
+ public final long mGuestPss;
+
+ CrosvmStats(Function<String, String> shellExecutor) {
+ try {
+ List<Integer> crosvmPids =
+ ProcessUtil.getProcessMap(shellExecutor).entrySet().stream()
+ .filter(e -> e.getValue().contains("crosvm"))
+ .map(e -> e.getKey())
+ .collect(java.util.stream.Collectors.toList());
+ if (crosvmPids.size() != 1) {
+ throw new IllegalStateException(
+ "expected to find exactly one crosvm processes, found "
+ + crosvmPids.size());
+ }
+
+ long hostRss = 0;
+ long hostPss = 0;
+ long guestRss = 0;
+ long guestPss = 0;
+ boolean hasGuestMaps = false;
+ for (ProcessUtil.SMapEntry entry :
+ ProcessUtil.getProcessSmaps(crosvmPids.get(0), shellExecutor)) {
+ long rss = entry.metrics.get("Rss");
+ long pss = entry.metrics.get("Pss");
+ if (entry.name.contains("crosvm_guest")) {
+ guestRss += rss;
+ guestPss += pss;
+ hasGuestMaps = true;
+ } else {
+ hostRss += rss;
+ hostPss += pss;
+ }
+ }
+ if (!hasGuestMaps) {
+ throw new IllegalStateException(
+ "found no crosvm_guest smap entry in crosvm process");
+ }
+ mHostRss = hostRss;
+ mHostPss = hostPss;
+ mGuestRss = guestRss;
+ mGuestPss = guestPss;
+ } catch (Exception e) {
+ Log.e(TAG, "Error inside onPayloadReady():" + e);
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
@Test
public void testMemoryUsage() throws Exception {
final String vmName = "test_vm_mem_usage";
@@ -299,10 +352,10 @@
double mem_buffers = (double) listener.mBuffers / 1024.0;
double mem_cached = (double) listener.mCached / 1024.0;
double mem_slab = (double) listener.mSlab / 1024.0;
- double mem_crosvm_host_rss = (double) listener.mCrosvmHostRss / 1024.0;
- double mem_crosvm_host_pss = (double) listener.mCrosvmHostPss / 1024.0;
- double mem_crosvm_guest_rss = (double) listener.mCrosvmGuestRss / 1024.0;
- double mem_crosvm_guest_pss = (double) listener.mCrosvmGuestPss / 1024.0;
+ double mem_crosvm_host_rss = (double) listener.mCrosvm.mHostRss / 1024.0;
+ double mem_crosvm_host_pss = (double) listener.mCrosvm.mHostPss / 1024.0;
+ double mem_crosvm_guest_rss = (double) listener.mCrosvm.mGuestRss / 1024.0;
+ double mem_crosvm_guest_pss = (double) listener.mCrosvm.mGuestPss / 1024.0;
double mem_kernel = mem_overall - mem_total;
double mem_used = mem_total - mem_free - mem_buffers - mem_cached - mem_slab;
@@ -327,7 +380,7 @@
mShellExecutor = shellExecutor;
}
- public Function<String, String> mShellExecutor;
+ public final Function<String, String> mShellExecutor;
public long mMemTotal;
public long mMemFree;
@@ -336,10 +389,7 @@
public long mCached;
public long mSlab;
- public long mCrosvmHostRss;
- public long mCrosvmHostPss;
- public long mCrosvmGuestRss;
- public long mCrosvmGuestPss;
+ public CrosvmStats mCrosvm;
@Override
public void onPayloadReady(VirtualMachine vm, IBenchmarkService service)
@@ -350,39 +400,80 @@
mBuffers = service.getMemInfoEntry("Buffers");
mCached = service.getMemInfoEntry("Cached");
mSlab = service.getMemInfoEntry("Slab");
+ mCrosvm = new CrosvmStats(mShellExecutor);
+ }
+ }
+ @Test
+ public void testMemoryReclaim() throws Exception {
+ final String vmName = "test_vm_mem_reclaim";
+ VirtualMachineConfig config =
+ newVmConfigBuilder()
+ .setPayloadConfigPath("assets/vm_config_io.json")
+ .setDebugLevel(DEBUG_LEVEL_NONE)
+ .setMemoryMib(256)
+ .build();
+ VirtualMachine vm = forceCreateNewVirtualMachine(vmName, config);
+ MemoryReclaimListener listener = new MemoryReclaimListener(this::executeCommand);
+ BenchmarkVmListener.create(listener).runToFinish(TAG, vm);
+
+ double mem_pre_crosvm_host_rss = (double) listener.mPreCrosvm.mHostRss / 1024.0;
+ double mem_pre_crosvm_host_pss = (double) listener.mPreCrosvm.mHostPss / 1024.0;
+ double mem_pre_crosvm_guest_rss = (double) listener.mPreCrosvm.mGuestRss / 1024.0;
+ double mem_pre_crosvm_guest_pss = (double) listener.mPreCrosvm.mGuestPss / 1024.0;
+ double mem_post_crosvm_host_rss = (double) listener.mPostCrosvm.mHostRss / 1024.0;
+ double mem_post_crosvm_host_pss = (double) listener.mPostCrosvm.mHostPss / 1024.0;
+ double mem_post_crosvm_guest_rss = (double) listener.mPostCrosvm.mGuestRss / 1024.0;
+ double mem_post_crosvm_guest_pss = (double) listener.mPostCrosvm.mGuestPss / 1024.0;
+
+ Bundle bundle = new Bundle();
+ bundle.putDouble(
+ METRIC_NAME_PREFIX + "mem_pre_crosvm_host_rss_MB", mem_pre_crosvm_host_rss);
+ bundle.putDouble(
+ METRIC_NAME_PREFIX + "mem_pre_crosvm_host_pss_MB", mem_pre_crosvm_host_pss);
+ bundle.putDouble(
+ METRIC_NAME_PREFIX + "mem_pre_crosvm_guest_rss_MB", mem_pre_crosvm_guest_rss);
+ bundle.putDouble(
+ METRIC_NAME_PREFIX + "mem_pre_crosvm_guest_pss_MB", mem_pre_crosvm_guest_pss);
+ bundle.putDouble(
+ METRIC_NAME_PREFIX + "mem_post_crosvm_host_rss_MB", mem_post_crosvm_host_rss);
+ bundle.putDouble(
+ METRIC_NAME_PREFIX + "mem_post_crosvm_host_pss_MB", mem_post_crosvm_host_pss);
+ bundle.putDouble(
+ METRIC_NAME_PREFIX + "mem_post_crosvm_guest_rss_MB", mem_post_crosvm_guest_rss);
+ bundle.putDouble(
+ METRIC_NAME_PREFIX + "mem_post_crosvm_guest_pss_MB", mem_post_crosvm_guest_pss);
+ mInstrumentation.sendStatus(0, bundle);
+ }
+
+ private static class MemoryReclaimListener implements BenchmarkVmListener.InnerListener {
+ MemoryReclaimListener(Function<String, String> shellExecutor) {
+ mShellExecutor = shellExecutor;
+ }
+
+ public final Function<String, String> mShellExecutor;
+
+ public CrosvmStats mPreCrosvm;
+ public CrosvmStats mPostCrosvm;
+
+ @Override
+ @SuppressWarnings("ReturnValueIgnored")
+ public void onPayloadReady(VirtualMachine vm, IBenchmarkService service)
+ throws RemoteException {
+ // Allocate 256MB of anonymous memory. This will fill all guest
+ // memory and cause swapping to start.
+ service.allocAnonMemory(256);
+ mPreCrosvm = new CrosvmStats(mShellExecutor);
+ // Send a memory trim hint to cause memory reclaim.
+ mShellExecutor.apply("am send-trim-memory " + Process.myPid() + " RUNNING_CRITICAL");
+ // Give time for the memory reclaim to do its work.
try {
- List<Integer> crosvmPids =
- ProcessUtil.getProcessMap(mShellExecutor).entrySet().stream()
- .filter(e -> e.getValue().contains("crosvm"))
- .map(e -> e.getKey())
- .collect(java.util.stream.Collectors.toList());
- if (crosvmPids.size() != 1) {
- throw new RuntimeException(
- "expected to find exactly one crosvm processes, found "
- + crosvmPids.size());
- }
-
- mCrosvmHostRss = 0;
- mCrosvmHostPss = 0;
- mCrosvmGuestRss = 0;
- mCrosvmGuestPss = 0;
- for (ProcessUtil.SMapEntry entry :
- ProcessUtil.getProcessSmaps(crosvmPids.get(0), mShellExecutor)) {
- long rss = entry.metrics.get("Rss");
- long pss = entry.metrics.get("Pss");
- if (entry.name.contains("crosvm_guest")) {
- mCrosvmGuestRss += rss;
- mCrosvmGuestPss += pss;
- } else {
- mCrosvmHostRss += rss;
- mCrosvmHostPss += pss;
- }
- }
- } catch (Exception e) {
- Log.e(TAG, "Error inside onPayloadReady():" + e);
- throw new RuntimeException(e);
+ Thread.sleep(isCuttlefish() ? 10000 : 5000);
+ } catch (InterruptedException e) {
+ Log.e(TAG, "Interrupted sleep:" + e);
+ Thread.currentThread().interrupt();
}
+ mPostCrosvm = new CrosvmStats(mShellExecutor);
}
}
diff --git a/tests/benchmark/src/native/benchmarkbinary.cpp b/tests/benchmark/src/native/benchmarkbinary.cpp
index 70ec7db..5c172c0 100644
--- a/tests/benchmark/src/native/benchmarkbinary.cpp
+++ b/tests/benchmark/src/native/benchmarkbinary.cpp
@@ -77,6 +77,11 @@
return ndk::ScopedAStatus::ok();
}
+ ndk::ScopedAStatus allocAnonMemory(long mb, long* out) override {
+ *out = (long)alloc_anon_memory(mb);
+ return ndk::ScopedAStatus::ok();
+ }
+
ndk::ScopedAStatus initVsockServer(int32_t port, int32_t* out) override {
auto res = io_vsock::init_vsock_server(port);
if (res.ok()) {
@@ -131,6 +136,17 @@
return {file_size_mb / elapsed_seconds};
}
+ void* alloc_anon_memory(long mb) {
+ long bytes = mb << 20;
+ void* p = malloc(bytes);
+ /*
+ * Heap memory is demand allocated. Dirty all pages to ensure
+ * all are allocated.
+ */
+ memset(p, 0x55, bytes);
+ return p;
+ }
+
Result<size_t> read_meminfo_entry(const std::string& stat) {
std::ifstream fs("/proc/meminfo");
if (!fs.is_open()) {
diff --git a/virtualizationservice/Android.bp b/virtualizationservice/Android.bp
index b767013..da56f76 100644
--- a/virtualizationservice/Android.bp
+++ b/virtualizationservice/Android.bp
@@ -51,6 +51,7 @@
"libshared_child",
"libstatslog_virtualization_rust",
"libtombstoned_client_rust",
+ "libvm_control",
"libvmconfig",
"libzip",
"libvsock",
diff --git a/virtualizationservice/aidl/android/system/virtualizationservice/IVirtualMachine.aidl b/virtualizationservice/aidl/android/system/virtualizationservice/IVirtualMachine.aidl
index d9d9a61..d76b586 100644
--- a/virtualizationservice/aidl/android/system/virtualizationservice/IVirtualMachine.aidl
+++ b/virtualizationservice/aidl/android/system/virtualizationservice/IVirtualMachine.aidl
@@ -16,6 +16,7 @@
package android.system.virtualizationservice;
import android.system.virtualizationservice.IVirtualMachineCallback;
+import android.system.virtualizationservice.MemoryTrimLevel;
import android.system.virtualizationservice.VirtualMachineState;
interface IVirtualMachine {
@@ -41,6 +42,9 @@
*/
void stop();
+ /** Communicate app low-memory notifications to the VM. */
+ void onTrimMemory(MemoryTrimLevel level);
+
/** Open a vsock connection to the CID of the VM on the given port. */
ParcelFileDescriptor connectVsock(int port);
}
diff --git a/virtualizationservice/aidl/android/system/virtualizationservice/MemoryTrimLevel.aidl b/virtualizationservice/aidl/android/system/virtualizationservice/MemoryTrimLevel.aidl
new file mode 100644
index 0000000..9ed9e99
--- /dev/null
+++ b/virtualizationservice/aidl/android/system/virtualizationservice/MemoryTrimLevel.aidl
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2022 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.virtualizationservice;
+
+/**
+ * Memory trim levels propagated from the app to the VM.
+ */
+@Backing(type="int")
+enum MemoryTrimLevel {
+ /* Same meaning as in ComponentCallbacks2 */
+ TRIM_MEMORY_RUNNING_CRITICAL = 0,
+ TRIM_MEMORY_RUNNING_LOW = 1,
+ TRIM_MEMORY_RUNNING_MODERATE = 2,
+}
diff --git a/virtualizationservice/src/aidl.rs b/virtualizationservice/src/aidl.rs
index 040c0d8..7d24a32 100644
--- a/virtualizationservice/src/aidl.rs
+++ b/virtualizationservice/src/aidl.rs
@@ -27,6 +27,7 @@
IVirtualMachine::{BnVirtualMachine, IVirtualMachine},
IVirtualMachineCallback::IVirtualMachineCallback,
IVirtualizationService::IVirtualizationService,
+ MemoryTrimLevel::MemoryTrimLevel,
Partition::Partition,
PartitionType::PartitionType,
VirtualMachineAppConfig::{Payload::Payload, VirtualMachineAppConfig},
@@ -961,6 +962,13 @@
})
}
+ fn onTrimMemory(&self, level: MemoryTrimLevel) -> binder::Result<()> {
+ self.instance.trim_memory(level).map_err(|e| {
+ error!("Error trimming VM with CID {}: {:?}", self.instance.cid, e);
+ Status::new_service_specific_error_str(-1, Some(e.to_string()))
+ })
+ }
+
fn connectVsock(&self, port: i32) -> binder::Result<ParcelFileDescriptor> {
if !matches!(&*self.instance.vm_state.lock().unwrap(), VmState::Running { .. }) {
return Err(Status::new_service_specific_error_str(-1, Some("VM is not running")));
diff --git a/virtualizationservice/src/crosvm.rs b/virtualizationservice/src/crosvm.rs
index 00c33ef..0fdc293 100644
--- a/virtualizationservice/src/crosvm.rs
+++ b/virtualizationservice/src/crosvm.rs
@@ -39,7 +39,10 @@
use std::sync::{Arc, Condvar, Mutex};
use std::time::{Duration, SystemTime};
use std::thread;
-use android_system_virtualizationservice::aidl::android::system::virtualizationservice::DeathReason::DeathReason;
+use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{
+ DeathReason::DeathReason,
+ MemoryTrimLevel::MemoryTrimLevel,
+};
use android_system_virtualizationservice_internal::aidl::android::system::virtualizationservice_internal::IGlobalVmContext::IGlobalVmContext;
use binder::Strong;
use android_system_virtualmachineservice::aidl::android::system::virtualmachineservice::IVirtualMachineService::IVirtualMachineService;
@@ -48,6 +51,7 @@
/// external/crosvm
use base::UnixSeqpacketListener;
+use vm_control::{BalloonControlCommand, VmRequest, VmResponse};
const CROSVM_PATH: &str = "/apex/com.android.virt/bin/crosvm";
@@ -172,7 +176,7 @@
// If this fails and returns an error, `self` will be left in the `Failed` state.
let child =
- Arc::new(run_vm(config, &instance.temporary_directory, failure_pipe_write)?);
+ Arc::new(run_vm(config, &instance.crosvm_control_socket_path, failure_pipe_write)?);
let instance_monitor_status = instance.clone();
let child_monitor_status = child.clone();
@@ -229,6 +233,8 @@
vm_context: VmContext,
/// The CID assigned to the VM for vsock communication.
pub cid: Cid,
+ /// Path to crosvm control socket
+ crosvm_control_socket_path: PathBuf,
/// The name of the VM.
pub name: String,
/// Whether the VM is a protected VM.
@@ -286,6 +292,7 @@
vm_state: Mutex::new(VmState::NotStarted { config }),
vm_context,
cid,
+ crosvm_control_socket_path: temporary_directory.join("crosvm.sock"),
name,
protected,
temporary_directory,
@@ -465,6 +472,46 @@
}
}
+ /// Responds to memory-trimming notifications by inflating the virtio
+ /// balloon to reclaim guest memory.
+ pub fn trim_memory(&self, level: MemoryTrimLevel) -> Result<(), Error> {
+ let request = VmRequest::BalloonCommand(BalloonControlCommand::Stats {});
+ match vm_control::client::handle_request(&request, &self.crosvm_control_socket_path) {
+ Ok(VmResponse::BalloonStats { stats, balloon_actual: _ }) => {
+ if let Some(total_memory) = stats.total_memory {
+ // Reclaim up to 50% of total memory assuming worst case
+ // most memory is anonymous and must be swapped to zram
+ // with an approximate 2:1 compression ratio.
+ let pct = match level {
+ MemoryTrimLevel::TRIM_MEMORY_RUNNING_CRITICAL => 50,
+ MemoryTrimLevel::TRIM_MEMORY_RUNNING_LOW => 30,
+ MemoryTrimLevel::TRIM_MEMORY_RUNNING_MODERATE => 10,
+ _ => bail!("Invalid memory trim level {:?}", level),
+ };
+ let command =
+ BalloonControlCommand::Adjust { num_bytes: total_memory * pct / 100 };
+ if let Err(e) = vm_control::client::handle_request(
+ &VmRequest::BalloonCommand(command),
+ &self.crosvm_control_socket_path,
+ ) {
+ bail!("Error sending balloon adjustment: {:?}", e);
+ }
+ }
+ }
+ Ok(VmResponse::Err(e)) => {
+ // ENOTSUP is returned when the balloon protocol is not initialised. This
+ // can occur for numerous reasons: Guest is still booting, guest doesn't
+ // support ballooning, host doesn't support ballooning. We don't log or
+ // raise an error in this case: trim is just a hint and we can ignore it.
+ if e.errno() != libc::ENOTSUP {
+ bail!("Errno return when requesting balloon stats: {}", e.errno())
+ }
+ }
+ e => bail!("Error requesting balloon stats: {:?}", e),
+ }
+ Ok(())
+ }
+
/// Checks if ramdump has been created. If so, send a notification to the user with the handle
/// to read the ramdump.
fn handle_ramdump(&self) -> Result<(), Error> {
@@ -604,7 +651,7 @@
/// Starts an instance of `crosvm` to manage a new VM.
fn run_vm(
config: CrosvmConfig,
- temporary_directory: &Path,
+ crosvm_control_socket_path: &Path,
failure_pipe_write: File,
) -> Result<SharedChild, Error> {
validate_config(&config)?;
@@ -710,9 +757,8 @@
command.arg(add_preserved_fd(&mut preserved_fds, kernel));
}
- let control_server_socket =
- UnixSeqpacketListener::bind(temporary_directory.join("crosvm.sock"))
- .context("failed to create control server")?;
+ let control_server_socket = UnixSeqpacketListener::bind(crosvm_control_socket_path)
+ .context("failed to create control server")?;
command.arg("--socket").arg(add_preserved_fd(&mut preserved_fds, &control_server_socket));
debug!("Preserving FDs {:?}", preserved_fds);