[ramdevice_client] Separate RamNand and RamNandCtl

Move around the functions for RamNand so that only
RamNandCtl touches the Isolated Devmgr code. This is
in preparation for making the Isolated Devmgr code
testonly.

Bug: 84322

Change-Id: I05407d91050bc10452647c6247c5d48e0cd6899c
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/579423
Reviewed-by: Suraj Malhotra <surajmalhotra@google.com>
Commit-Queue: David Gilhooley <dgilhooley@google.com>

Author: gilhooleyd

src/lib/storage/ramdevice_client/cpp/include/ramdevice-client/ramnand.h

@@ -26,6 +26,12 @@ class RamNandCtl : public fbl::RefCounted<RamNandCtl> {
   // Creates an isolated devmgr and spawns a ram_nand_ctl device in it.
   static zx_status_t Create(fbl::RefPtr<RamNandCtl>* out);
 
+  static zx_status_t CreateWithRamNand(const fuchsia_hardware_nand_RamNandInfo* config,
+                                       std::optional<RamNand>* out);
+
+  zx_status_t CreateRamNand(const fuchsia_hardware_nand_RamNandInfo* config,
+                            std::optional<RamNand>* out);
+
   ~RamNandCtl() = default;
 
   const fbl::unique_fd& fd() { return ctl_; }
@@ -47,15 +53,6 @@ class RamNand {
   static zx_status_t Create(const fuchsia_hardware_nand_RamNandInfo* config,
                             std::optional<RamNand>* out);
 
-  // Creates a ram_nand device underneath the ram_nand_ctl.
-  static zx_status_t Create(fbl::RefPtr<RamNandCtl> ctl,
-                            const fuchsia_hardware_nand_RamNandInfo* config,
-                            std::optional<RamNand>* out);
-
-  // Creates a ram_nand_ctl device and then a ram_device underneath.
-  static zx_status_t CreateIsolated(const fuchsia_hardware_nand_RamNandInfo* config,
-                                    std::optional<RamNand>* out);
-
   // Not copyable.
   RamNand(const RamNand&) = delete;
   RamNand& operator=(const RamNand&) = delete;
@@ -84,14 +81,12 @@ class RamNand {
     return nullptr;
   }
 
-  const fbl::unique_fd& devfs_root() { return parent_->devfs_root(); }
+  explicit RamNand(fbl::unique_fd fd)
+      : fd_(std::move(fd)), path_(std::nullopt), filename_(std::nullopt) {}
 
  private:
-  RamNand(fbl::unique_fd fd, fbl::RefPtr<RamNandCtl> ctl)
-      : fd_(std::move(fd)), path_(std::nullopt), filename_(std::nullopt), parent_(ctl) {}
-
   RamNand(fbl::unique_fd fd, fbl::String path, fbl::String filename)
-      : fd_(std::move(fd)), path_(path), filename_(filename), parent_(nullptr) {}
+      : fd_(std::move(fd)), path_(path), filename_(filename) {}
 
   fbl::unique_fd fd_;
   bool unbind = true;
@@ -101,9 +96,6 @@ class RamNand {
 
   // Only valid if not spawned in an isolated devmgr.
   std::optional<fbl::String> filename_;
-
-  // Optional parent if spawned in an isolated devmgr.
-  fbl::RefPtr<RamNandCtl> parent_;
 };
 
 }  // namespace ramdevice_client

src/lib/storage/ramdevice_client/cpp/ramnand.cc

@@ -84,99 +84,98 @@ zx_status_t RamNandCtl::Create(fbl::RefPtr<RamNandCtl>* out) {
 }
 
 __EXPORT
-zx_status_t RamNand::Create(const fuchsia_hardware_nand_RamNandInfo* config,
-                            std::optional<RamNand>* out) {
-  fbl::unique_fd control(open(kBasePath, O_RDWR));
-
-  zx::channel ctl_svc;
-  zx_status_t st = fdio_get_service_handle(control.release(), ctl_svc.reset_and_get_address());
-  if (st != ZX_OK) {
-    return st;
+zx_status_t RamNandCtl::CreateRamNand(const fuchsia_hardware_nand_RamNandInfo* config,
+                                      std::optional<RamNand>* out) {
+  fdio_t* io = fdio_unsafe_fd_to_io(fd().get());
+  if (io == NULL) {
+    fprintf(stderr, "Could not get fdio object\n");
+    return ZX_ERR_INTERNAL;
   }
+  zx_handle_t ctl_svc = fdio_unsafe_borrow_channel(io);
 
   char name[fuchsia_hardware_nand_NAME_LEN + 1];
   size_t out_name_size;
   zx_status_t status;
-  st = fuchsia_hardware_nand_RamNandCtlCreateDevice(ctl_svc.get(), config, &status, name,
-                                                    fuchsia_hardware_nand_NAME_LEN, &out_name_size);
+  zx_status_t st = fuchsia_hardware_nand_RamNandCtlCreateDevice(
+      ctl_svc, config, &status, name, fuchsia_hardware_nand_NAME_LEN, &out_name_size);
+  fdio_unsafe_release(io);
   if (st != ZX_OK || status != ZX_OK) {
     st = st != ZX_OK ? st : status;
     fprintf(stderr, "Could not create ram_nand device, %d\n", st);
     return st;
   }
   name[out_name_size] = '\0';
+
+  // TODO(fxbug.dev/33003): We should be able to open relative to ctl->fd(), but
+  // due to a bug, we have to be relative to devfs_root instead.
   fbl::StringBuffer<PATH_MAX> path;
-  path.Append(kBasePath);
-  path.Append("/");
+  path.Append("sys/platform/00:00:2e/nand-ctl/");
   path.Append(name);
+  fprintf(stderr, "Trying to open (%s)\n", path.c_str());
 
-  fbl::unique_fd ram_nand_ctl(open(kBasePath, O_RDONLY | O_DIRECTORY));
-  if (!ram_nand_ctl) {
-    fprintf(stderr, "Could not open ram_nand_ctl");
-    return ZX_ERR_INTERNAL;
-  }
-
-  fbl::unique_fd ram_nand;
-  st = WaitForFile(ram_nand_ctl, name, &ram_nand);
+  fbl::unique_fd fd;
+  st = devmgr_integration_test::RecursiveWaitForFile(devfs_root(), path.c_str(), &fd);
   if (st != ZX_OK) {
-    fprintf(stderr, "Could not open ram_nand\n");
     return st;
   }
 
-  *out = RamNand(std::move(ram_nand), path.ToString(), fbl::String(name));
+  *out = RamNand(std::move(fd));
   return ZX_OK;
 }
 
 __EXPORT
-zx_status_t RamNand::Create(fbl::RefPtr<RamNandCtl> ctl,
-                            const fuchsia_hardware_nand_RamNandInfo* config,
+zx_status_t RamNandCtl::CreateWithRamNand(const fuchsia_hardware_nand_RamNandInfo* config,
+                                          std::optional<RamNand>* out) {
+  fbl::RefPtr<RamNandCtl> ctl;
+  zx_status_t st = RamNandCtl::Create(&ctl);
+  if (st != ZX_OK) {
+    return st;
+  }
+  return ctl->CreateRamNand(config, out);
+}
+
+__EXPORT
+zx_status_t RamNand::Create(const fuchsia_hardware_nand_RamNandInfo* config,
                             std::optional<RamNand>* out) {
-  fdio_t* io = fdio_unsafe_fd_to_io(ctl->fd().get());
-  if (io == NULL) {
-    fprintf(stderr, "Could not get fdio object\n");
-    return ZX_ERR_INTERNAL;
+  fbl::unique_fd control(open(kBasePath, O_RDWR));
+
+  zx::channel ctl_svc;
+  zx_status_t st = fdio_get_service_handle(control.release(), ctl_svc.reset_and_get_address());
+  if (st != ZX_OK) {
+    return st;
   }
-  zx_handle_t ctl_svc = fdio_unsafe_borrow_channel(io);
 
   char name[fuchsia_hardware_nand_NAME_LEN + 1];
   size_t out_name_size;
   zx_status_t status;
-  zx_status_t st = fuchsia_hardware_nand_RamNandCtlCreateDevice(
-      ctl_svc, config, &status, name, fuchsia_hardware_nand_NAME_LEN, &out_name_size);
-  fdio_unsafe_release(io);
+  st = fuchsia_hardware_nand_RamNandCtlCreateDevice(ctl_svc.get(), config, &status, name,
+                                                    fuchsia_hardware_nand_NAME_LEN, &out_name_size);
   if (st != ZX_OK || status != ZX_OK) {
     st = st != ZX_OK ? st : status;
     fprintf(stderr, "Could not create ram_nand device, %d\n", st);
     return st;
   }
   name[out_name_size] = '\0';
-
-  // TODO(fxbug.dev/33003): We should be able to open relative to ctl->fd(), but
-  // due to a bug, we have to be relative to devfs_root instead.
   fbl::StringBuffer<PATH_MAX> path;
-  path.Append("sys/platform/00:00:2e/nand-ctl/");
+  path.Append(kBasePath);
+  path.Append("/");
   path.Append(name);
-  fprintf(stderr, "Trying to open (%s)\n", path.c_str());
 
-  fbl::unique_fd fd;
-  st = devmgr_integration_test::RecursiveWaitForFile(ctl->devfs_root(), path.c_str(), &fd);
-  if (st != ZX_OK) {
-    return st;
+  fbl::unique_fd ram_nand_ctl(open(kBasePath, O_RDONLY | O_DIRECTORY));
+  if (!ram_nand_ctl) {
+    fprintf(stderr, "Could not open ram_nand_ctl");
+    return ZX_ERR_INTERNAL;
   }
 
-  *out = RamNand(std::move(fd), std::move(ctl));
-  return ZX_OK;
-}
-
-__EXPORT
-zx_status_t RamNand::CreateIsolated(const fuchsia_hardware_nand_RamNandInfo* config,
-                                    std::optional<RamNand>* out) {
-  fbl::RefPtr<RamNandCtl> ctl;
-  zx_status_t st = RamNandCtl::Create(&ctl);
+  fbl::unique_fd ram_nand;
+  st = WaitForFile(ram_nand_ctl, name, &ram_nand);
   if (st != ZX_OK) {
+    fprintf(stderr, "Could not open ram_nand\n");
     return st;
   }
-  return Create(std::move(ctl), config, out);
+
+  *out = RamNand(std::move(ram_nand), path.ToString(), fbl::String(name));
+  return ZX_OK;
 }
 
 __EXPORT