Fix Cuttlefish multi-instance restart deadlocks, socket hangs, and UWB/bootconfig configuration mismatches

Author: SuperStrongDinosaur

base/cvd/cuttlefish/common/libs/fs/shared_fd.cpp

@@ -518,14 +518,15 @@ int SharedFD::Fchdir(SharedFD shared_fd) {
 
 Result<SharedFD> SharedFD::Fifo(const std::string& path, mode_t mode) {
   struct stat st {};
-  if (TEMP_FAILURE_RETRY(stat(path.c_str(), &st)) == 0) {
-    CF_EXPECTF(TEMP_FAILURE_RETRY(remove(path.c_str())) == 0,
-               "Failed to delete old file at '{}': '{}'", path,
+  if (TEMP_FAILURE_RETRY(stat(path.c_str(), &st)) != 0) {
+    CF_EXPECTF(TEMP_FAILURE_RETRY(mkfifo(path.c_str(), mode)) == 0,
+               "Failed to mkfifo('{}', {:o}): {}", path, mode,
                ::cuttlefish::StrError(errno));
+  } else {
+    CF_EXPECTF(S_ISFIFO(st.st_mode),
+               "File at '{}' exists but is not a FIFO", path);
   }
 
-  CF_EXPECTF(TEMP_FAILURE_RETRY(mkfifo(path.c_str(), mode)) == 0,
-             "Failed to mkfifo('{}', {:o})", path, mode);
   auto ret = Open(path, O_RDWR);
   CF_EXPECTF(ret->IsOpen(), "Failed to open '{}': '{}'", path, ret->StrError());
   return ret;

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

@@ -39,7 +39,7 @@ namespace cuttlefish {
 Result<std::optional<MonitorCommand>> UwbConnector(
     const CuttlefishConfig& config,
     const CuttlefishConfig::InstanceSpecific& instance) {
-  if (!instance.enable_host_uwb_connector()) {
+  if (!config.enable_host_uwb()) {
     return {};
   }
   std::vector<std::string> fifo_paths = {
@@ -50,6 +50,9 @@ Result<std::optional<MonitorCommand>> UwbConnector(
   for (const auto& path : fifo_paths) {
     fifos.push_back(CF_EXPECT(SharedFD::Fifo(path, 0660)));
   }
+  if (!instance.enable_host_uwb_connector()) {
+    return {};
+  }
   return Command(HostBinaryPath("tcp_connector"))
       .AddParameter("-fifo_out=", fifos[0])
       .AddParameter("-fifo_in=", fifos[1])

base/cvd/cuttlefish/host/commands/run_cvd/server_loop_impl.cpp

@@ -337,12 +337,6 @@ void ServerLoopImpl::DeleteFifos() {
       instance_.PerInstanceInternalPath("gatekeeper_fifo_vm.out"),
       instance_.PerInstanceInternalPath("oemlock_fifo_vm.in"),
       instance_.PerInstanceInternalPath("oemlock_fifo_vm.out"),
-      instance_.PerInstanceInternalPath("bt_fifo_vm.in"),
-      instance_.PerInstanceInternalPath("bt_fifo_vm.out"),
-      instance_.PerInstanceInternalPath("nfc_fifo_vm.in"),
-      instance_.PerInstanceInternalPath("nfc_fifo_vm.out"),
-      instance_.PerInstanceInternalPath("uwb_fifo_vm.in"),
-      instance_.PerInstanceInternalPath("uwb_fifo_vm.out"),
       instance_.PerInstanceInternalPath("gnsshvc_fifo_vm.in"),
       instance_.PerInstanceInternalPath("gnsshvc_fifo_vm.out"),
       instance_.PerInstanceInternalPath("locationhvc_fifo_vm.in"),

base/cvd/cuttlefish/host/libs/process_monitor/process_monitor.cc

@@ -278,7 +278,15 @@ Result<void> ProcessMonitor::StartSubprocesses(
 Result<void> ProcessMonitor::ReadMonitorSocketLoop(std::atomic_bool& running) {
   VLOG(0) << "Waiting for a `stop` message from the parent";
   while (running.load()) {
-    ManagedMessage message = CF_EXPECT(child_channel_->ReceiveMessage());
+    auto message_res = child_channel_->ReceiveMessage();
+    if (!message_res.ok()) {
+      if (!running.load()) {
+        // We were shut down intentionally, ignore error
+        return {};
+      }
+      CF_EXPECT(std::move(message_res));
+    }
+    auto message = std::move(*message_res);
     if (message->command == ParentToChildMessageType::kStop) {
       running.store(false);
       // Wake up the wait() loop by giving it an exited child process
@@ -406,6 +414,7 @@ Result<void> ProcessMonitor::StartAndMonitorProcesses() {
   if (monitor_ == 0) {
     pipe_read->Close();
     child_channel_ = transport::SharedFdChannel(child_sock, child_sock);
+    child_sock_ = std::move(child_sock);
     Result<void> monitor_result = MonitorRoutine();
     if (!monitor_result.ok()) {
       LOG(ERROR) << "Monitoring processes failed:\n" << monitor_result.error();
@@ -444,6 +453,9 @@ Result<void> ProcessMonitor::MonitorRoutine() {
   CF_EXPECT(MonitorLoop(running, properties_mutex_,
                         properties_.restart_subprocesses_,
                         properties_.entries_));
+  if (child_sock_->IsOpen()) {
+    child_sock_->Shutdown(SHUT_RDWR);
+  }
   CF_EXPECT(parent_comms.get(), "Should have exited if monitoring stopped");
 
   CF_EXPECT(StopSubprocesses(properties_.entries_));

base/cvd/cuttlefish/host/libs/process_monitor/process_monitor.h

@@ -94,6 +94,7 @@ class ProcessMonitor {
   pid_t monitor_;
   std::optional<transport::SharedFdChannel> parent_channel_;
   std::optional<transport::SharedFdChannel> child_channel_;
+  SharedFD child_sock_;
 
   /*
    * The lock that should be acquired when multiple threads