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

native_client_sdk/src/libraries/nacl_io/kernel_proxy.cc

 // Copyright (c) 2012 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.
 
 #include "nacl_io/kernel_proxy.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <poll.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/time.h>
 #include <unistd.h>
 
 #include <iterator>
 #include <string>
 
 #include "nacl_io/devfs/dev_fs.h"
 #include "nacl_io/filesystem.h"
 #include "nacl_io/fusefs/fuse_fs_factory.h"
 #include "nacl_io/host_resolver.h"
 #include "nacl_io/html5fs/html5_fs.h"
 #include "nacl_io/httpfs/http_fs.h"
 #include "nacl_io/kernel_handle.h"
 #include "nacl_io/kernel_wrap_real.h"
+#include "nacl_io/log.h"
 #include "nacl_io/memfs/mem_fs.h"
 #include "nacl_io/node.h"
 #include "nacl_io/osmman.h"
 #include "nacl_io/ossocket.h"
 #include "nacl_io/osstat.h"
 #include "nacl_io/passthroughfs/passthrough_fs.h"
 #include "nacl_io/path.h"
 #include "nacl_io/pepper_interface.h"
 #include "nacl_io/pipe/pipe_node.h"
 #include "nacl_io/socket/tcp_node.h"
 #include "nacl_io/socket/udp_node.h"
 #include "nacl_io/stream/stream_fs.h"
 #include "nacl_io/typed_fs_factory.h"
 #include "sdk_util/auto_lock.h"
 #include "sdk_util/ref_object.h"
 #include "sdk_util/string_util.h"
 
 #ifndef MAXPATHLEN
 #define MAXPATHLEN 256
 #endif
 
 namespace nacl_io {
 
-
-KernelProxy::KernelProxy() : dev_(0), ppapi_(NULL),
-                             exit_handler_(NULL),
-                             signal_emitter_(new EventEmitter) {
-   memset(&sigwinch_handler_, 0, sizeof(sigwinch_handler_));
-   sigwinch_handler_.sa_handler = SIG_DFL;
+KernelProxy::KernelProxy()
+    : dev_(0),
+      ppapi_(NULL),
+      exit_handler_(NULL),
+      signal_emitter_(new EventEmitter) {
+  memset(&sigwinch_handler_, 0, sizeof(sigwinch_handler_));
+  sigwinch_handler_.sa_handler = SIG_DFL;
 }
 
 KernelProxy::~KernelProxy() {
-  // Clean up the MountFactories.
+  // Clean up the FsFactories.
   for (FsFactoryMap_t::iterator i = factories_.begin(); i != factories_.end();
        ++i) {
     delete i->second;
   }
 }
 
 Error KernelProxy::Init(PepperInterface* ppapi) {
   Error rtn = 0;
   ppapi_ = ppapi;
   dev_ = 1;
 
   factories_["memfs"] = new TypedFsFactory<MemFs>;
   factories_["dev"] = new TypedFsFactory<DevFs>;
   factories_["html5fs"] = new TypedFsFactory<Html5Fs>;
   factories_["httpfs"] = new TypedFsFactory<HttpFs>;
   factories_["passthroughfs"] = new TypedFsFactory<PassthroughFs>;
 
-  int result;
-  result = mount("", "/", "passthroughfs", 0, NULL);
-  if (result != 0) {
+  ScopedFilesystem root_fs;
+  rtn = MountInternal("", "/", "passthroughfs", 0, NULL, false, &root_fs);
+  if (rtn != 0)
     assert(false);
-    rtn = errno;
-  }
 
-  result = mount("", "/dev", "dev", 0, NULL);
-  if (result != 0) {
+  ScopedFilesystem fs;
+  rtn = MountInternal("", "/dev", "dev", 0, NULL, false, &fs);
+  if (rtn != 0)
     assert(false);
-    rtn = errno;
-  }
+  dev_fs_ = sdk_util::static_scoped_ref_cast<DevFs>(fs);
+
+  // Create the filesystem nodes for / and /dev afterward. They can't be
+  // created the normal way because the dev filesystem didn't exist yet.
+  rtn = CreateFsNode(root_fs);
+  if (rtn != 0)
+    assert(false);
+
+  rtn = CreateFsNode(dev_fs_);
+  if (rtn != 0)
+    assert(false);
 
   // Open the first three in order to get STDIN, STDOUT, STDERR
   int fd;
   fd = open("/dev/stdin", O_RDONLY);
   assert(fd == 0);
   if (fd < 0)
     rtn = errno;
 
   fd = open("/dev/stdout", O_WRONLY);
   assert(fd == 1);
   if (fd < 0)
     rtn = errno;
 
   fd = open("/dev/stderr", O_WRONLY);
   assert(fd == 2);
   if (fd < 0)
     rtn = errno;
 
 #ifdef PROVIDES_SOCKET_API
   host_resolver_.Init(ppapi_);
 #endif
 
   FsInitArgs args;
   args.dev = dev_++;
   args.ppapi = ppapi_;
-  stream_mount_.reset(new StreamFs());
-  result = stream_mount_->Init(args);
+  stream_fs_.reset(new StreamFs());
+  int result = stream_fs_->Init(args);
   if (result != 0) {
     assert(false);
     rtn = result;
   }
 
   return rtn;
 }
 
 bool KernelProxy::RegisterFsType(const char* fs_type,
                                  fuse_operations* fuse_ops) {
@@ skipping 69 matching lines @@
   error = handle->Init(open_flags);
   if (error) {
     errno = error;
     return -1;
   }
 
   return AllocateFD(handle, path);
 }
 
 int KernelProxy::pipe(int pipefds[2]) {
-  PipeNode* pipe = new PipeNode(stream_mount_.get());
+  PipeNode* pipe = new PipeNode(stream_fs_.get());
   ScopedNode node(pipe);
 
   if (pipe->Init(O_RDWR) == 0) {
-    ScopedKernelHandle handle0(new KernelHandle(stream_mount_, node));
-    ScopedKernelHandle handle1(new KernelHandle(stream_mount_, node));
+    ScopedKernelHandle handle0(new KernelHandle(stream_fs_, node));
+    ScopedKernelHandle handle1(new KernelHandle(stream_fs_, node));
 
     // Should never fail, but...
     if (handle0->Init(O_RDONLY) || handle1->Init(O_WRONLY)) {
       errno = EACCES;
       return -1;
     }
 
     pipefds[0] = AllocateFD(handle0);
     pipefds[1] = AllocateFD(handle1);
     return 0;
@@ skipping 151 matching lines @@
 int KernelProxy::stat(const char* path, struct stat* buf) {
   int fd = open(path, O_RDONLY);
   if (-1 == fd)
     return -1;
 
   int result = fstat(fd, buf);
   close(fd);
   return result;
 }
 
-
 int KernelProxy::mount(const char* source,
                        const char* target,
                        const char* filesystemtype,
                        unsigned long mountflags,
                        const void* data) {
+  ScopedFilesystem fs;
+  Error error = MountInternal(
+      source, target, filesystemtype, mountflags, data, true, &fs);
+  if (error) {
+    errno = error;
+    return -1;
+  }
+
+  return 0;
+}
+
+Error KernelProxy::MountInternal(const char* source,
+                                 const char* target,
+                                 const char* filesystemtype,
+                                 unsigned long mountflags,
+                                 const void* data,
+                                 bool create_fs_node,
+                                 ScopedFilesystem* out_filesystem) {
   std::string abs_path = GetAbsParts(target).Join();
 
   // Find a factory of that type
   FsFactoryMap_t::iterator factory = factories_.find(filesystemtype);
-  if (factory == factories_.end()) {
-    errno = ENODEV;
-    return -1;
-  }
+  if (factory == factories_.end())
+    return ENODEV;
 
   // Create a map of settings
   StringMap_t smap;
   smap["SOURCE"] = source;
   smap["TARGET"] = abs_path;
 
   if (data) {
     std::vector<std::string> elements;
     sdk_util::SplitString(static_cast<const char*>(data), ',', &elements);
 
     for (std::vector<std::string>::const_iterator it = elements.begin();
-         it != elements.end(); ++it) {
+         it != elements.end();
+         ++it) {
       size_t location = it->find('=');
       if (location != std::string::npos) {
         std::string key = it->substr(0, location);
         std::string val = it->substr(location + 1);
         smap[key] = val;
       } else {
         smap[*it] = "TRUE";
       }
     }
   }
 
   FsInitArgs args;
   args.dev = dev_++;
   args.string_map = smap;
   args.ppapi = ppapi_;
 
   ScopedFilesystem fs;
   Error error = factory->second->CreateFilesystem(args, &fs);
+  if (error)
+    return error;
+
+  error = AttachFsAtPath(fs, abs_path);
+  if (error)
+    return error;
+
+  if (create_fs_node) {
+    error = CreateFsNode(fs);
+    if (error)
+      return error;
+  }
+
+  *out_filesystem = fs;
+  return 0;
+}
+
+Error KernelProxy::CreateFsNode(const ScopedFilesystem& fs) {
+  assert(dev_fs_);
+
+  return dev_fs_->CreateFsNode(fs.get());
+}
+
+int KernelProxy::umount(const char* path) {
+  ScopedFilesystem fs;
+  Error error = DetachFsAtPath(path, &fs);
   if (error) {
     errno = error;
     return -1;
   }
 
-  error = AttachFsAtPath(fs, abs_path);
+  error = dev_fs_->DestroyFsNode(fs.get());
   if (error) {
-    errno = error;
-    return -1;
-  }
-
-  return 0;
-}
-
-int KernelProxy::umount(const char* path) {
-  Error error = DetachFsAtPath(path);
-  if (error) {
-    errno = error;
-    return -1;
+    // Ignore any errors here, just log.
+    LOG_ERROR("Unable to destroy FsNode: %s", strerror(error));
   }
   return 0;
 }
 
 ssize_t KernelProxy::read(int fd, void* buf, size_t nbytes) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
@@ skipping 275 matching lines @@
     errno = error;
     return -1;
   }
 
   return 0;
 }
 
 int KernelProxy::fcntl(int fd, int request, va_list args) {
   Error error = 0;
 
-  // F_GETFD and F_SETFD are descirptor specific flags that
-  // are stored in the KernelObject's decriptor map unlink
+  // F_GETFD and F_SETFD are descriptor specific flags that
+  // are stored in the KernelObject's decriptor map unlike
   // F_GETFL and F_SETFL which are handle specific.
   switch (request) {
     case F_GETFD: {
       int rtn = -1;
       error = GetFDFlags(fd, &rtn);
       if (error) {
         errno = error;
         return -1;
       }
       return rtn;
@@ skipping 37 matching lines @@
   }
 
   error = fs->Access(rel, amode);
   if (error) {
     errno = error;
     return -1;
   }
   return 0;
 }
 
-int KernelProxy::readlink(const char *path, char *buf, size_t count) {
+int KernelProxy::readlink(const char* path, char* buf, size_t count) {
   errno = EINVAL;
   return -1;
 }
 
-int KernelProxy::utimes(const char *filename, const struct timeval times[2]) {
+int KernelProxy::utimes(const char* filename, const struct timeval times[2]) {
   errno = EINVAL;
   return -1;
 }
 
 // TODO(noelallen): Needs implementation.
 int KernelProxy::link(const char* oldpath, const char* newpath) {
   errno = EINVAL;
   return -1;
 }
 
@@ skipping 91 matching lines @@
 
   error = handle->node()->Tcgetattr(termios_p);
   if (error) {
     errno = error;
     return -1;
   }
 
   return 0;
 }
 
-int KernelProxy::tcsetattr(int fd, int optional_actions,
-                           const struct termios *termios_p) {
+int KernelProxy::tcsetattr(int fd,
+                           int optional_actions,
+                           const struct termios* termios_p) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
   error = handle->node()->Tcsetattr(optional_actions, termios_p);
   if (error) {
     errno = error;
@@ skipping 28 matching lines @@
     case SIGUSR2:
       break;
 
     default:
       errno = EINVAL;
       return -1;
   }
   return 0;
 }
 
-int KernelProxy::sigaction(int signum, const struct sigaction* action,
+int KernelProxy::sigaction(int signum,
+                           const struct sigaction* action,
                            struct sigaction* oaction) {
   if (action && action->sa_flags & SA_SIGINFO) {
     // We don't support SA_SIGINFO (sa_sigaction field) yet
     errno = EINVAL;
     return -1;
   }
 
   switch (signum) {
     // Handled signals.
     case SIGWINCH: {
@@ skipping 39 matching lines @@
       return -1;
   }
 
   // Unknown signum
   errno = EINVAL;
   return -1;
 }
 
 #ifdef PROVIDES_SOCKET_API
 
-int KernelProxy::select(int nfds, fd_set* readfds, fd_set* writefds,
-                        fd_set* exceptfds, struct timeval* timeout) {
+int KernelProxy::select(int nfds,
+                        fd_set* readfds,
+                        fd_set* writefds,
+                        fd_set* exceptfds,
+                        struct timeval* timeout) {
   std::vector<pollfd> pollfds;
 
   for (int fd = 0; fd < nfds; fd++) {
     int events = 0;
     if (readfds && FD_ISSET(fd, readfds)) {
       events |= POLLIN;
       FD_CLR(fd, readfds);
     }
 
     if (writefds && FD_ISSET(fd, writefds)) {
@@ skipping 14 matching lines @@
     }
   }
 
   // NULL timeout signals wait forever.
   int ms_timeout = -1;
   if (timeout != NULL) {
     int64_t ms = timeout->tv_sec * 1000 + ((timeout->tv_usec + 500) / 1000);
 
     // If the timeout is invalid or too long (larger than signed 32 bit).
     if ((timeout->tv_sec < 0) || (timeout->tv_sec >= (INT_MAX / 1000)) ||
-        (timeout->tv_usec < 0) || (timeout->tv_usec >= 1000000) ||
-        (ms < 0) || (ms >= INT_MAX)) {
+        (timeout->tv_usec < 0) || (timeout->tv_usec >= 1000000) || (ms < 0) ||
+        (ms >= INT_MAX)) {
       errno = EINVAL;
       return -1;
     }
 
     ms_timeout = static_cast<int>(ms);
   }
 
   int result = poll(&pollfds[0], pollfds.size(), ms_timeout);
   if (result == -1)
     return -1;
@@ skipping 20 matching lines @@
 
 struct PollInfo {
   PollInfo() : index(-1) {};
 
   std::vector<struct pollfd*> fds;
   int index;
 };
 
 typedef std::map<EventEmitter*, PollInfo> EventPollMap_t;
 
-int KernelProxy::poll(struct pollfd *fds, nfds_t nfds, int timeout) {
+int KernelProxy::poll(struct pollfd* fds, nfds_t nfds, int timeout) {
   EventPollMap_t event_map;
 
   std::vector<EventRequest> requests;
   size_t event_cnt = 0;
 
   for (int index = 0; static_cast<nfds_t>(index) < nfds; index++) {
     ScopedKernelHandle handle;
     struct pollfd* fd_info = &fds[index];
     Error err = AcquireHandle(fd_info->fd, &handle);
 
@@ skipping 60 matching lines @@
             event_cnt++;
           }
         }
       }
     }
   }
 
   return event_cnt;
 }
 
-
 // Socket Functions
 int KernelProxy::accept(int fd, struct sockaddr* addr, socklen_t* len) {
   if (NULL == addr || NULL == len) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
   PP_Resource new_sock = 0;
   error = handle->Accept(&new_sock, addr, len);
   if (error != 0) {
     errno = error;
     return -1;
   }
 
-  SocketNode* sock = new TcpNode(stream_mount_.get(), new_sock);
+  SocketNode* sock = new TcpNode(stream_fs_.get(), new_sock);
 
   // The SocketNode now holds a reference to the new socket
   // so we release ours.
   ppapi_->ReleaseResource(new_sock);
   error = sock->Init(O_RDWR);
   if (error != 0) {
     errno = error;
     return -1;
   }
 
   ScopedNode node(sock);
-  ScopedKernelHandle new_handle(new KernelHandle(stream_mount_, node));
+  ScopedKernelHandle new_handle(new KernelHandle(stream_fs_, node));
   error = new_handle->Init(O_RDWR);
   if (error != 0) {
     errno = error;
     return -1;
   }
 
   return AllocateFD(new_handle);
 }
 
 int KernelProxy::bind(int fd, const struct sockaddr* addr, socklen_t len) {
@@ skipping 30 matching lines @@
 
   error = handle->Connect(addr, len);
   if (error != 0) {
     errno = error;
     return -1;
   }
 
   return 0;
 }
 
-void KernelProxy::freeaddrinfo(struct addrinfo *res) {
+void KernelProxy::freeaddrinfo(struct addrinfo* res) {
   return host_resolver_.freeaddrinfo(res);
 }
 
-int KernelProxy::getaddrinfo(const char* node, const char* service,
+int KernelProxy::getaddrinfo(const char* node,
+                             const char* service,
                              const struct addrinfo* hints,
                              struct addrinfo** res) {
   return host_resolver_.getaddrinfo(node, service, hints, res);
 }
 
 struct hostent* KernelProxy::gethostbyname(const char* name) {
   return host_resolver_.gethostbyname(name);
 }
 
 int KernelProxy::getpeername(int fd, struct sockaddr* addr, socklen_t* len) {
@@ skipping 64 matching lines @@
 
   Error err = handle->socket_node()->Listen(backlog);
   if (err != 0) {
     errno = err;
     return -1;
   }
 
   return 0;
 }
 
-ssize_t KernelProxy::recv(int fd,
-                          void* buf,
-                          size_t len,
-                          int flags) {
+ssize_t KernelProxy::recv(int fd, void* buf, size_t len, int flags) {
   if (NULL == buf) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
@@ skipping 36 matching lines @@
   error = handle->RecvFrom(buf, len, flags, addr, addrlen, &out_len);
   if (error != 0) {
     errno = error;
     return -1;
   }
 
   return static_cast<ssize_t>(out_len);
 }
 
 ssize_t KernelProxy::recvmsg(int fd, struct msghdr* msg, int flags) {
-  if (NULL == msg ) {
+  if (NULL == msg) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
     return -1;
 
   errno = EOPNOTSUPP;
   return -1;
@@ skipping 125 matching lines @@
   }
 
   if (type & SOCK_NONBLOCK) {
     open_flags |= O_NONBLOCK;
     type &= ~SOCK_NONBLOCK;
   }
 
   SocketNode* sock = NULL;
   switch (type) {
     case SOCK_DGRAM:
-      sock = new UdpNode(stream_mount_.get());
+      sock = new UdpNode(stream_fs_.get());
       break;
 
     case SOCK_STREAM:
-      sock = new TcpNode(stream_mount_.get());
+      sock = new TcpNode(stream_fs_.get());
       break;
 
     case SOCK_SEQPACKET:
     case SOCK_RDM:
     case SOCK_RAW:
       errno = EPROTONOSUPPORT;
       return -1;
 
     default:
       errno = EINVAL;
       return -1;
   }
 
   ScopedNode node(sock);
   Error rtn = sock->Init(O_RDWR);
   if (rtn != 0) {
     errno = rtn;
     return -1;
   }
 
-  ScopedKernelHandle handle(new KernelHandle(stream_mount_, node));
+  ScopedKernelHandle handle(new KernelHandle(stream_fs_, node));
   rtn = handle->Init(open_flags);
   if (rtn != 0) {
     errno = rtn;
     return -1;
   }
 
   return AllocateFD(handle);
 }
 
 int KernelProxy::socketpair(int domain, int type, int protocol, int* sv) {
@@ skipping 31 matching lines @@
     errno = ENOTSOCK;
     return -1;
   }
 
   return 0;
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 }  // namespace_nacl_io