diff --git a/host/commands/launch/main.cc b/host/commands/launch/main.cc
index 0218698..7c2cf47 100644
--- a/host/commands/launch/main.cc
+++ b/host/commands/launch/main.cc
@@ -74,7 +74,7 @@
 DEFINE_string(blank_data_image_fmt, "ext4",
               "The fs format for the blank data image. Used with mkfs.");
 DEFINE_string(qemu_gdb, "",
-	      "Debug flag to pass to qemu. e.g. --qemu_gdb=tcp::1234");
+              "Debug flag to pass to qemu. e.g. --qemu_gdb=tcp::1234");
 
 DEFINE_int32(x_res, 720, "Width of the screen in pixels");
 DEFINE_int32(y_res, 1280, "Height of the screen in pixels");
@@ -262,9 +262,8 @@
   return true;
 }
 
-std::string GetConfigFile() {
-  return vsoc::CuttlefishConfig::Get()->PerInstancePath(
-      "cuttlefish_config.json");
+std::string GetConfigFilePath(const vsoc::CuttlefishConfig& config) {
+  return config.PerInstancePath("cuttlefish_config.json");
 }
 
 std::string GetGuestPortArg() {
@@ -313,11 +312,11 @@
   return FLAGS_run_adb_connector && AdbTunnelEnabled();
 }
 
-void LaunchUsbServerIfEnabled(vsoc::CuttlefishConfig* config) {
+void LaunchUsbServerIfEnabled(const vsoc::CuttlefishConfig& config) {
   if (!AdbUsbEnabled()) {
     return;
   }
-  auto socket_name = config->usb_v1_socket_name();
+  auto socket_name = config.usb_v1_socket_name();
   auto usb_v1_server = cvd::SharedFD::SocketLocalServer(
       socket_name.c_str(), false, SOCK_STREAM, 0666);
   if (!usb_v1_server->IsOpen()) {
@@ -338,9 +337,9 @@
   close(server_fd);
 }
 
-void LaunchKernelLogMonitor(vsoc::CuttlefishConfig* config,
+void LaunchKernelLogMonitor(const vsoc::CuttlefishConfig& config,
                             cvd::SharedFD boot_events_pipe) {
-  auto log_name = config->kernel_log_socket_name();
+  auto log_name = config.kernel_log_socket_name();
   auto server = cvd::SharedFD::SocketLocalServer(log_name.c_str(), false,
                                                  SOCK_STREAM, 0666);
   int server_fd = server->UNMANAGED_Dup();
@@ -357,7 +356,7 @@
   }
 }
 
-void LaunchIvServer(vsoc::CuttlefishConfig* config) {
+void LaunchIvServer(const vsoc::CuttlefishConfig& config) {
   // Resize gralloc region
   auto actual_width = cvd::AlignToPowerOf2(FLAGS_x_res * 4, 4);  // align to 16
   uint32_t screen_buffers_size =
@@ -369,13 +368,13 @@
   // TODO(b/79170615) Resize gralloc region too.
 
   vsoc::CreateSharedMemoryFile(
-      config->mempath(),
+      config.mempath(),
       {{vsoc::layout::screen::ScreenLayout::region_name, screen_buffers_size}});
 
   auto qemu_channel =
-      CreateIvServerUnixSocket(config->ivshmem_qemu_socket_path());
+      CreateIvServerUnixSocket(config.ivshmem_qemu_socket_path());
   auto client_channel =
-      CreateIvServerUnixSocket(config->ivshmem_client_socket_path());
+      CreateIvServerUnixSocket(config.ivshmem_client_socket_path());
   auto qemu_socket_arg = "-qemu_socket_fd=" + std::to_string(qemu_channel);
   auto client_socket_arg =
       "-client_socket_fd=" + std::to_string(client_channel);
@@ -449,10 +448,10 @@
 }
 
 bool UnpackBootImage(const cvd::BootImageUnpacker& boot_image_unpacker,
-                     vsoc::CuttlefishConfig* config) {
+                     const vsoc::CuttlefishConfig& config) {
   if (boot_image_unpacker.HasRamdiskImage()) {
     if (!boot_image_unpacker.ExtractRamdiskImage(
-            config->ramdisk_image_path())) {
+            config.ramdisk_image_path())) {
       LOG(ERROR) << "Error extracting ramdisk from boot image";
       return false;
     }
@@ -460,7 +459,7 @@
   if (!FLAGS_kernel_path.size()) {
     if (boot_image_unpacker.HasKernelImage()) {
       if (!boot_image_unpacker.ExtractKernelImage(
-              config->kernel_image_path())) {
+              config.kernel_image_path())) {
         LOG(ERROR) << "Error extracting kernel from boot image";
         return false;
       }
@@ -479,44 +478,46 @@
   return os.str();
 }
 
-vsoc::CuttlefishConfig* InitializeCuttlefishConfiguration(
+std::string GetCuttlefishEnvPath() {
+  return cvd::StringFromEnv("HOME", ".") + "/.cuttlefish.sh";
+}
+
+// Initializes the config object and saves it to file. It doesn't return it, all
+// further uses of the config should happen through the singleton
+bool InitializeCuttlefishConfiguration(
     const cvd::BootImageUnpacker& boot_image_unpacker) {
+  vsoc::CuttlefishConfig tmp_config_obj;
   auto& memory_layout = *vsoc::VSoCMemoryLayout::Get();
-  auto config = vsoc::CuttlefishConfig::Get();
-  if (!config) {
-    LOG(ERROR) << "Failed to instantiate config object. Most likely because "
-                  "config file was specified and doesn't exist: '"
-               << getenv(vsoc::kCuttlefishConfigEnvVarName) << "'";
-    return nullptr;
-  }
   // Set this first so that calls to PerInstancePath below are correct
-  config->set_instance_dir(FLAGS_instance_dir);
+  tmp_config_obj.set_instance_dir(FLAGS_instance_dir);
   if (!vm_manager::VmManager::IsValidName(FLAGS_vm_manager)) {
     LOG(ERROR) << "Invalid vm_manager: " << FLAGS_vm_manager;
-    return nullptr;
+    return false;
   }
-  config->set_vm_manager(FLAGS_vm_manager);
+  tmp_config_obj.set_vm_manager(FLAGS_vm_manager);
 
-  config->set_serial_number(FLAGS_serial_number);
+  tmp_config_obj.set_serial_number(FLAGS_serial_number);
 
-  config->set_cpus(FLAGS_cpus);
-  config->set_memory_mb(FLAGS_memory_mb);
+  tmp_config_obj.set_cpus(FLAGS_cpus);
+  tmp_config_obj.set_memory_mb(FLAGS_memory_mb);
 
-  config->set_dpi(FLAGS_dpi);
-  config->set_setupwizard_mode(FLAGS_setupwizard_mode);
-  config->set_x_res(FLAGS_x_res);
-  config->set_y_res(FLAGS_y_res);
-  config->set_refresh_rate_hz(FLAGS_refresh_rate_hz);
-  config->set_gdb_flag(FLAGS_qemu_gdb);
-  config->set_adb_mode(FLAGS_adb_mode);
-  config->set_device_title(FLAGS_device_title);
+  tmp_config_obj.set_dpi(FLAGS_dpi);
+  tmp_config_obj.set_setupwizard_mode(FLAGS_setupwizard_mode);
+  tmp_config_obj.set_x_res(FLAGS_x_res);
+  tmp_config_obj.set_y_res(FLAGS_y_res);
+  tmp_config_obj.set_refresh_rate_hz(FLAGS_refresh_rate_hz);
+  tmp_config_obj.set_gdb_flag(FLAGS_qemu_gdb);
+  tmp_config_obj.set_adb_mode(FLAGS_adb_mode);
+
+  tmp_config_obj.set_device_title(FLAGS_device_title);
   if (FLAGS_kernel_path.size()) {
-    config->set_kernel_image_path(FLAGS_kernel_path);
+    tmp_config_obj.set_kernel_image_path(FLAGS_kernel_path);
   } else {
-    config->set_kernel_image_path(config->PerInstancePath("kernel"));
+    tmp_config_obj.set_kernel_image_path(
+        tmp_config_obj.PerInstancePath("kernel"));
   }
 
-  auto ramdisk_path = config->PerInstancePath("ramdisk.img");
+  auto ramdisk_path = tmp_config_obj.PerInstancePath("ramdisk.img");
   bool use_ramdisk = boot_image_unpacker.HasRamdiskImage();
   if (!use_ramdisk) {
     LOG(INFO) << "No ramdisk present; assuming system-as-root build";
@@ -533,101 +534,114 @@
     }
   }
 
-  config->add_kernel_cmdline(boot_image_unpacker.kernel_cmdline());
+  tmp_config_obj.add_kernel_cmdline(boot_image_unpacker.kernel_cmdline());
   if (!use_ramdisk) {
-    config->add_kernel_cmdline("root=/dev/vda init=/init");
+    tmp_config_obj.add_kernel_cmdline("root=/dev/vda init=/init");
   }
-  config->add_kernel_cmdline(
+  tmp_config_obj.add_kernel_cmdline(
       concat("androidboot.serialno=", FLAGS_serial_number));
-  config->add_kernel_cmdline("mac80211_hwsim.radios=0");
-  config->add_kernel_cmdline(concat("androidboot.lcd_density=", FLAGS_dpi));
-  config->add_kernel_cmdline(concat("androidboot.setupwizard_mode=",
-				    FLAGS_setupwizard_mode));
-  config->add_kernel_cmdline(concat("loop.max_part=", FLAGS_loop_max_part));
+  tmp_config_obj.add_kernel_cmdline("mac80211_hwsim.radios=0");
+  tmp_config_obj.add_kernel_cmdline(concat("androidboot.lcd_density=", FLAGS_dpi));
+  tmp_config_obj.add_kernel_cmdline(
+      concat("androidboot.setupwizard_mode=", FLAGS_setupwizard_mode));
+  tmp_config_obj.add_kernel_cmdline(concat("loop.max_part=", FLAGS_loop_max_part));
   if (!FLAGS_console.empty()) {
-    config->add_kernel_cmdline(concat("console=", FLAGS_console));
+    tmp_config_obj.add_kernel_cmdline(concat("console=", FLAGS_console));
   }
   if (!FLAGS_androidboot_console.empty()) {
-    config->add_kernel_cmdline(
+    tmp_config_obj.add_kernel_cmdline(
         concat("androidboot.console=", FLAGS_androidboot_console));
   }
   if (!FLAGS_hardware_name.empty()) {
-    config->add_kernel_cmdline(
+    tmp_config_obj.add_kernel_cmdline(
         concat("androidboot.hardware=", FLAGS_hardware_name));
   }
   if (!FLAGS_guest_security.empty()) {
-    config->add_kernel_cmdline(concat("security=", FLAGS_guest_security));
+    tmp_config_obj.add_kernel_cmdline(concat("security=", FLAGS_guest_security));
     if (FLAGS_guest_enforce_security) {
-      config->add_kernel_cmdline("enforcing=1");
+      tmp_config_obj.add_kernel_cmdline("enforcing=1");
     } else {
-      config->add_kernel_cmdline("enforcing=0");
-      config->add_kernel_cmdline("androidboot.selinux=permissive");
+      tmp_config_obj.add_kernel_cmdline("enforcing=0");
+      tmp_config_obj.add_kernel_cmdline("androidboot.selinux=permissive");
     }
     if (FLAGS_guest_audit_security) {
-      config->add_kernel_cmdline("audit=1");
+      tmp_config_obj.add_kernel_cmdline("audit=1");
     } else {
-      config->add_kernel_cmdline("audit=0");
+      tmp_config_obj.add_kernel_cmdline("audit=0");
     }
   }
   if (FLAGS_extra_kernel_cmdline.size()) {
-    config->add_kernel_cmdline(FLAGS_extra_kernel_cmdline);
+    tmp_config_obj.add_kernel_cmdline(FLAGS_extra_kernel_cmdline);
   }
 
-  config->set_ramdisk_image_path(ramdisk_path);
-  config->set_system_image_path(FLAGS_system_image);
-  config->set_cache_image_path(FLAGS_cache_image);
-  config->set_data_image_path(FLAGS_data_image);
-  config->set_vendor_image_path(FLAGS_vendor_image);
-  config->set_dtb_path(FLAGS_dtb);
+  tmp_config_obj.set_ramdisk_image_path(ramdisk_path);
+  tmp_config_obj.set_system_image_path(FLAGS_system_image);
+  tmp_config_obj.set_cache_image_path(FLAGS_cache_image);
+  tmp_config_obj.set_data_image_path(FLAGS_data_image);
+  tmp_config_obj.set_vendor_image_path(FLAGS_vendor_image);
+  tmp_config_obj.set_dtb_path(FLAGS_dtb);
 
-  config->set_mempath(FLAGS_mempath);
-  config->set_ivshmem_qemu_socket_path(
-      config->PerInstancePath("ivshmem_socket_qemu"));
-  config->set_ivshmem_client_socket_path(
-      config->PerInstancePath("ivshmem_socket_client"));
-  config->set_ivshmem_vector_count(memory_layout.GetRegions().size());
+  tmp_config_obj.set_mempath(FLAGS_mempath);
+  tmp_config_obj.set_ivshmem_qemu_socket_path(
+      tmp_config_obj.PerInstancePath("ivshmem_socket_qemu"));
+  tmp_config_obj.set_ivshmem_client_socket_path(
+      tmp_config_obj.PerInstancePath("ivshmem_socket_client"));
+  tmp_config_obj.set_ivshmem_vector_count(memory_layout.GetRegions().size());
 
   if (AdbUsbEnabled()) {
-    config->set_usb_v1_socket_name(config->PerInstancePath("usb-v1"));
-    config->set_vhci_port(FLAGS_vhci_port);
-    config->set_usb_ip_socket_name(config->PerInstancePath("usb-ip"));
+    tmp_config_obj.set_usb_v1_socket_name(tmp_config_obj.PerInstancePath("usb-v1"));
+    tmp_config_obj.set_vhci_port(FLAGS_vhci_port);
+    tmp_config_obj.set_usb_ip_socket_name(tmp_config_obj.PerInstancePath("usb-ip"));
   }
 
-  config->set_kernel_log_socket_name(config->PerInstancePath("kernel-log"));
-  config->set_deprecated_boot_completed(FLAGS_deprecated_boot_completed);
-  config->set_console_path(config->PerInstancePath("console"));
-  config->set_logcat_path(config->PerInstancePath("logcat"));
-  config->set_launcher_log_path(config->PerInstancePath("launcher.log"));
-  config->set_launcher_monitor_socket_path(
-      config->PerInstancePath("launcher_monitor.sock"));
+  tmp_config_obj.set_kernel_log_socket_name(tmp_config_obj.PerInstancePath("kernel-log"));
+  tmp_config_obj.set_deprecated_boot_completed(FLAGS_deprecated_boot_completed);
+  tmp_config_obj.set_console_path(tmp_config_obj.PerInstancePath("console"));
+  tmp_config_obj.set_logcat_path(tmp_config_obj.PerInstancePath("logcat"));
+  tmp_config_obj.set_launcher_log_path(tmp_config_obj.PerInstancePath("launcher.log"));
+  tmp_config_obj.set_launcher_monitor_socket_path(
+      tmp_config_obj.PerInstancePath("launcher_monitor.sock"));
 
-  config->set_mobile_bridge_name(FLAGS_mobile_interface);
-  config->set_mobile_tap_name(FLAGS_mobile_tap_name);
+  tmp_config_obj.set_mobile_bridge_name(FLAGS_mobile_interface);
+  tmp_config_obj.set_mobile_tap_name(FLAGS_mobile_tap_name);
 
-  config->set_wifi_bridge_name(FLAGS_wifi_interface);
-  config->set_wifi_tap_name(FLAGS_wifi_tap_name);
+  tmp_config_obj.set_wifi_bridge_name(FLAGS_wifi_interface);
+  tmp_config_obj.set_wifi_tap_name(FLAGS_wifi_tap_name);
 
-  config->set_wifi_guest_mac_addr(FLAGS_guest_mac_address);
-  config->set_wifi_host_mac_addr(FLAGS_host_mac_address);
+  tmp_config_obj.set_wifi_guest_mac_addr(FLAGS_guest_mac_address);
+  tmp_config_obj.set_wifi_host_mac_addr(FLAGS_host_mac_address);
 
-  config->set_entropy_source("/dev/urandom");
-  config->set_uuid(FLAGS_uuid);
+  tmp_config_obj.set_entropy_source("/dev/urandom");
+  tmp_config_obj.set_uuid(FLAGS_uuid);
 
-  config->set_disable_dac_security(FLAGS_disable_dac_security);
-  config->set_disable_app_armor_security(FLAGS_disable_app_armor_security);
+  tmp_config_obj.set_disable_dac_security(FLAGS_disable_dac_security);
+  tmp_config_obj.set_disable_app_armor_security(FLAGS_disable_app_armor_security);
 
-  config->set_qemu_binary(FLAGS_qemu_binary);
-  config->set_hypervisor_uri(FLAGS_hypervisor_uri);
-  config->set_log_xml(FLAGS_log_xml);
+  tmp_config_obj.set_qemu_binary(FLAGS_qemu_binary);
+  tmp_config_obj.set_hypervisor_uri(FLAGS_hypervisor_uri);
+  tmp_config_obj.set_log_xml(FLAGS_log_xml);
 
   if(!AdbUsbEnabled()) {
-    config->disable_usb_adb();
+    tmp_config_obj.disable_usb_adb();
   }
 
-  config->set_cuttlefish_env_path(cvd::StringFromEnv("HOME", ".") +
-                                  "/.cuttlefish.sh");
+  tmp_config_obj.set_cuttlefish_env_path(GetCuttlefishEnvPath());
 
-  return config;
+  auto config_file = GetConfigFilePath(tmp_config_obj);
+  auto config_link = vsoc::GetGlobalConfigFileLink();
+  // Save the config object before starting any host process
+  if (!tmp_config_obj.SaveToFile(config_file)) {
+    LOG(ERROR) << "Unable to save config object";
+    return false;
+  }
+  setenv(vsoc::kCuttlefishConfigEnvVarName, config_file.c_str(), true);
+  if (symlink(config_file.c_str(), config_link.c_str()) != 0) {
+    LOG(ERROR) << "Failed to create symlink to config file at " << config_link
+               << ": " << strerror(errno);
+    return false;
+  }
+
+  return true;
 }
 
 void SetDefaultFlagsForQemu() {
@@ -708,18 +722,49 @@
   return ResolveInstanceFiles();
 }
 
-bool WriteCuttlefishEnvironment(vsoc::CuttlefishConfig* config) {
-  auto env = cvd::SharedFD::Open(config->cuttlefish_env_path().c_str(),
+bool CleanPriorFiles() {
+  // Everything on the instance directory
+  std::string prior_files = FLAGS_instance_dir + "/*";
+  // The shared memory file
+  prior_files += " " + FLAGS_mempath;
+  // The environment file
+  prior_files += " " + GetCuttlefishEnvPath();
+  // The global link to the config file
+  prior_files += " " + vsoc::GetGlobalConfigFileLink();
+  LOG(INFO) << "Assuming prior files of " << prior_files;
+  std::string fuser_cmd = "fuser " + prior_files + " 2> /dev/null";
+  int rval = std::system(fuser_cmd.c_str());
+  // fuser returns 0 if any of the files are open
+  if (WEXITSTATUS(rval) == 0) {
+    LOG(ERROR) << "Clean aborted: files are in use";
+    return false;
+  }
+  std::string clean_command = "rm -rf " + prior_files;
+  if (FLAGS_vm_manager == vm_manager::LibvirtManager::name()) {
+    // Libvirt runs as libvirt-qemu so we need sudo to delete the files it
+    // creates
+    clean_command = "sudo " + clean_command;
+  }
+  rval = std::system(clean_command.c_str());
+  if (WEXITSTATUS(rval) != 0) {
+    LOG(ERROR) << "Remove of files failed";
+    return false;
+  }
+  return true;
+}
+
+bool WriteCuttlefishEnvironment(const vsoc::CuttlefishConfig& config) {
+  auto env = cvd::SharedFD::Open(config.cuttlefish_env_path().c_str(),
                                  O_CREAT | O_RDWR, 0755);
   if (!env->IsOpen()) {
     LOG(ERROR) << "Unable to create cuttlefish.env file";
     return false;
   }
   std::string config_env = "export CUTTLEFISH_PER_INSTANCE_PATH=\"" +
-                           config->PerInstancePath(".") + "\"\n";
+                           config.PerInstancePath(".") + "\"\n";
   config_env += "export ANDROID_SERIAL=";
   if (AdbUsbEnabled()) {
-    config_env += config->serial_number();
+    config_env += config.serial_number();
   } else {
     config_env += "127.0.0.1:" + std::to_string(GetHostPort());
   }
@@ -730,7 +775,7 @@
 
 // Forks and returns the write end of a pipe to the child process. The parent
 // process waits for boot events to come through the pipe and exits accordingly.
-cvd::SharedFD DaemonizeLauncher(vsoc::CuttlefishConfig* config) {
+cvd::SharedFD DaemonizeLauncher(const vsoc::CuttlefishConfig& config) {
   cvd::SharedFD read_end, write_end;
   if (!cvd::SharedFD::Pipe(&read_end, &write_end)) {
     LOG(ERROR) << "Unable to create pipe";
@@ -766,7 +811,7 @@
       std::exit(LauncherExitCodes::kDaemonizationError);
     }
     // Redirect standard I/O
-    auto log_path = config->launcher_log_path();
+    auto log_path = config.launcher_log_path();
     auto log =
         cvd::SharedFD::Open(log_path.c_str(), O_CREAT | O_WRONLY | O_TRUNC,
                             S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
@@ -862,13 +907,35 @@
 int main(int argc, char** argv) {
   ::android::base::InitLogging(argv, android::base::StderrLogger);
   if (!ParseCommandLineFlags(&argc, &argv)) {
+    LOG(ERROR) << "Failed to parse command arguments";
     return LauncherExitCodes::kArgumentParsingError;
   }
 
+  // Clean up prior files before saving the config file (doing it after would
+  // delete it)
+  if (!CleanPriorFiles()) {
+    LOG(ERROR) << "Failed to clean prior files";
+    return LauncherExitCodes::kPrioFilesCleanupError;
+  }
+  // For now it has to be the vm manager who ensures the instance dir exists
+  // because in the case of the libvirt manager root privileges are required to
+  // create and set acls on the directory
+  if (!vm_manager::VmManager::EnsureInstanceDirExists(FLAGS_vm_manager,
+                                                      FLAGS_instance_dir)) {
+    LOG(ERROR) << "Failed to create instance directory";
+    return LauncherExitCodes::kInstanceDirCreationError;
+  }
+
   auto boot_img_unpacker = cvd::BootImageUnpacker::FromImage(FLAGS_boot_image);
+
+  if (!InitializeCuttlefishConfiguration(*boot_img_unpacker)) {
+    LOG(ERROR) << "Failed to initialize configuration";
+    return LauncherExitCodes::kCuttlefishConfigurationInitError;
+  }
   // Do this early so that the config object is ready for anything that needs it
-  auto config = InitializeCuttlefishConfiguration(*boot_img_unpacker);
+  auto config = vsoc::CuttlefishConfig::Get();
   if (!config) {
+    LOG(ERROR) << "Failed to obtain config singleton";
     return LauncherExitCodes::kCuttlefishConfigurationInitError;
   }
 
@@ -887,45 +954,28 @@
     return LauncherExitCodes::kInvalidHostConfiguration;
   }
 
-  if (!vm_manager->EnsureInstanceDirExists()) {
+  if (!vm_manager->EnsureInstanceDirExists(FLAGS_vm_manager,
+                                           FLAGS_instance_dir)) {
     LOG(ERROR) << "Failed to create instance directory: " << FLAGS_instance_dir;
     return LauncherExitCodes::kInstanceDirCreationError;
   }
 
-  if (!vm_manager->CleanPriorFiles()) {
-    LOG(ERROR) << "Failed to clean prior files";
-    return LauncherExitCodes::kPrioFilesCleanupError;
-  }
-
-  if (!UnpackBootImage(*boot_img_unpacker, config)) {
+  if (!UnpackBootImage(*boot_img_unpacker, *config)) {
     LOG(ERROR) << "Failed to unpack boot image";
     return LauncherExitCodes::kBootImageUnpackError;
   }
 
-  if (!WriteCuttlefishEnvironment(config)) {
+  if (!WriteCuttlefishEnvironment(*config)) {
     LOG(ERROR) << "Unable to write cuttlefish environment file";
   }
 
-  auto config_file = GetConfigFile();
-  auto config_link = vsoc::GetGlobalConfigFileLink();
-  // Save the config object before starting any host process
-  if (!config->SaveToFile(config_file)) {
-    return LauncherExitCodes::kCuttlefishConfigurationSaveError;
-  }
-  setenv(vsoc::kCuttlefishConfigEnvVarName, config_file.c_str(), true);
-  if (symlink(config_file.c_str(), config_link.c_str()) != 0) {
-    LOG(ERROR) << "Failed to create symlink to config file at " << config_link
-               << ": " << strerror(errno);
-    return LauncherExitCodes::kCuttlefishConfigurationSaveError;
-  }
-
   LOG(INFO) << "The following files contain useful debugging information:";
   if (FLAGS_daemon) {
     LOG(INFO) << "  Launcher log: " << config->launcher_log_path();
   }
   LOG(INFO) << "  Android's logcat output: " << config->logcat_path();
   LOG(INFO) << "  Kernel log: " << config->PerInstancePath("kernel.log");
-  LOG(INFO) << "  Instance configuration: " << GetConfigFile();
+  LOG(INFO) << "  Instance configuration: " << GetConfigFilePath(*config);
   LOG(INFO) << "  Instance environment: " << config->cuttlefish_env_path();
   LOG(INFO) << "To access the console run: socat file:$(tty),raw,echo=0 "
             << config->console_path();
@@ -940,7 +990,7 @@
   }
   cvd::SharedFD boot_events_pipe;
   if (FLAGS_daemon) {
-    boot_events_pipe = DaemonizeLauncher(config);
+    boot_events_pipe = DaemonizeLauncher(*config);
     if (!boot_events_pipe->IsOpen()) {
       return LauncherExitCodes::kDaemonizationError;
     }
@@ -956,12 +1006,12 @@
     }
   }
 
-  LaunchKernelLogMonitor(config, boot_events_pipe);
-  LaunchUsbServerIfEnabled(config);
-  LaunchIvServer(config);
+  LaunchKernelLogMonitor(*config, boot_events_pipe);
+  LaunchUsbServerIfEnabled(*config);
+  LaunchIvServer(*config);
 
   // Initialize the regions that require so before the VM starts.
-  PreLaunchInitializers::Initialize(config);
+  PreLaunchInitializers::Initialize(*config);
 
   // Start the guest VM
   if (!vm_manager->Start()) {
diff --git a/host/commands/launch/pre_launch_initializers.h b/host/commands/launch/pre_launch_initializers.h
index 91e97aa..925cdf8 100644
--- a/host/commands/launch/pre_launch_initializers.h
+++ b/host/commands/launch/pre_launch_initializers.h
@@ -24,13 +24,13 @@
 // machine is started.
 // To add initializers for more regions declare here, implement in its own
 // source file and call from PreLaunchInitializers::Initialize().
-void InitializeScreenRegion(vsoc::CuttlefishConfig* config);
-void InitializeRilRegion(vsoc::CuttlefishConfig* config);
-void InitializeWifiRegion(vsoc::CuttlefishConfig* config);
+void InitializeScreenRegion(const vsoc::CuttlefishConfig& config);
+void InitializeRilRegion(const vsoc::CuttlefishConfig& config);
+void InitializeWifiRegion(const vsoc::CuttlefishConfig& config);
 
 class PreLaunchInitializers {
  public:
-  static void Initialize(vsoc::CuttlefishConfig* config) {
+  static void Initialize(const vsoc::CuttlefishConfig& config) {
     InitializeScreenRegion(config);
     InitializeRilRegion(config);
     InitializeWifiRegion(config);
diff --git a/host/commands/launch/ril_region_handler.cc b/host/commands/launch/ril_region_handler.cc
index 224cecd..b3bb00a 100644
--- a/host/commands/launch/ril_region_handler.cc
+++ b/host/commands/launch/ril_region_handler.cc
@@ -121,9 +121,9 @@
 };
 }  // namespace
 
-void InitializeRilRegion(vsoc::CuttlefishConfig* config) {
+void InitializeRilRegion(const vsoc::CuttlefishConfig& config) {
   NetConfig netconfig;
-  if (!netconfig.ObtainConfig(config->mobile_bridge_name())) {
+  if (!netconfig.ObtainConfig(config.mobile_bridge_name())) {
     LOG(ERROR) << "Unable to obtain the network configuration";
     return;
   }
diff --git a/host/commands/launch/screen_region_handler.cc b/host/commands/launch/screen_region_handler.cc
index a4bc600..732f60b 100644
--- a/host/commands/launch/screen_region_handler.cc
+++ b/host/commands/launch/screen_region_handler.cc
@@ -20,7 +20,7 @@
 #include "host/commands/launch/pre_launch_initializers.h"
 #include "host/libs/config/cuttlefish_config.h"
 
-void InitializeScreenRegion(vsoc::CuttlefishConfig* config) {
+void InitializeScreenRegion(const vsoc::CuttlefishConfig& config) {
   auto region =
       vsoc::screen::ScreenRegionView::GetInstance(vsoc::GetDomain().c_str());
   if (!region) {
@@ -28,8 +28,8 @@
     return;
   }
   auto dest = region->data();
-  dest->x_res = config->x_res();
-  dest->y_res = config->y_res();
-  dest->dpi = config->dpi();
-  dest->refresh_rate_hz = config->refresh_rate_hz();
+  dest->x_res = config.x_res();
+  dest->y_res = config.y_res();
+  dest->dpi = config.dpi();
+  dest->refresh_rate_hz = config.refresh_rate_hz();
 }
diff --git a/host/commands/launch/wifi_region_handler.cc b/host/commands/launch/wifi_region_handler.cc
index 6b68a23..5c001b7 100644
--- a/host/commands/launch/wifi_region_handler.cc
+++ b/host/commands/launch/wifi_region_handler.cc
@@ -24,27 +24,27 @@
 
 using vsoc::wifi::WifiExchangeView;
 
-void InitializeWifiRegion(vsoc::CuttlefishConfig* config) {
+void InitializeWifiRegion(const vsoc::CuttlefishConfig& config) {
   auto region = WifiExchangeView::GetInstance(vsoc::GetDomain().c_str());
   if (!region) {
     LOG(FATAL) << "Wifi region not found";
     return;
   }
   WifiExchangeView::MacAddress guest_mac, host_mac;
-  if (!WifiExchangeView::ParseMACAddress(config->wifi_guest_mac_addr(),
+  if (!WifiExchangeView::ParseMACAddress(config.wifi_guest_mac_addr(),
                                          &guest_mac)) {
     LOG(FATAL) << "Unable to parse guest mac address: "
-               << config->wifi_guest_mac_addr();
+               << config.wifi_guest_mac_addr();
     return;
   }
-  LOG(INFO) << "Setting guest mac to " << config->wifi_guest_mac_addr();
+  LOG(INFO) << "Setting guest mac to " << config.wifi_guest_mac_addr();
   region->SetGuestMACAddress(guest_mac);
-  if (!WifiExchangeView::ParseMACAddress(config->wifi_host_mac_addr(),
+  if (!WifiExchangeView::ParseMACAddress(config.wifi_host_mac_addr(),
                                          &host_mac)) {
     LOG(FATAL) << "Unable to parse guest mac address: "
-               << config->wifi_guest_mac_addr();
+               << config.wifi_guest_mac_addr();
     return;
   }
-  LOG(INFO) << "Setting host mac to " << config->wifi_host_mac_addr();
+  LOG(INFO) << "Setting host mac to " << config.wifi_host_mac_addr();
   region->SetHostMACAddress(host_mac);
 }
diff --git a/host/libs/config/cuttlefish_config.cpp b/host/libs/config/cuttlefish_config.cpp
index 7adaa70..b39e728 100644
--- a/host/libs/config/cuttlefish_config.cpp
+++ b/host/libs/config/cuttlefish_config.cpp
@@ -515,10 +515,11 @@
 // the config file if the CUTTLEFISH_CONFIG_FILE env variable is present.
 // Returns nullptr if there was an error loading from file
 /*static*/ CuttlefishConfig* CuttlefishConfig::BuildConfigImpl() {
+  auto config_file_path = cvd::StringFromEnv(kCuttlefishConfigEnvVarName,
+                                             vsoc::GetGlobalConfigFileLink());
   auto ret = new CuttlefishConfig();
-  char* config_file_cstr = getenv(kCuttlefishConfigEnvVarName);
-  if (ret && config_file_cstr && strlen(config_file_cstr) > 0) {
-    auto loaded = ret->LoadFromFile(config_file_cstr);
+  if (ret) {
+    auto loaded = ret->LoadFromFile(config_file_path.c_str());
     if (!loaded) {
       delete ret;
       return nullptr;
diff --git a/host/libs/vm_manager/libvirt_manager.cpp b/host/libs/vm_manager/libvirt_manager.cpp
index 9c67391..24ff33b 100644
--- a/host/libs/vm_manager/libvirt_manager.cpp
+++ b/host/libs/vm_manager/libvirt_manager.cpp
@@ -257,7 +257,7 @@
   xmlNewProp(bend, xc("model"), xc("random"));
 }
 
-static std::string GetLibvirtCommand(vsoc::CuttlefishConfig* config) {
+static std::string GetLibvirtCommand(const vsoc::CuttlefishConfig* config) {
   std::string cmd = "virsh";
   if (!config->hypervisor_uri().empty()) {
     cmd += " -c " + config->hypervisor_uri();
@@ -265,7 +265,7 @@
   return cmd;
 }
 
-std::string BuildXmlConfig(vsoc::CuttlefishConfig* config) {
+std::string BuildXmlConfig(const vsoc::CuttlefishConfig* config) {
   std::string instance_name = config->instance_name();
 
   std::unique_ptr<xmlDoc, void (*)(xmlDocPtr)> xml{xmlNewDoc(xc("1.0")),
@@ -341,7 +341,7 @@
 
 const std::string LibvirtManager::name() { return "libvirt"; }
 
-LibvirtManager::LibvirtManager(vsoc::CuttlefishConfig* config)
+LibvirtManager::LibvirtManager(const vsoc::CuttlefishConfig* config)
   : VmManager(config) {}
 
 bool LibvirtManager::Start() {
@@ -377,8 +377,7 @@
   return std::system(stop_command.c_str()) == 0;
 }
 
-bool LibvirtManager::EnsureInstanceDirExists() const {
-  auto instance_dir = config_->instance_dir();
+bool LibvirtManager::EnsureInstanceDirExists(const std::string& instance_dir) {
   if (!cvd::DirectoryExists(instance_dir)) {
     LOG(INFO) << "Setting up " << instance_dir;
     cvd::execute({"/usr/bin/sudo", "/bin/mkdir", "-m", "0775", instance_dir});
@@ -391,28 +390,6 @@
   return true;
 }
 
-bool LibvirtManager::CleanPriorFiles() const {
-  std::string run_files = config_->PerInstancePath("*") + " " +
-                          config_->mempath() + " " +
-                          config_->cuttlefish_env_path() + " " +
-                          vsoc::GetGlobalConfigFileLink();
-  LOG(INFO) << "Assuming run files of " << run_files;
-  std::string fuser_cmd = "fuser " + run_files + " 2> /dev/null";
-  int rval = std::system(fuser_cmd.c_str());
-  // fuser returns 0 if any of the files are open
-  if (WEXITSTATUS(rval) == 0) {
-    LOG(ERROR) << "Clean aborted: files are in use";
-    return false;
-  }
-  std::string clean_command = "rm -rf " + run_files;
-  rval = std::system(clean_command.c_str());
-  if (WEXITSTATUS(rval) != 0) {
-    LOG(ERROR) << "Remove of files failed";
-    return false;
-  }
-  return true;
-}
-
 bool LibvirtManager::ValidateHostConfiguration(
     std::vector<std::string>* config_commands) const {
   return VmManager::UserInGroup("libvirt", config_commands);
diff --git a/host/libs/vm_manager/libvirt_manager.h b/host/libs/vm_manager/libvirt_manager.h
index d582827..6bb99d1 100644
--- a/host/libs/vm_manager/libvirt_manager.h
+++ b/host/libs/vm_manager/libvirt_manager.h
@@ -24,15 +24,14 @@
 class LibvirtManager : public VmManager {
  public:
   static const std::string name();
-  LibvirtManager(vsoc::CuttlefishConfig* config);
+  static bool EnsureInstanceDirExists(const std::string& instance_dir);
+
+  LibvirtManager(const vsoc::CuttlefishConfig* config);
   virtual ~LibvirtManager() = default;
 
   bool Start() override;
   bool Stop() override;
 
-  bool EnsureInstanceDirExists() const override;
-  bool CleanPriorFiles() const override;
-
   bool ValidateHostConfiguration(
       std::vector<std::string>* config_commands) const override;
 };
diff --git a/host/libs/vm_manager/qemu_manager.cpp b/host/libs/vm_manager/qemu_manager.cpp
index afd5848..ce7e842 100644
--- a/host/libs/vm_manager/qemu_manager.cpp
+++ b/host/libs/vm_manager/qemu_manager.cpp
@@ -42,7 +42,7 @@
 
 namespace {
 
-std::string GetMonitorPath(vsoc::CuttlefishConfig* config) {
+std::string GetMonitorPath(const vsoc::CuttlefishConfig* config) {
   return config->PerInstancePath("qemu_monitor.sock");
 }
 
@@ -51,7 +51,7 @@
   LOG(INFO) << key << "=" << value;
 }
 
-pid_t BuildAndRunQemuCmd(vsoc::CuttlefishConfig* config) {
+pid_t BuildAndRunQemuCmd(const vsoc::CuttlefishConfig* config) {
   // Set the config values in the environment
   LogAndSetEnv("qemu_binary", config->qemu_binary());
   LogAndSetEnv("instance_name", config->instance_name());
@@ -86,7 +86,7 @@
 
 const std::string QemuManager::name() { return "qemu_cli"; }
 
-QemuManager::QemuManager(vsoc::CuttlefishConfig* config)
+QemuManager::QemuManager(const vsoc::CuttlefishConfig* config)
   : VmManager(config) {}
 
 bool QemuManager::Start() {
@@ -141,8 +141,7 @@
   return true;
 }
 
-bool QemuManager::EnsureInstanceDirExists() const {
-  auto instance_dir = config_->instance_dir();
+bool QemuManager::EnsureInstanceDirExists(const std::string& instance_dir) {
   if (!cvd::DirectoryExists(instance_dir.c_str())) {
     LOG(INFO) << "Setting up " << instance_dir;
     if (mkdir(instance_dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) < 0) {
@@ -153,27 +152,6 @@
   return true;
 
 }
-bool QemuManager::CleanPriorFiles() const {
-  std::string run_files = config_->PerInstancePath("*") + " " +
-                          config_->mempath() + " " +
-                          config_->cuttlefish_env_path() + " " +
-                          vsoc::GetGlobalConfigFileLink();
-  LOG(INFO) << "Assuming run files of " << run_files;
-  std::string fuser_cmd = "fuser " + run_files + " 2> /dev/null";
-  int rval = std::system(fuser_cmd.c_str());
-  // fuser returns 0 if any of the files are open
-  if (WEXITSTATUS(rval) == 0) {
-    LOG(ERROR) << "Clean aborted: files are in use";
-    return false;
-  }
-  std::string clean_command = "rm -rf " + run_files;
-  rval = std::system(clean_command.c_str());
-  if (WEXITSTATUS(rval) != 0) {
-    LOG(ERROR) << "Remove of files failed";
-    return false;
-  }
-  return true;
-}
 
 bool QemuManager::ValidateHostConfiguration(
     std::vector<std::string>* config_commands) const {
diff --git a/host/libs/vm_manager/qemu_manager.h b/host/libs/vm_manager/qemu_manager.h
index 7c053e7..6ae1926 100644
--- a/host/libs/vm_manager/qemu_manager.h
+++ b/host/libs/vm_manager/qemu_manager.h
@@ -26,15 +26,14 @@
 class QemuManager : public VmManager {
  public:
   static const std::string name();
-  QemuManager(vsoc::CuttlefishConfig* config);
+  static bool EnsureInstanceDirExists(const std::string& instance_dir);
+
+  QemuManager(const vsoc::CuttlefishConfig* config);
   virtual ~QemuManager() = default;
 
   bool Start() override;
   bool Stop() override;
 
-  bool EnsureInstanceDirExists() const override;
-  bool CleanPriorFiles() const override;
-
   bool ValidateHostConfiguration(
       std::vector<std::string>* config_commands) const override;
  private:
diff --git a/host/libs/vm_manager/vm_manager.cpp b/host/libs/vm_manager/vm_manager.cpp
index 5d14711..b452bf9 100644
--- a/host/libs/vm_manager/vm_manager.cpp
+++ b/host/libs/vm_manager/vm_manager.cpp
@@ -27,12 +27,12 @@
 
 namespace vm_manager {
 
-VmManager::VmManager(vsoc::CuttlefishConfig* config)
+VmManager::VmManager(const vsoc::CuttlefishConfig* config)
     : config_(config) {}
 
 namespace{
 template <typename T>
-VmManager* GetManagerSingleton(vsoc::CuttlefishConfig* config) {
+VmManager* GetManagerSingleton(const vsoc::CuttlefishConfig* config) {
   static std::shared_ptr<VmManager> vm_manager(new T(config));
   return vm_manager.get();
 }
@@ -41,20 +41,26 @@
 std::map<std::string, VmManager::VmManagerHelper>
     VmManager::vm_manager_helpers_ = {
         {LibvirtManager::name(),
-         {[](vsoc::CuttlefishConfig* config) {
+         {[](const vsoc::CuttlefishConfig* config) {
             return GetManagerSingleton<LibvirtManager>(config);
           },
-          []() { return true; }}},
+          []() { return true; },
+          [](const std::string& dir_path) {
+            return LibvirtManager::EnsureInstanceDirExists(dir_path);
+          }}},
         {QemuManager::name(),
-         {[](vsoc::CuttlefishConfig* config) {
+         {[](const vsoc::CuttlefishConfig* config) {
             return GetManagerSingleton<QemuManager>(config);
           },
-          []() { return vsoc::HostSupportsQemuCli(); }}}};
+          []() { return vsoc::HostSupportsQemuCli(); },
+          [](const std::string& dir_path) {
+            return QemuManager::EnsureInstanceDirExists(dir_path);
+          }}}};
 
 VmManager* VmManager::Get(const std::string& vm_manager_name,
-                          vsoc::CuttlefishConfig* config) {
+                          const vsoc::CuttlefishConfig* config) {
   if (VmManager::IsValidName(vm_manager_name)) {
-    return vm_manager_helpers_[vm_manager_name].first(config);
+    return vm_manager_helpers_[vm_manager_name].builder(config);
   }
   LOG(ERROR) << "Requested invalid VmManager: " << vm_manager_name;
   return nullptr;
@@ -66,7 +72,7 @@
 
 bool VmManager::IsVmManagerSupported(const std::string& name) {
   return VmManager::IsValidName(name) &&
-         vm_manager_helpers_[name].second();
+         vm_manager_helpers_[name].support_checker();
 }
 
 std::vector<std::string> VmManager::GetValidNames() {
@@ -87,4 +93,10 @@
   }
   return true;
 }
+
+bool VmManager::EnsureInstanceDirExists(const std::string& vm_manager_name,
+                                        const std::string& instance_dir_path) {
+  return vm_manager_helpers_[vm_manager_name].instance_dir_creator(
+      instance_dir_path);
+}
 }  // namespace vm_manager
diff --git a/host/libs/vm_manager/vm_manager.h b/host/libs/vm_manager/vm_manager.h
index d4f7036..98dd1d3 100644
--- a/host/libs/vm_manager/vm_manager.h
+++ b/host/libs/vm_manager/vm_manager.h
@@ -32,36 +32,38 @@
   // if the requested vm manager is not supported by the current version of the
   // host packages
   static VmManager* Get(const std::string& vm_manager_name,
-                        vsoc::CuttlefishConfig* config);
+                        const vsoc::CuttlefishConfig* config);
   static bool IsValidName(const std::string& name);
   static bool IsVmManagerSupported(const std::string& name);
   static std::vector<std::string> GetValidNames();
+  static bool EnsureInstanceDirExists(const std::string& vm_manager_name,
+                                      const std::string& instance_dir_path);
 
   virtual ~VmManager() = default;
 
   virtual bool Start() = 0;
   virtual bool Stop() = 0;
 
-  virtual bool EnsureInstanceDirExists() const = 0;
-  virtual bool CleanPriorFiles() const = 0;
-
   virtual bool ValidateHostConfiguration(
       std::vector<std::string>* config_commands) const = 0;
 
  protected:
   static bool UserInGroup(const std::string& group,
                           std::vector<std::string>* config_commands);
-  vsoc::CuttlefishConfig* config_;
-  VmManager(vsoc::CuttlefishConfig* config);
+  const vsoc::CuttlefishConfig* config_;
+  VmManager(const vsoc::CuttlefishConfig* config);
 
 private:
-  // Holds a map of manager names to a pair of functions. The first function
-  // implements a singleton for the specified manager and the second one
-  // specifies whether the host packages support it.
- using Builder = std::function<VmManager*(vsoc::CuttlefishConfig*)>;
- using SupportChecker = std::function<bool()>;
- using VmManagerHelper = std::pair<Builder, SupportChecker>;
- static std::map<std::string, VmManagerHelper> vm_manager_helpers_;
+  struct VmManagerHelper {
+    // The singleton implementation
+    std::function<VmManager*(const vsoc::CuttlefishConfig*)> builder;
+    // Whether the host packages support this vm manager
+    std::function<bool()> support_checker;
+    // Creates the instance directory if it doesn't exist
+    std::function<bool(const std::string&)> instance_dir_creator;
+  };
+  // Asociates a vm manager helper to every valid vm manager name
+  static std::map<std::string, VmManagerHelper> vm_manager_helpers_;
 };
 
 }  // namespace vm_manager