[NaCl SDK] nacl_io: big refactor to return error value (errno).

native_client_sdk/src/libraries/nacl_io/mount_node.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/mount_node.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <string>
 
 #include "nacl_io/kernel_wrap_real.h"
 #include "nacl_io/mount.h"
 #include "nacl_io/osmman.h"
 #include "utils/auto_lock.h"
 
 static const int USR_ID = 1001;
 static const int GRP_ID = 1002;
 
-MountNode::MountNode(Mount* mount)
-    : mount_(mount) {
+MountNode::MountNode(Mount* mount) : mount_(mount) {
   memset(&stat_, 0, sizeof(stat_));
   stat_.st_gid = GRP_ID;
   stat_.st_uid = USR_ID;
 
   // Mount should normally never be NULL, but may be null in tests.
   // If NULL, at least set the inode to a valid (nonzero) value.
   if (mount_)
     mount_->OnNodeCreated(this);
   else
     stat_.st_ino = 1;
 }
 
-MountNode::~MountNode() {
-}
+MountNode::~MountNode() {}
 
-bool MountNode::Init(int perm) {
+Error MountNode::Init(int perm) {
   stat_.st_mode |= perm;
-  return true;
+  return 0;
 }
 
 void MountNode::Destroy() {
   if (mount_) {
     mount_->OnNodeDestroyed(this);
   }
 }
 
-int MountNode::FSync() {
-  return 0;
+Error MountNode::FSync() { return 0; }
+
+Error MountNode::FTruncate(off_t length) {
+  return EINVAL;
 }
 
-int MountNode::FTruncate(off_t length) {
-  errno = EINVAL;
-  return -1;
+Error MountNode::GetDents(size_t offs,
+                          struct dirent* pdir,
+                          size_t count,
+                          int* out_bytes) {
+  *out_bytes = 0;
+  return ENOTDIR;
 }
 
-int MountNode::GetDents(size_t offs, struct dirent* pdir, size_t count) {
-  errno = ENOTDIR;
-  return -1;
-}
-
-int MountNode::GetStat(struct stat* pstat) {
+Error MountNode::GetStat(struct stat* pstat) {
   AutoLock lock(&lock_);
   memcpy(pstat, &stat_, sizeof(stat_));
   return 0;
 }
 
-int MountNode::Ioctl(int request, char* arg) {
-  errno = EINVAL;
-  return -1;
+Error MountNode::Ioctl(int request, char* arg) {
+  return EINVAL;
 }
 
-int MountNode::Read(size_t offs, void* buf, size_t count) {
-  errno = EINVAL;
-  return -1;
+Error MountNode::Read(size_t offs, void* buf, size_t count, int* out_bytes) {
+  *out_bytes = 0;
+  return EINVAL;
 }
 
-int MountNode::Write(size_t offs, const void* buf, size_t count) {
-  errno = EINVAL;
-  return -1;
+Error MountNode::Write(size_t offs,
+                       const void* buf,
+                       size_t count,
+                       int* out_bytes) {
+  *out_bytes = 0;
+  return EINVAL;
 }
 
-void* MountNode::MMap(void* addr, size_t length, int prot, int flags,
-                      size_t offset) {
+Error MountNode::MMap(void* addr,
+                      size_t length,
+                      int prot,
+                      int flags,
+                      size_t offset,
+                      void** out_addr) {
+  *out_addr = NULL;
+
   // Never allow mmap'ing PROT_EXEC. The passthrough node supports this, but we
   // don't. Fortunately, glibc will fallback if this fails, so dlopen will
   // continue to work.
-  if (prot & PROT_EXEC) {
-    errno = EPERM;
-    return MAP_FAILED;
-  }
+  if (prot & PROT_EXEC)
+    return EPERM;
 
   // This default mmap support is just enough to make dlopen work.
   // This implementation just reads from the mount into the mmap'd memory area.
   void* new_addr = addr;
-  int err = _real_mmap(&new_addr, length, prot | PROT_WRITE, flags |
-                       MAP_ANONYMOUS, -1, 0);
+  int mmap_error = _real_mmap(
+      &new_addr, length, prot | PROT_WRITE, flags | MAP_ANONYMOUS, -1, 0);
   if (new_addr == MAP_FAILED) {
     _real_munmap(new_addr, length);
-    errno = err;
-    return MAP_FAILED;
+    return mmap_error;
   }
 
-  ssize_t cnt = Read(offset, new_addr, length);
-  if (cnt == -1) {
+  ssize_t bytes_read;
+  Error read_error = Read(offset, new_addr, length, &bytes_read);
+  if (read_error) {
     _real_munmap(new_addr, length);
-    errno = ENOSYS;
-    return MAP_FAILED;
+    return read_error;
   }
 
-  return new_addr;
+  *out_addr = new_addr;
+  return 0;
 }
 
-int MountNode::GetLinks() {
-  return stat_.st_nlink;
+int MountNode::GetLinks() { return stat_.st_nlink; }
+
+int MountNode::GetMode() { return stat_.st_mode & ~S_IFMT; }
+
+Error MountNode::GetSize(size_t* out_size) {
+  *out_size = stat_.st_size;
+  return 0;
 }
 
-int MountNode::GetMode() {
-  return stat_.st_mode & ~S_IFMT;
+int MountNode::GetType() { return stat_.st_mode & S_IFMT; }
+
+bool MountNode::IsaDir() { return (stat_.st_mode & S_IFDIR) != 0; }
+
+bool MountNode::IsaFile() { return (stat_.st_mode & S_IFREG) != 0; }
+
+bool MountNode::IsaTTY() { return (stat_.st_mode & S_IFCHR) != 0; }
+
+Error MountNode::AddChild(const std::string& name, MountNode* node) {
+  return ENOTDIR;
 }
 
-size_t MountNode::GetSize() {
-  return stat_.st_size;
+Error MountNode::RemoveChild(const std::string& name) {
+  return ENOTDIR;
 }
 
-int MountNode::GetType() {
-  return stat_.st_mode & S_IFMT;
-}
-
-bool MountNode::IsaDir() {
-  return (stat_.st_mode & S_IFDIR) != 0;
-}
-
-bool MountNode::IsaFile() {
-  return (stat_.st_mode & S_IFREG) != 0;
-}
-
-bool MountNode::IsaTTY() {
-  return (stat_.st_mode & S_IFCHR) != 0;
-}
-
-
-int MountNode:: AddChild(const std::string& name, MountNode* node) {
-  errno = ENOTDIR;
-  return -1;
-}
-
-int MountNode::RemoveChild(const std::string& name) {
-  errno = ENOTDIR;
-  return -1;
-}
-
-MountNode* MountNode::FindChild(const std::string& name) {
-  errno = ENOTDIR;
-  return NULL;
+Error MountNode::FindChild(const std::string& name, MountNode** out_node) {
+  *out_node = NULL;
+  return ENOTDIR;
 }
 
 int MountNode::ChildCount() {
-  errno = ENOTDIR;
-  return -1;
+  return 0;

[noelallen1, 2013/06/07 21:48:43]

Not ENOTDIR?

[binji, 2013/06/07 23:23:11]

No, I figure that returning an error from ChildCount is more trouble than its
worth. It's not called directly, and anything that actually cares about the file
type will check it and set its own error.

 }
 
 void MountNode::Link() {
   Acquire();
   stat_.st_nlink++;
 }
 
 void MountNode::Unlink() {
   stat_.st_nlink--;
   Release();
 }