Migrate SharedFD::[VsockServer,GetVhostUserVsock[Client,Server]Addr]

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

@@ -264,33 +264,12 @@ SharedFD SharedFD::SocketLocalServer(const std::string& name, bool abstract,
 }
 
 #ifdef __linux__
-SharedFD SharedFD::VsockServer(
-    unsigned int port, int type,
-    std::optional<int> vhost_user_vsock_listening_cid, unsigned int cid) {
-  return Fd::VsockServer(port, type, vhost_user_vsock_listening_cid, cid)
-      .value_or(Fd());
-}
-
-SharedFD SharedFD::VsockServer(
-    int type, std::optional<int> vhost_user_vsock_listening_cid) {
-  return VsockServer(VMADDR_PORT_ANY, type, vhost_user_vsock_listening_cid);
-}
-
-std::string SharedFD::GetVhostUserVsockServerAddr(
-    unsigned int port, int vhost_user_vsock_listening_cid) {
-  return Fd::GetVhostUserVsockServerAddr(port, vhost_user_vsock_listening_cid);
-}
-
-std::string SharedFD::GetVhostUserVsockClientAddr(int cid) {
-  return Fd::GetVhostUserVsockClientAddr(cid);
-}
-
 SharedFD SharedFD::VsockClient(unsigned int cid, unsigned int port, int type,
                                bool vhost_user) {
   if (vhost_user) {
     // TODO(b/277909042): better path than /tmp/vsock_{}/vm.vsock
-    auto client = SharedFD::SocketLocalClient(GetVhostUserVsockClientAddr(cid),
-                                              false /* abstract */, type);
+    auto client = SharedFD::SocketLocalClient(
+        Fd::GetVhostUserVsockClientAddr(cid), false /* abstract */, type);
     const std::string msg = fmt::format("connect {}\n", port);
     SendAll(client, msg);
 

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

@@ -186,16 +186,8 @@ class SharedFD {
   // necessary.
   // TODO: combining them when vhost-user-vsock impl supports a kind of
   // VMADDR_CID_HOST
-  static SharedFD VsockServer(unsigned int port, int type,
-                              std::optional<int> vhost_user_vsock_listening_cid,
-                              unsigned int cid = VMADDR_CID_ANY);
-  static SharedFD VsockServer(
-      int type, std::optional<int> vhost_user_vsock_listening_cid);
   static SharedFD VsockClient(unsigned int cid, unsigned int port, int type,
                               bool vhost_user);
-  static std::string GetVhostUserVsockServerAddr(
-      unsigned int port, int vhost_user_vsock_listening_cid);
-  static std::string GetVhostUserVsockClientAddr(int cid);
 #endif
 
   auto operator<=>(const SharedFD&) const = default;

base/cvd/cuttlefish/common/libs/utils/vsock_connection.cpp

@@ -240,8 +240,8 @@ void VsockServerConnection::ServerShutdown() {
 bool VsockServerConnection::Connect(unsigned int port, unsigned int cid,
                                     std::optional<int> vhost_user_vsock_cid) {
   if (!server_fd_->IsOpen()) {
-    server_fd_ = cuttlefish::SharedFD::VsockServer(port, SOCK_STREAM,
-                                                   vhost_user_vsock_cid, cid);
+    server_fd_ = Fd::VsockServer(port, SOCK_STREAM, vhost_user_vsock_cid, cid)
+                     .value_or(Fd());
   }
   if (server_fd_->IsOpen()) {
     fd_ = Fd::Accept(*server_fd_).value_or(Fd());

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

@@ -269,6 +269,7 @@ cf_cc_library(
     hdrs = ["modem.h"],
     deps = [
         "//cuttlefish/common/libs/fs",
+        "//cuttlefish/common/libs/fs:fd",
         "//cuttlefish/host/libs/config:cuttlefish_config",
         "//cuttlefish/host/libs/config:known_paths",
         "//cuttlefish/host/libs/feature",
@@ -285,6 +286,7 @@ cf_cc_library(
     hdrs = ["netsim_server.h"],
     deps = [
         "//cuttlefish/common/libs/fs",
+        "//cuttlefish/common/libs/fs:fd",
         "//cuttlefish/common/libs/utils:files",
         "//cuttlefish/files:file_exists",
         "//cuttlefish/host/commands/run_cvd/launch:grpc_socket_creator",
@@ -508,7 +510,7 @@ cf_cc_library(
     srcs = ["tombstone_receiver.cpp"],
     hdrs = ["tombstone_receiver.h"],
     deps = [
-        "//cuttlefish/common/libs/fs",
+        "//cuttlefish/common/libs/fs:fd",
         "//cuttlefish/files:directory_exists",
         "//cuttlefish/host/libs/config:cuttlefish_config",
         "//cuttlefish/host/libs/config:known_paths",
@@ -540,7 +542,7 @@ cf_cc_library(
     srcs = ["vhal_proxy_server.cpp"],
     hdrs = ["vhal_proxy_server.h"],
     deps = [
-        "//cuttlefish/common/libs/fs",
+        "//cuttlefish/common/libs/fs:fd",
         "//cuttlefish/host/libs/config:cuttlefish_config",
         "//cuttlefish/host/libs/config:known_paths",
         "//cuttlefish/host/libs/feature",

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

@@ -24,6 +24,7 @@
 
 #include "absl/log/log.h"
 
+#include "cuttlefish/common/libs/fs/fd.h"
 #include "cuttlefish/common/libs/fs/shared_fd.h"
 #include "cuttlefish/host/libs/config/cuttlefish_config.h"
 #include "cuttlefish/host/libs/config/known_paths.h"
@@ -73,22 +74,19 @@ Result<std::optional<MonitorCommand>> ModemSimulator(
   CF_EXPECT(instance_number >= 0 && instance_number < 4,
             "Modem simulator instance number should range between 0 and 3");
   auto ports = instance.modem_simulator_ports();
-  std::vector<SharedFD> sockets;
+  std::vector<Fd> sockets;
   for (int i = 0; i < instance_number; ++i) {
     auto pos = ports.find(',');
     auto temp = (pos != std::string::npos) ? ports.substr(0, pos) : ports;
     auto port = std::stoi(temp);
     ports = ports.substr(pos + 1);
 
-    auto modem_sim_socket = SharedFD::VsockServer(
-        port, SOCK_STREAM,
-        instance.vhost_user_vsock()
-            ? std::make_optional(instance.vsock_guest_cid())
-            : std::nullopt);
-    CF_EXPECT(
-        modem_sim_socket->IsOpen(),
-        modem_sim_socket->StrError()
-            << " (try `cvd reset`, or `pkill run_cvd` and `pkill crosvm`)");
+    Fd modem_sim_socket = CF_EXPECT(
+        Fd::VsockServer(port, SOCK_STREAM,
+                        instance.vhost_user_vsock()
+                            ? std::make_optional(instance.vsock_guest_cid())
+                            : std::nullopt),
+        " (try `cvd reset`, or `pkill run_cvd` and `pkill crosvm`)");
     sockets.emplace_back(std::move(modem_sim_socket));
   }
 
@@ -100,11 +98,11 @@ Result<std::optional<MonitorCommand>> ModemSimulator(
   cmd.AddParameter(std::string{"-sim_type="} + std::to_string(sim_type));
   cmd.AddParameter("-server_fds=");
   bool first_socket = true;
-  for (const auto& socket : sockets) {
+  for (auto& socket : sockets) {
     if (!first_socket) {
       cmd.AppendToLastParameter(",");
     }
-    cmd.AppendToLastParameter(socket);
+    cmd.AppendToLastParameter(SharedFD(std::move(socket)));
     first_socket = false;
   }
   return cmd;

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

@@ -28,6 +28,7 @@
 #include "fruit/fruit_forward_decls.h"
 #include "fruit/macro.h"
 
+#include "cuttlefish/common/libs/fs/fd.h"
 #include "cuttlefish/common/libs/fs/shared_fd.h"
 #include "cuttlefish/common/libs/utils/files.h"
 #include "cuttlefish/files/file_exists.h"
@@ -261,17 +262,17 @@ class NetsimServer : public CommandSource {
               absl::SimpleAtoi(port_strings[i], &port),
               "Failed to parse modem simulator port: " << port_strings[i]);
 
-          auto vsock = SharedFD::VsockServer(
-              port, SOCK_STREAM,
-              instance.vhost_user_vsock()
-                  ? std::make_optional(instance.vsock_guest_cid())
-                  : std::nullopt);
-          CF_EXPECT(vsock->IsOpen(), vsock->StrError()
-                                         << " (try `cvd reset`, or `pkill "
-                                            "run_cvd` and `pkill crosvm`)");
+          Fd vsock =
+              CF_EXPECT(Fd::VsockServer(
+                            port, SOCK_STREAM,
+                            instance.vhost_user_vsock()
+                                ? std::make_optional(instance.vsock_guest_cid())
+                                : std::nullopt),
+                        " (try `cvd reset`, or `pkill "
+                        "run_cvd` and `pkill crosvm`)");
 
           Chip chip("CELLULAR");
-          chip.vsock_fd = vsock;
+          chip.vsock_fd = std::move(vsock);
           chip.sim_type = instance.modem_simulator_sim_type();
           device.chips.emplace_back(chip);
         }

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

@@ -18,12 +18,12 @@
 #include <errno.h>
 #include <sys/stat.h>
 
-#include <cstring>
 #include <optional>
+#include <utility>
 
 #include "absl/log/log.h"
 
-#include "cuttlefish/common/libs/fs/shared_fd.h"
+#include "cuttlefish/common/libs/fs/fd.h"
 #include "cuttlefish/files/directory_exists.h"
 #include "cuttlefish/host/libs/config/cuttlefish_config.h"
 #include "cuttlefish/host/libs/config/known_paths.h"
@@ -47,16 +47,14 @@ Result<MonitorCommand> TombstoneReceiver(
   }
 
   auto port = instance.tombstone_receiver_port();
-  auto socket =
-      SharedFD::VsockServer(port, SOCK_STREAM,
-                            instance.vhost_user_vsock()
-                                ? std::make_optional(instance.vsock_guest_cid())
-                                : std::nullopt);
-  CF_EXPECTF(socket->IsOpen(), "Can't tombstone server socket: '{}'",
-             socket->StrError());
+  Fd socket = CF_EXPECT(
+      Fd::VsockServer(port, SOCK_STREAM,
+                      instance.vhost_user_vsock()
+                          ? std::make_optional(instance.vsock_guest_cid())
+                          : std::nullopt));
 
   return Command(TombstoneReceiverBinary())
-      .AddParameter("-server_fd=", socket)
+      .AddParameter("-server_fd=", std::move(socket))
       .AddParameter("-tombstone_dir=", tombstone_dir);
 }
 

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

@@ -22,7 +22,7 @@
 #include "fmt/core.h"
 #include "fmt/format.h"
 
-#include "cuttlefish/common/libs/fs/shared_fd.h"
+#include "cuttlefish/common/libs/fs/fd.h"
 #include "cuttlefish/host/libs/config/cuttlefish_config.h"
 #include "cuttlefish/host/libs/config/known_paths.h"
 #include "cuttlefish/host/libs/feature/command_source.h"
@@ -42,9 +42,9 @@ std::optional<MonitorCommand> VhalProxyServer(
                         .AddParameter(fmt::format(
                             "{}:{}", vhal_proxy_server::kEthAddr, port));
   if (instance.vhost_user_vsock()) {
-    command.AddParameter(
-        fmt::format("unix://{}", SharedFD::GetVhostUserVsockServerAddr(
-                                     port, instance.vsock_guest_cid())));
+    command.AddParameter(fmt::format(
+        "unix://{}",
+        Fd::GetVhostUserVsockServerAddr(port, instance.vsock_guest_cid())));
   } else {
     command.AddParameter(fmt::format("vsock:{}:{}", VMADDR_CID_HOST, port));
   }

base/cvd/cuttlefish/host/commands/socket_vsock_proxy/server.cpp

@@ -89,7 +89,10 @@ VsockServer::VsockServer(int port, std::optional<int> vhost_user_vsock_cid)
 Result<SharedFD> VsockServer::Start() {
   SharedFD server;
   do {
-    server = SharedFD::VsockServer(port_, SOCK_STREAM, vhost_user_vsock_cid_);
+    // TODO(schuffelen): Expose errno from Fd results so
+    // socketErrorIsRecoverable works correctly
+    server = Fd::VsockServer(port_, SOCK_STREAM, vhost_user_vsock_cid_)
+                 .value_or(Fd());
     if (!server->IsOpen() && !socketErrorIsRecoverable(server->GetErrno())) {
       LOG(ERROR) << "Could not open vsock socket: " << server->StrError();
       // socket_vsock_proxy will now wait forever in the guest on encountering