[NaCl SDK] Add some more logging to nacl_io.

native_client_sdk/src/libraries/nacl_io/fusefs/fuse_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.
 
 #include "nacl_io/fusefs/fuse_fs.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
 
 #include <algorithm>
 
 #include "nacl_io/getdents_helper.h"
 #include "nacl_io/kernel_handle.h"
+#include "nacl_io/log.h"
 #include "sdk_util/macros.h"
 
 namespace nacl_io {
 
 namespace {
 
 struct FillDirInfo {
   FillDirInfo(GetDentsHelper* getdents, size_t num_bytes)
       : getdents(getdents), num_bytes(num_bytes), wrote_offset(false) {}
 
   GetDentsHelper* getdents;
   size_t num_bytes;
   bool wrote_offset;
 };
 
 }  // namespace
 
 FuseFs::FuseFs() : fuse_ops_(NULL), fuse_user_data_(NULL) {
 }
 
 Error FuseFs::Init(const FsInitArgs& args) {
   Error error = Filesystem::Init(args);
   if (error)
     return error;
 
   fuse_ops_ = args.fuse_ops;
-  if (fuse_ops_ == NULL)
+  if (fuse_ops_ == NULL) {
+    LOG_ERROR("fuse_ops_ is NULL.");
     return EINVAL;
+  }
 
   if (fuse_ops_->init) {
     struct fuse_conn_info info;
     fuse_user_data_ = fuse_ops_->init(&info);
   }
 
   return 0;
 }
 
 void FuseFs::Destroy() {
   if (fuse_ops_ && fuse_ops_->destroy)
     fuse_ops_->destroy(fuse_user_data_);
 }
 
 Error FuseFs::Access(const Path& path, int a_mode) {
-  if (!fuse_ops_->access)
+  if (!fuse_ops_->access) {
+    LOG_TRACE("fuse_ops_->access is NULL.");
     return ENOSYS;
+  }
 
   int result = fuse_ops_->access(path.Join().c_str(), a_mode);
   if (result < 0)
     return -result;
 
   return 0;
 }
 
 Error FuseFs::Open(const Path& path, int open_flags, ScopedNode* out_node) {
   std::string path_str = path.Join();
@@ skipping 10 matching lines @@
     mode_t mode = S_IRALL | S_IWALL;
     if (fuse_ops_->create) {
       result = fuse_ops_->create(path_cstr, mode, &fi);
       if (result < 0)
         return -result;
     } else if (fuse_ops_->mknod) {
       result = fuse_ops_->mknod(path_cstr, mode, dev_);
       if (result < 0)
         return -result;
     } else {
+      LOG_TRACE("fuse_ops_->create and fuse_ops_->mknod are NULL.");
       return ENOSYS;
     }
   } else {
     // First determine if this is a regular file or a directory.
     if (fuse_ops_->getattr) {
       struct stat statbuf;
       result = fuse_ops_->getattr(path_cstr, &statbuf);
       if (result < 0)
         return -result;
 
       if ((statbuf.st_mode & S_IFMT) == S_IFDIR) {
         // This is a directory. Don't try to open, just create a new node with
         // this path.
         ScopedNode node(new DirFuseFsNode(this, fuse_ops_, fi, path_cstr));
         Error error = node->Init(open_flags);
         if (error)
           return error;
 
         *out_node = node;
         return 0;
       }
     }
 
     // Existing file.
     if (open_flags & O_TRUNC) {
       // According to the FUSE docs, O_TRUNC does two calls: first truncate()
       // then open().
-      if (!fuse_ops_->truncate)
+      if (!fuse_ops_->truncate) {
+        LOG_TRACE("fuse_ops_->truncate is NULL.");
         return ENOSYS;
+      }
       result = fuse_ops_->truncate(path_cstr, 0);
       if (result < 0)
         return -result;
     }
 
-    if (!fuse_ops_->open)
+    if (!fuse_ops_->open) {
+      LOG_TRACE("fuse_ops_->open is NULL.");
       return ENOSYS;
+    }
     result = fuse_ops_->open(path_cstr, &fi);
     if (result < 0)
       return -result;
   }
 
   ScopedNode node(new FileFuseFsNode(this, fuse_ops_, fi, path_cstr));
   Error error = node->Init(open_flags);
   if (error)
     return error;
 
   *out_node = node;
   return 0;
 }
 
 Error FuseFs::Unlink(const Path& path) {
-  if (!fuse_ops_->unlink)
+  if (!fuse_ops_->unlink) {
+    LOG_TRACE("fuse_ops_->unlink is NULL.");
     return ENOSYS;
+  }
 
   int result = fuse_ops_->unlink(path.Join().c_str());
   if (result < 0)
     return -result;
 
   return 0;
 }
 
 Error FuseFs::Mkdir(const Path& path, int perm) {
-  if (!fuse_ops_->mkdir)
+  if (!fuse_ops_->mkdir) {
+    LOG_TRACE("fuse_ops_->mkdir is NULL.");
     return ENOSYS;
+  }
 
   int result = fuse_ops_->mkdir(path.Join().c_str(), perm);
   if (result < 0)
     return -result;
 
   return 0;
 }
 
 Error FuseFs::Rmdir(const Path& path) {
-  if (!fuse_ops_->rmdir)
+  if (!fuse_ops_->rmdir) {
+    LOG_TRACE("fuse_ops_->rmdir is NULL.");
     return ENOSYS;
+  }
 
   int result = fuse_ops_->rmdir(path.Join().c_str());
   if (result < 0)
     return -result;
 
   return 0;
 }
 
 Error FuseFs::Remove(const Path& path) {
   ScopedNode node;
   Error error = Open(path, O_RDONLY, &node);
   if (error)
     return error;
 
   struct stat statbuf;
   error = node->GetStat(&statbuf);
   if (error)
     return error;
 
   node.reset();
 
   if ((statbuf.st_mode & S_IFMT) == S_IFDIR) {
     return Rmdir(path);
   } else {
     return Unlink(path);
   }
 }
 
 Error FuseFs::Rename(const Path& path, const Path& newpath) {
-  if (!fuse_ops_->rename)
+  if (!fuse_ops_->rename) {
+    LOG_TRACE("fuse_ops_->rename is NULL.");
     return ENOSYS;
+  }
 
   int result = fuse_ops_->rename(path.Join().c_str(), newpath.Join().c_str());
   if (result < 0)
     return -result;
 
   return 0;
 }
 
 FuseFsNode::FuseFsNode(Filesystem* filesystem,
                        struct fuse_operations* fuse_ops,
@@ skipping 17 matching lines @@
   int result;
   if (fuse_ops_->fgetattr) {
     result = fuse_ops_->fgetattr(path_.c_str(), stat, &info_);
     if (result < 0)
       return -result;
   } else if (fuse_ops_->getattr) {
     result = fuse_ops_->getattr(path_.c_str(), stat);
     if (result < 0)
       return -result;
   } else {
+    LOG_TRACE("fuse_ops_->fgetattr and fuse_ops_->getattr are NULL.");
     return ENOSYS;
   }
 
   // Also update the cached stat values.
   stat_ = *stat;
   return 0;
 }
 
 Error FuseFsNode::VIoctl(int request, va_list args) {
-  // TODO(binji): implement
+  LOG_ERROR("Ioctl not implemented for fusefs.");
   return ENOSYS;
 }
 
 Error FuseFsNode::Tcflush(int queue_selector) {
-  // TODO(binji): use ioctl for this?
+  LOG_ERROR("Tcflush not implemented for fusefs.");
   return ENOSYS;
 }
 
 Error FuseFsNode::Tcgetattr(struct termios* termios_p) {
-  // TODO(binji): use ioctl for this?
+  LOG_ERROR("Tcgetattr not implemented for fusefs.");
   return ENOSYS;
 }
 
 Error FuseFsNode::Tcsetattr(int optional_actions,
                             const struct termios* termios_p) {
-  // TODO(binji): use ioctl for this?
+  LOG_ERROR("Tcsetattr not implemented for fusefs.");
   return ENOSYS;
 }
 
 Error FuseFsNode::GetSize(off_t* out_size) {
   struct stat statbuf;
   Error error = GetStat(&statbuf);
   if (error)
     return error;
 
   *out_size = stat_.st_size;
   return 0;
 }
 
 FileFuseFsNode::FileFuseFsNode(Filesystem* filesystem,
                                struct fuse_operations* fuse_ops,
                                struct fuse_file_info& info,
                                const std::string& path)
     : FuseFsNode(filesystem, fuse_ops, info, path) {
 }
 
 void FileFuseFsNode::Destroy() {
   if (!fuse_ops_->release)
     return;
   fuse_ops_->release(path_.c_str(), &info_);
 }
 
 Error FileFuseFsNode::FSync() {
-  if (!fuse_ops_->fsync)
+  if (!fuse_ops_->fsync) {
+    LOG_ERROR("fuse_ops_->fsync is NULL.");
     return ENOSYS;
+  }
 
   int datasync = 0;
   int result = fuse_ops_->fsync(path_.c_str(), datasync, &info_);
   if (result < 0)
     return -result;
   return 0;
 }
 
 Error FileFuseFsNode::FTruncate(off_t length) {
-  if (!fuse_ops_->ftruncate)
+  if (!fuse_ops_->ftruncate) {
+    LOG_ERROR("fuse_ops_->ftruncate is NULL.");
     return ENOSYS;
+  }
 
   int result = fuse_ops_->ftruncate(path_.c_str(), length, &info_);
   if (result < 0)
     return -result;
   return 0;
 }
 
 Error FileFuseFsNode::Read(const HandleAttr& attr,
                            void* buf,
                            size_t count,
                            int* out_bytes) {
-  if (!fuse_ops_->read)
+  if (!fuse_ops_->read) {
+    LOG_ERROR("fuse_ops_->read is NULL.");
     return ENOSYS;
+  }
 
   char* cbuf = static_cast<char*>(buf);
 
   int result = fuse_ops_->read(path_.c_str(), cbuf, count, attr.offs, &info_);
   if (result < 0)
     return -result;
 
   // Fuse docs say that a read() call will always completely fill the buffer
   // (padding with zeroes) unless the direct_io filesystem flag is set.
   // TODO(binji): support the direct_io flag
   if (static_cast<size_t>(result) < count)
     memset(&cbuf[result], 0, count - result);
 
   *out_bytes = count;
   return 0;
 }
 
 Error FileFuseFsNode::Write(const HandleAttr& attr,
                             const void* buf,
                             size_t count,
                             int* out_bytes) {
-  if (!fuse_ops_->write)
+  if (!fuse_ops_->write) {
+    LOG_ERROR("fuse_ops_->write is NULL.");
     return ENOSYS;
+  }
 
   int result = fuse_ops_->write(
       path_.c_str(), static_cast<const char*>(buf), count, attr.offs, &info_);
   if (result < 0)
     return -result;
 
   // Fuse docs say that a write() call will always write the entire buffer
   // unless the direct_io filesystem flag is set.
   // TODO(binji): What should we do if the user breaks this contract? Warn?
   // TODO(binji): support the direct_io flag
   *out_bytes = result;
   return 0;
 }
 
 DirFuseFsNode::DirFuseFsNode(Filesystem* filesystem,
                              struct fuse_operations* fuse_ops,
                              struct fuse_file_info& info,
                              const std::string& path)
     : FuseFsNode(filesystem, fuse_ops, info, path) {
 }
 
 void DirFuseFsNode::Destroy() {
   if (!fuse_ops_->releasedir)
     return;
   fuse_ops_->releasedir(path_.c_str(), &info_);
 }
 
 Error DirFuseFsNode::FSync() {
-  if (!fuse_ops_->fsyncdir)
+  if (!fuse_ops_->fsyncdir) {
+    LOG_ERROR("fuse_ops_->fsyncdir is NULL.");
     return ENOSYS;
+  }
 
   int datasync = 0;
   int result = fuse_ops_->fsyncdir(path_.c_str(), datasync, &info_);
   if (result < 0)
     return -result;
   return 0;
 }
 
 Error DirFuseFsNode::GetDents(size_t offs,
                               struct dirent* pdir,
                               size_t count,
                               int* out_bytes) {
-  if (!fuse_ops_->readdir)
+  if (!fuse_ops_->readdir) {
+    LOG_ERROR("fuse_ops_->readdir is NULL.");
     return ENOSYS;
+  }
 
   bool opened_dir = false;
   int result;
 
   // Opendir is not necessary, only readdir. Call it anyway, if it is defined.
   if (fuse_ops_->opendir) {
     result = fuse_ops_->opendir(path_.c_str(), &info_);
     if (result < 0)
       return -result;
 
@@ skipping 57 matching lines @@
   } else {
     fill_info->getdents->AddDirent(ino, name, strlen(name));
     fill_info->num_bytes -= sizeof(dirent);
     // According to the docs, we can never return 1 (buffer full) when the
     // offset is zero (the user is probably ignoring the result anyway).
     return 0;
   }
 }
 
 }  // namespace nacl_io