[NaCl SDK] Create Filesystem nodes in /dev/fs/...

native_client_sdk/src/libraries/nacl_io/devfs/dev_fs.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #if defined(WIN32)
 #define _CRT_RAND_S
 #endif
 
 #include "nacl_io/devfs/dev_fs.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
+#include <stdio.h>
 #include <string.h>
 
 #include "nacl_io/devfs/jspipe_node.h"
 #include "nacl_io/devfs/tty_node.h"
 #include "nacl_io/dir_node.h"
 #include "nacl_io/kernel_wrap_real.h"
 #include "nacl_io/node.h"
 #include "nacl_io/osunistd.h"
 #include "nacl_io/pepper_interface.h"
 #include "sdk_util/auto_lock.h"
@@ skipping 80 matching lines @@
                       size_t count,
                       int* out_bytes);
 
  private:
 #if defined(__native_client__)
   nacl_irt_random random_interface_;
   bool interface_ok_;
 #endif
 };
 
+class FsNode : public Node {
+ public:
+  FsNode(Filesystem* filesystem, Filesystem* other_fs);
+
+  virtual Error VIoctl(int request, va_list args);
+
+ private:
+  // Don't addref the filesystem. We are relying on the fact that the
+  // KernelObject will keep the filsystem around as long as we need it, and
+  // this node will be destroyed when the filesystem is destroyed.
+  Filesystem* other_fs_;
+};
+
 RealNode::RealNode(Filesystem* filesystem, int fd) : Node(filesystem), fd_(fd) {
   SetType(S_IFCHR);
 }
 
 Error RealNode::Read(const HandleAttr& attr,
                      void* buf,
                      size_t count,
                      int* out_bytes) {
   *out_bytes = 0;
 
@@ skipping 130 matching lines @@
 }
 
 Error UrandomNode::Write(const HandleAttr& attr,
                          const void* buf,
                          size_t count,
                          int* out_bytes) {
   *out_bytes = count;
   return 0;
 }
 
+FsNode::FsNode(Filesystem* filesystem, Filesystem* other_fs)
+    : Node(filesystem), other_fs_(other_fs) {
+}
+
+Error FsNode::VIoctl(int request, va_list args) {
+  return other_fs_->Filesystem_VIoctl(request, args);
+}
+
 }  // namespace
 
 Error DevFs::Access(const Path& path, int a_mode) {
   ScopedNode node;
   int error = root_->FindChild(path.Join(), &node);
   if (error)
     return error;
 
   // Don't allow execute access.
   if (a_mode & X_OK)
     return EACCES;
 
   return 0;
 }
 
 Error DevFs::Open(const Path& path, int open_flags, ScopedNode* out_node) {
   out_node->reset(NULL);
-  int error = root_->FindChild(path.Join(), out_node);
+  int error;
+  if (path.Part(1) == "fs") {
+    if (path.Size() == 3)
+      error = fs_dir_->FindChild(path.Part(2), out_node);
+    else
+      error = ENOENT;
+  } else {
+    error = root_->FindChild(path.Join(), out_node);
+  }
+
   // Only return EACCES when trying to create a node that does not exist.
   if ((error == ENOENT) && (open_flags & O_CREAT))
     return EACCES;
 
   return error;
 }
 
 Error DevFs::Unlink(const Path& path) { return EPERM; }
 
 Error DevFs::Mkdir(const Path& path, int permissions) { return EPERM; }
 
 Error DevFs::Rmdir(const Path& path) { return EPERM; }
 
 Error DevFs::Remove(const Path& path) { return EPERM; }
 
 Error DevFs::Rename(const Path& path, const Path& newpath) { return EPERM; }
 
+Error DevFs::CreateFsNode(Filesystem* other_fs) {
+  int dev = other_fs->dev();
+  char path[32];
+  snprintf(path, 32, "%d", dev);
+  ScopedNode new_node(new FsNode(this, other_fs));
+  return fs_dir_->AddChild(path, new_node);
+}
+
+Error DevFs::DestroyFsNode(Filesystem* other_fs) {
+  int dev = other_fs->dev();
+  char path[32];
+  snprintf(path, 32, "%d", dev);
+  return fs_dir_->RemoveChild(path);
+}
+
+
 DevFs::DevFs() {}
 
 #define INITIALIZE_DEV_NODE(path, klass)   \
   new_node = ScopedNode(new klass(this));  \
   error = root_->AddChild(path, new_node); \
   if (error)                               \
     return error;
 
 #define INITIALIZE_DEV_NODE_1(path, klass, arg) \
   new_node = ScopedNode(new klass(this, arg));  \
@@ skipping 20 matching lines @@
   INITIALIZE_DEV_NODE_1("/stdin", RealNode, 0);
   INITIALIZE_DEV_NODE_1("/stdout", RealNode, 1);
   INITIALIZE_DEV_NODE_1("/stderr", RealNode, 2);
   INITIALIZE_DEV_NODE("/jspipe1", JSPipeNode);
   new_node->Ioctl(NACL_IOC_PIPE_SETNAME, "jspipe1");
   INITIALIZE_DEV_NODE("/jspipe2", JSPipeNode);
   new_node->Ioctl(NACL_IOC_PIPE_SETNAME, "jspipe2");
   INITIALIZE_DEV_NODE("/jspipe3", JSPipeNode);
   new_node->Ioctl(NACL_IOC_PIPE_SETNAME, "jspipe3");
 
+  // Add a directory for "fs" nodes; they represent all currently-mounted
+  // filesystems. We can ioctl these nodes to make changes or provide input to
+  // a mounted filesystem.
+  INITIALIZE_DEV_NODE("/fs", DirNode);
+  fs_dir_ = new_node;
+
   return 0;
 }
 
 }  // namespace nacl_io