native_client_sdk/src/libraries/nacl_io/memfs/mem_fs.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "nacl_io/memfs/mem_fs.h"
   6
   7 #include <errno.h>
   8 #include <fcntl.h>
   9
  10 #include <string>
  11
  12 #include "nacl_io/dir_node.h"
  13 #include "nacl_io/filesystem.h"
  14 #include "nacl_io/memfs/mem_fs_node.h"
  15 #include "nacl_io/node.h"
  16 #include "nacl_io/osstat.h"
  17 #include "nacl_io/osunistd.h"
  18 #include "nacl_io/path.h"
  19 #include "sdk_util/auto_lock.h"
  20 #include "sdk_util/ref_object.h"
  21
  22 namespace nacl_io {
  23
  24 MemFs::MemFs() : root_(NULL) {
  25 }
  26
  27 Error MemFs::Init(const FsInitArgs& args) {
  28   Error error = Filesystem::Init(args);
  29   if (error)
  30     return error;
  31
  32   root_.reset(new DirNode(this, S_IRALL | S_IWALL | S_IXALL));
  33   error = root_->Init(0);
  34   if (error) {
  35     root_.reset(NULL);
  36     return error;
  37   }
  38   return 0;
  39 }
  40
  41 Error MemFs::FindNode(const Path& path, int type, ScopedNode* out_node) {
  42   out_node->reset(NULL);
  43   ScopedNode node = root_;
  44
  45   // If there is no root there, we have an error.
  46   if (node == NULL)
  47     return ENOTDIR;
  48
  49   // We are expecting an "absolute" path from this mount point.
  50   if (!path.IsAbsolute())
  51     return EINVAL;
  52
  53   // Starting at the root, traverse the path parts.
  54   for (size_t index = 1; node && index < path.Size(); index++) {
  55     // If not a directory, then we have an error so return.
  56     if (!node->IsaDir())
  57       return ENOTDIR;
  58
  59     // Find the child node
  60     Error error = node->FindChild(path.Part(index), &node);
  61     if (error)
  62       return error;
  63   }
  64
  65   // If a directory is expected, but it's not a directory, then fail.
  66   if ((type & S_IFDIR) && !node->IsaDir())
  67     return ENOTDIR;
  68
  69   // If a file is expected, but it's not a file, then fail.
  70   if ((type & S_IFREG) && node->IsaDir())
  71     return EISDIR;
  72
  73   // We now have a valid object of the expected type, so return it.
  74   *out_node = node;
  75   return 0;
  76 }
  77
  78 Error MemFs::OpenWithMode(const Path& path, int open_flags, mode_t mode,
  79                           ScopedNode* out_node) {
  80   out_node->reset(NULL);
  81   ScopedNode node;
  82
  83   Error error = FindNode(path, 0, &node);
  84   if (error) {
  85     // If the node does not exist and we can't create it, fail
  86     if ((open_flags & O_CREAT) == 0)
  87       return ENOENT;
  88
  89     // Now first find the parent directory to see if we can add it
  90     ScopedNode parent;
  91     error = FindNode(path.Parent(), S_IFDIR, &parent);
  92     if (error)
  93       return error;
  94
  95     node.reset(new MemFsNode(this));
  96     error = node->Init(open_flags);
  97     if (error)
  98       return error;
  99     node->SetMode(mode);
 100
 101     error = parent->AddChild(path.Basename(), node);
 102     if (error)
 103       return error;
 104
 105   } else {
 106     // Opening an existing file.
 107
 108     // If we were expected to create it exclusively, fail
 109     if (open_flags & O_EXCL)
 110       return EEXIST;
 111
 112     if (open_flags & O_TRUNC)
 113       node->FTruncate(0);
 114   }
 115
 116   *out_node = node;
 117   return 0;
 118 }
 119
 120 Error MemFs::Mkdir(const Path& path, int mode) {
 121   // The root of the filesystem is already created by the filesystem
 122   if (path.Size() == 1)
 123     return EEXIST;
 124
 125   ScopedNode parent;
 126   int error = FindNode(path.Parent(), S_IFDIR, &parent);
 127   if (error)
 128     return error;
 129
 130   ScopedNode node;
 131   error = parent->FindChild(path.Basename(), &node);
 132   if (!error)
 133     return EEXIST;
 134
 135   if (error != ENOENT)
 136     return error;
 137
 138   // Allocate a node, with a RefCount of 1.  If added to the parent
 139   // it will get ref counted again.  In either case, release the
 140   // recount we have on exit.
 141   node.reset(new DirNode(this, mode));
 142   error = node->Init(0);
 143   if (error)
 144     return error;
 145
 146   return parent->AddChild(path.Basename(), node);
 147 }
 148
 149 Error MemFs::Unlink(const Path& path) {
 150   return RemoveInternal(path, REMOVE_FILE);
 151 }
 152
 153 Error MemFs::Rmdir(const Path& path) {
 154   return RemoveInternal(path, REMOVE_DIR);
 155 }
 156
 157 Error MemFs::Remove(const Path& path) {
 158   return RemoveInternal(path, REMOVE_ALL);
 159 }
 160
 161 Error MemFs::Rename(const Path& src_path, const Path& target_path) {
 162   ScopedNode src_node;
 163   ScopedNode src_parent;
 164   ScopedNode target_node;
 165   ScopedNode target_parent;
 166   int error = FindNode(src_path, 0, &src_node);
 167   if (error)
 168     return error;
 169
 170   // The source must exist
 171   error = FindNode(src_path.Parent(), S_IFDIR, &src_parent);
 172   if (error)
 173     return error;
 174
 175   // The parent of the target must exist
 176   error = FindNode(target_path.Parent(), 0, &target_parent);
 177   if (error)
 178     return error;
 179
 180   std::string target_name = target_path.Basename();
 181
 182   // The target itself need not exist but if it does there are
 183   // certain restrictions
 184   error = FindNode(target_path, 0, &target_node);
 185   bool replacing_target = error == 0;
 186   if (replacing_target) {
 187     if (target_node->IsaDir()) {
 188       // If the target is a direcotry it must be empty
 189       if (target_node->ChildCount()) {
 190         return ENOTEMPTY;
 191       }
 192
 193       if (src_node->IsaDir()) {
 194         // Replacing an existing directory.
 195         RemoveInternal(target_path, REMOVE_ALL);
 196       } else {
 197         // Renaming into an existing directory.
 198         target_name = src_path.Basename();
 199         target_parent = target_node;
 200       }
 201     } else {
 202       if (src_node->IsaDir())
 203         // Can't replace a file with a direcotory
 204         return EISDIR;
 205
 206       // Replacing an existing file.
 207       target_parent->RemoveChild(target_path.Basename());
 208     }
 209   }
 210
 211   // Perform that actual rename. Simply re-parent the original source node
 212   // onto its new parent node.
 213   error = src_parent->RemoveChild(src_path.Basename());
 214   if (error)
 215     return error;
 216
 217   error = target_parent->AddChild(target_name, src_node);
 218   if (error) {
 219     // Re-parent the old target_node if we failed to add the new one.
 220     if (replacing_target)
 221       target_parent->AddChild(target_path.Basename(), target_node);
 222     // Re-parent the src_node
 223     target_parent->AddChild(target_path.Basename(), src_node);
 224     return error;
 225   }
 226
 227   return 0;
 228 }
 229
 230 Error MemFs::RemoveInternal(const Path& path, int remove_type) {
 231   bool dir_only = remove_type == REMOVE_DIR;
 232   bool file_only = remove_type == REMOVE_FILE;
 233   bool remove_dir = (remove_type & REMOVE_DIR) != 0;
 234
 235   if (dir_only) {
 236     // The root of the filesystem is already created by the filesystem
 237     if (path.Size() == 1)
 238       return EEXIST;
 239   }
 240
 241   ScopedNode parent;
 242   int error = FindNode(path.Parent(), S_IFDIR, &parent);
 243   if (error)
 244     return error;
 245
 246   // Verify we find a child which is a directory.
 247   ScopedNode child;
 248   error = parent->FindChild(path.Basename(), &child);
 249   if (error)
 250     return error;
 251
 252   if (dir_only && !child->IsaDir())
 253     return ENOTDIR;
 254
 255   if (file_only && child->IsaDir())
 256     return EISDIR;
 257
 258   if (remove_dir && child->ChildCount() > 0)
 259     return ENOTEMPTY;
 260
 261   return parent->RemoveChild(path.Basename());
 262 }
 263
 264 }  // namespace nacl_io