Create VmManagerIs[Crosvm,Qemu,Gem5] utilities

base/cvd/cuttlefish/host/commands/assemble_cvd/BUILD.bazel

@@ -179,7 +179,6 @@ cf_cc_library(
         "//cuttlefish/host/libs/config:fetcher_config",
         "//cuttlefish/host/libs/config:file_source",
         "//cuttlefish/host/libs/config:instance_nums",
-        "//cuttlefish/host/libs/config:vmm_mode",
         "//cuttlefish/host/libs/feature:inject",
         "//libbase",
         "@abseil-cpp//absl/strings",
@@ -220,7 +219,6 @@ cf_cc_library(
         "//cuttlefish/host/libs/config:cuttlefish_config",
         "//cuttlefish/host/libs/config:fetcher_config",
         "//cuttlefish/host/libs/config:instance_nums",
-        "//cuttlefish/host/libs/config:vmm_mode",
         "//libbase",
     ],
 )

base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp

@@ -115,9 +115,8 @@ Result<std::unordered_map<std::string, std::string>> BootconfigArgsFromConfig(
         std::to_string(instance.openthread_node_id());
   }
 
-  const auto enable_confui = (config.vm_manager() == VmmMode::kQemu ? 0 : 1);
   bootconfig_args["androidboot.enable_confirmationui"] =
-      std::to_string(enable_confui);
+      std::to_string(!VmManagerIsQemu(config));
 
   if (instance.audiocontrol_server_port()) {
     bootconfig_args["androidboot.vendor.audiocontrol.server.cid"] =

base/cvd/cuttlefish/host/commands/assemble_cvd/create_dynamic_disk_files.cc

@@ -59,7 +59,6 @@
 #include "cuttlefish/host/libs/config/fetched_archive.h"
 #include "cuttlefish/host/libs/config/fetcher_config.h"
 #include "cuttlefish/host/libs/config/file_source.h"
-#include "cuttlefish/host/libs/config/vmm_mode.h"
 
 namespace cuttlefish {
 namespace {
@@ -234,7 +233,7 @@ Result<void> CreateDynamicDiskFiles(
 
     // Gem5 Simulate per-instance what the bootloader would usually do
     // Since on other devices this runs every time, just do it here every time
-    if (config.vm_manager() == VmmMode::kGem5) {
+    if (VmManagerIsGem5(config)) {
       RepackGem5BootImage(instance.PerInstancePath("initrd.img"), boot_config,
                           config.assembly_dir(), instance.initramfs_path());
     }

base/cvd/cuttlefish/host/commands/assemble_cvd/disk/BUILD.bazel

@@ -199,7 +199,6 @@ cf_cc_library(
         "//cuttlefish/host/commands/assemble_cvd/disk:generate_persistent_vbmeta",
         "//cuttlefish/host/libs/config:ap_boot_flow",
         "//cuttlefish/host/libs/config:cuttlefish_config",
-        "//cuttlefish/host/libs/config:vmm_mode",
         "//cuttlefish/host/libs/image_aggregator",
         "//cuttlefish/host/libs/vm_manager",
         "@gflags",
@@ -315,7 +314,6 @@ cf_cc_library(
         "//cuttlefish/common/libs/utils:result",
         "//cuttlefish/host/libs/config:cuttlefish_config",
         "//cuttlefish/host/libs/config:data_image",
-        "//cuttlefish/host/libs/config:vmm_mode",
         "//cuttlefish/host/libs/image_aggregator:qcow2",
     ],
 )

base/cvd/cuttlefish/host/commands/assemble_cvd/disk/gem5_image_unpacker.cpp

@@ -27,7 +27,7 @@
 namespace cuttlefish {
 
 Result<void> Gem5ImageUnpacker(const CuttlefishConfig& config) {
-  if (config.vm_manager() != VmmMode::kGem5) {
+  if (!VmManagerIsGem5(config)) {
     return {};
   }
   // TODO: b/281130788 - This should accept InstanceSpecific as an argument

base/cvd/cuttlefish/host/commands/assemble_cvd/disk/generate_persistent_bootconfig.cpp

@@ -16,7 +16,6 @@
 
 #include "cuttlefish/host/commands/assemble_cvd/disk/generate_persistent_bootconfig.h"
 
-#include <memory>
 #include <optional>
 #include <string>
 
@@ -74,7 +73,7 @@ Result<std::optional<BootConfigPartition>> BootConfigPartition::CreateIfNeeded(
                                 << bootconfig_path
                                 << "` failed:" << bootconfig_fd->StrError());
 
-  if (config.vm_manager() == VmmMode::kGem5) {
+  if (VmManagerIsGem5(config)) {
     const off_t bootconfig_size_bytes_gem5 =
         AlignToPowerOf2(bytesWritten, PARTITION_SIZE_SHIFT);
     CF_EXPECT(bootconfig_fd->Truncate(bootconfig_size_bytes_gem5) == 0);

base/cvd/cuttlefish/host/commands/assemble_cvd/disk/initialize_instance_composite_disk.cc

@@ -26,7 +26,6 @@
 #include "cuttlefish/host/commands/assemble_cvd/disk_builder.h"
 #include "cuttlefish/host/libs/config/ap_boot_flow.h"
 #include "cuttlefish/host/libs/config/cuttlefish_config.h"
-#include "cuttlefish/host/libs/config/vmm_mode.h"
 #include "cuttlefish/host/libs/image_aggregator/image_aggregator.h"
 
 namespace cuttlefish {
@@ -71,10 +70,6 @@ std::vector<ImagePartition> PersistentAPCompositeDiskConfig(
   return partitions;
 }
 
-bool IsVmManagerQemu(const CuttlefishConfig& config) {
-  return config.vm_manager() == VmmMode::kQemu;
-}
-
 }  // namespace
 
 Result<InstanceCompositeDisk> InstanceCompositeDisk::Create(
@@ -104,7 +99,7 @@ Result<InstanceCompositeDisk> InstanceCompositeDisk::Create(
   std::string overlay_path =
       instance.PerInstancePath("persistent_composite_overlay.img");
   persistent_disk_builder.OverlayPath(overlay_path);
-  if (IsVmManagerQemu(config)) {
+  if (VmManagerIsQemu(config)) {
     CF_EXPECT(persistent_disk_builder.BuildOverlayIfNecessary());
   }
   return InstanceCompositeDisk();
@@ -136,7 +131,7 @@ Result<std::optional<ApCompositeDisk>> ApCompositeDisk::Create(
   CF_EXPECT(persistent_ap_disk_builder.BuildCompositeDiskIfNecessary());
   persistent_ap_disk_builder.OverlayPath(
       instance.PerInstancePath("ap_persistent_composite_overlay.img"));
-  if (IsVmManagerQemu(config)) {
+  if (VmManagerIsQemu(config)) {
     CF_EXPECT(persistent_ap_disk_builder.BuildOverlayIfNecessary());
   }
   return ApCompositeDisk();

base/cvd/cuttlefish/host/commands/assemble_cvd/disk/kernel_ramdisk_repacker.cpp

@@ -109,7 +109,7 @@ Result<void> RepackKernelRamdisk(
   // large to be repacked. Skip repack of boot.img on Gem5, as we need to be
   // able to extract the ramdisk.img in a later stage and so this step must
   // not fail (..and the repacked kernel wouldn't be used anyway).
-  if (!instance.kernel_path().empty() && config.vm_manager() != VmmMode::kGem5) {
+  if (!instance.kernel_path().empty() && !VmManagerIsGem5(config)) {
     CF_EXPECT(
         RepackBootImage(avb, instance.kernel_path(), instance.boot_image(),
                         instance.new_boot_image(), instance.instance_dir()),

base/cvd/cuttlefish/host/commands/assemble_cvd/disk/sd_card.cc

@@ -20,7 +20,6 @@
 #include "cuttlefish/common/libs/utils/result.h"
 #include "cuttlefish/host/libs/config/cuttlefish_config.h"
 #include "cuttlefish/host/libs/config/data_image.h"
-#include "cuttlefish/host/libs/config/vmm_mode.h"
 #include "cuttlefish/host/libs/image_aggregator/qcow2.h"
 
 namespace cuttlefish {
@@ -37,7 +36,7 @@ Result<void> InitializeSdCard(
   CF_EXPECT(CreateBlankImage(instance.sdcard_path(),
                              instance.blank_sdcard_image_mb(), "sdcard"),
             "Failed to create \"" << instance.sdcard_path() << "\"");
-  if (config.vm_manager() == VmmMode::kQemu) {
+  if (VmManagerIsQemu(config)) {
     const std::string crosvm_path = instance.crosvm_binary();
     CF_EXPECT(Qcow2Image::Create(crosvm_path, instance.sdcard_path(),
                                  instance.sdcard_overlay_path()));

base/cvd/cuttlefish/host/commands/assemble_cvd/disk_builder.cpp

@@ -208,7 +208,7 @@ Result<bool> DiskBuilder::BuildCompositeDiskIfNecessary() {
 
   CF_EXPECT(vm_manager_ != VmmMode::kUnknown);
   // TODO: b/346855591 - run with QEMU when crosvm block device is integrated
-  if (vm_manager_ == VmmMode::kCrosvm) {
+  if (VmManagerIsCrosvm(vm_manager_)) {
     CF_EXPECT(!header_path_.empty(), "No header path");
     CF_EXPECT(!footer_path_.empty(), "No footer path");
     CF_EXPECT(CreateOrUpdateCompositeDisk(

base/cvd/cuttlefish/host/commands/assemble_cvd/disk_image_flags_vectorization.cc

@@ -38,7 +38,6 @@
 #include "cuttlefish/host/libs/config/cuttlefish_config.h"
 #include "cuttlefish/host/libs/config/fetcher_config.h"
 #include "cuttlefish/host/libs/config/instance_nums.h"
-#include "cuttlefish/host/libs/config/vmm_mode.h"
 
 namespace cuttlefish {
 
@@ -214,7 +213,7 @@ Result<void> DiskImageFlagsVectorization(
     const CuttlefishConfig::InstanceSpecific const_instance =
         const_config.ForInstance(num);
     if (!kernel_path.KernelPathForIndex(instance_index).empty() &&
-        config.vm_manager() != VmmMode::kGem5) {
+        !VmManagerIsGem5(config)) {
       const std::string new_boot_image_path =
           const_instance.PerInstancePath("boot_repacked.img");
       // change the new flag value to corresponding instance

base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc

@@ -850,7 +850,7 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
       std::set<Arch> default_on_arch = {Arch::Arm64};
       if (guest_configs[instance_index].vhost_user_vsock) {
         instance.set_vhost_user_vsock(true);
-      } else if (tmp_config_obj.vm_manager() == VmmMode::kCrosvm &&
+      } else if (VmManagerIsCrosvm(tmp_config_obj) &&
                  default_on_arch.find(
                      guest_configs[instance_index].target_arch) !=
                      default_on_arch.end()) {
@@ -1150,28 +1150,23 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
 
     std::vector<std::string> virtual_disk_paths;
 
-    bool os_overlay = true;
     // Gem5 already uses CoW wrappers around disk images
-    os_overlay &= vm_manager_flag.Mode() != VmmMode::kGem5;
-    os_overlay &= FLAGS_use_overlay;
-    if (os_overlay) {
+    if (FLAGS_use_overlay && !VmManagerIsGem5(vm_manager_flag)) {
       auto path = const_instance.PerInstancePath("overlay.img");
       virtual_disk_paths.push_back(path);
     } else {
       virtual_disk_paths.push_back(const_instance.os_composite_disk_path());
     }
 
-    bool persistent_disk = vm_manager_flag.Mode() != VmmMode::kGem5;
+    bool persistent_disk = !VmManagerIsGem5(vm_manager_flag);
     if (persistent_disk) {
 #ifdef __APPLE__
       const std::string persistent_composite_img_base =
           "persistent_composite.img";
 #else
-      const bool is_vm_qemu_cli =
-          (tmp_config_obj.vm_manager() == VmmMode::kQemu);
       const std::string persistent_composite_img_base =
-          is_vm_qemu_cli ? "persistent_composite_overlay.img"
-                         : "persistent_composite.img";
+          VmManagerIsQemu(tmp_config_obj) ? "persistent_composite_overlay.img"
+                                          : "persistent_composite.img";
 #endif
       auto path =
           const_instance.PerInstancePath(persistent_composite_img_base.data());
@@ -1182,7 +1177,7 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
 
     bool sdcard = use_sdcard_vec[instance_index];
     if (sdcard) {
-      if (tmp_config_obj.vm_manager() == VmmMode::kQemu) {
+      if (VmManagerIsQemu(tmp_config_obj)) {
         virtual_disk_paths.push_back(const_instance.sdcard_overlay_path());
       } else {
         virtual_disk_paths.push_back(const_instance.sdcard_path());
@@ -1269,7 +1264,7 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
     auto external_network_mode = CF_EXPECT(
         ParseExternalNetworkMode(device_external_network_vec[instance_index]));
     CF_EXPECT(external_network_mode == ExternalNetworkMode::kTap ||
-                  vm_manager_flag.Mode() == VmmMode::kQemu,
+                  VmManagerIsQemu(vm_manager_flag),
               "TODO(b/286284441): slirp only works on QEMU");
     instance.set_external_network_mode(external_network_mode);
 
@@ -1333,11 +1328,10 @@ Result<CuttlefishConfig> InitializeCuttlefishConfiguration(
   const auto& environment_specific =
       (static_cast<const CuttlefishConfig&>(tmp_config_obj))
           .ForEnvironment(environment_name);
-  CF_EXPECT(CheckSnapshotCompatible(
-                FLAGS_snapshot_compatible &&
-                    (tmp_config_obj.vm_manager() == VmmMode::kCrosvm) &&
-                    instance_nums.size() == 1,
-                calculated_gpu_mode_vec),
+  CF_EXPECT(CheckSnapshotCompatible(FLAGS_snapshot_compatible &&
+                                        VmManagerIsCrosvm(tmp_config_obj) &&
+                                        instance_nums.size() == 1,
+                                    calculated_gpu_mode_vec),
             "The set of flags is incompatible with snapshot");
 
   AndroidEfiLoaderFlag efi_loader =

base/cvd/cuttlefish/host/commands/assemble_cvd/flags/vm_manager.cc

@@ -66,4 +66,16 @@ VmManagerFlag::VmManagerFlag(VmmMode mode) : mode_(mode) {}
 
 VmmMode VmManagerFlag::Mode() const { return mode_; }
 
+bool VmManagerIsCrosvm(const VmManagerFlag& vmm) {
+  return VmManagerIsCrosvm(vmm.Mode());
+}
+
+bool VmManagerIsQemu(const VmManagerFlag& vmm) {
+  return VmManagerIsQemu(vmm.Mode());
+}
+
+bool VmManagerIsGem5(const VmManagerFlag& vmm) {
+  return VmManagerIsGem5(vmm.Mode());
+}
+
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/assemble_cvd/flags/vm_manager.h

@@ -36,4 +36,8 @@ class VmManagerFlag {
   VmmMode mode_;
 };
 
+bool VmManagerIsCrosvm(const VmManagerFlag&);
+bool VmManagerIsQemu(const VmManagerFlag&);
+bool VmManagerIsGem5(const VmManagerFlag&);
+
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/assemble_cvd/graphics_flags.cc

@@ -292,7 +292,7 @@ Result<std::string> SelectGpuMode(
       LOG(INFO) << "GPU auto mode: detected prerequisites for accelerated "
                 << "rendering support.";
 
-      if (vmm == VmmMode::kQemu && !UseQemuPrebuilt()) {
+      if (VmManagerIsQemu(vmm) && !UseQemuPrebuilt()) {
         LOG(INFO) << "Not using QEMU prebuilt (QEMU 8+): selecting guest swiftshader";
         return kGpuModeGuestSwiftshader;
       } else if (guest_config.prefer_drm_virgl_when_supported) {
@@ -325,7 +325,7 @@ Result<std::string> SelectGpuMode(
                     "--gpu_mode=auto or --gpu_mode=guest_swiftshader.";
     }
 
-    if (vmm == VmmMode::kQemu && !UseQemuPrebuilt()) {
+    if (VmManagerIsQemu(vmm) && !UseQemuPrebuilt()) {
       LOG(INFO) << "Not using QEMU prebuilt (QEMU 8+): selecting guest swiftshader";
       return kGpuModeGuestSwiftshader;
     }
@@ -347,7 +347,7 @@ Result<bool> SelectGpuVhostUserMode(const std::string& gpu_mode,
       return false;
     }
 
-    if (vmm != VmmMode::kCrosvm) {
+    if (!VmManagerIsCrosvm(vmm)) {
       LOG(INFO) << "GPU vhost user auto mode: not yet supported with " << vmm
                 << ". Not enabling vhost user gpu.";
       return false;

base/cvd/cuttlefish/host/commands/run_cvd/launch/BUILD.bazel

@@ -307,7 +307,6 @@ cf_cc_library(
         "//cuttlefish/host/libs/config:ap_boot_flow",
         "//cuttlefish/host/libs/config:cuttlefish_config",
         "//cuttlefish/host/libs/config:openwrt_args",
-        "//cuttlefish/host/libs/config:vmm_mode",
         "//cuttlefish/host/libs/feature",
         "//cuttlefish/host/libs/vm_manager",
         "//libbase",
@@ -447,7 +446,6 @@ cf_cc_library(
         "//cuttlefish/host/libs/config:cuttlefish_config",
         "//cuttlefish/host/libs/config:guest_os",
         "//cuttlefish/host/libs/config:known_paths",
-        "//cuttlefish/host/libs/config:vmm_mode",
         "//cuttlefish/host/libs/feature",
         "//libbase",
         "@fmt",

base/cvd/cuttlefish/host/commands/run_cvd/launch/open_wrt.cpp

@@ -34,7 +34,6 @@
 #include "cuttlefish/host/libs/config/ap_boot_flow.h"
 #include "cuttlefish/host/libs/config/cuttlefish_config.h"
 #include "cuttlefish/host/libs/config/openwrt_args.h"
-#include "cuttlefish/host/libs/config/vmm_mode.h"
 #include "cuttlefish/host/libs/feature/command_source.h"
 #include "cuttlefish/host/libs/feature/feature.h"
 #include "cuttlefish/host/libs/vm_manager/crosvm_builder.h"
@@ -146,7 +145,7 @@ class OpenWrt : public CommandSource {
     auto openwrt_args = OpenwrtArgsFromConfig(instance_);
     switch (instance_.ap_boot_flow()) {
       case APBootFlow::Grub:
-        if (config_.vm_manager() == VmmMode::kQemu) {
+        if (VmManagerIsQemu(config_)) {
           ap_cmd.AddReadWriteDisk(
               instance_.persistent_ap_composite_overlay_path());
         } else {
@@ -179,7 +178,7 @@ class OpenWrt : public CommandSource {
   std::string Name() const override { return "OpenWrt"; }
   bool Enabled() const override {
     return instance_.ap_boot_flow() != APBootFlow::None &&
-           config_.vm_manager() == VmmMode::kCrosvm;
+           VmManagerIsCrosvm(config_);
   }
 
  private:

base/cvd/cuttlefish/host/commands/run_cvd/launch/streamer.cpp

@@ -44,7 +44,6 @@
 #include "cuttlefish/host/libs/config/custom_actions.h"
 #include "cuttlefish/host/libs/config/cuttlefish_config.h"
 #include "cuttlefish/host/libs/config/known_paths.h"
-#include "cuttlefish/host/libs/config/vmm_mode.h"
 #include "cuttlefish/host/libs/feature/command_source.h"
 #include "cuttlefish/host/libs/feature/feature.h"
 #include "cuttlefish/host/libs/feature/kernel_log_pipe_provider.h"
@@ -151,9 +150,8 @@ class StreamerSockets : public virtual SetupFeature {
   // SetupFeature
   std::string Name() const override { return "StreamerSockets"; }
   bool Enabled() const override {
-    bool is_qemu = config_.vm_manager() == VmmMode::kQemu;
     bool is_accelerated = instance_.gpu_mode() != kGpuModeGuestSwiftshader;
-    return !(is_qemu && is_accelerated);
+    return !(VmManagerIsQemu(config_) && is_accelerated);
   }
 
  private:
@@ -270,17 +268,8 @@ class WebRtcServer : public virtual CommandSource,
 
   // SetupFeature
   bool Enabled() const override {
-    if (!sockets_.Enabled()) {
-      return false;
-    }
-    switch (config_.vm_manager()) {
-      case VmmMode::kCrosvm:
-      case VmmMode::kQemu:
-        return true;
-      case VmmMode::kGem5:
-      case VmmMode::kUnknown:
-        return false;
-    }
+    return sockets_.Enabled() &&
+           (VmManagerIsCrosvm(config_) || VmManagerIsQemu(config_));
   }
 
  private: