[NaCl SDK] Add some more logging to nacl_io.

native_client_sdk/src/libraries/nacl_io/jsfs/js_fs_node.cc

 // Copyright 2014 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/jsfs/js_fs_node.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <string.h>
 
 #include "nacl_io/jsfs/js_fs.h"
 #include "nacl_io/kernel_handle.h"
 #include "nacl_io/log.h"
 #include "nacl_io/osdirent.h"
 #include "nacl_io/pepper_interface.h"
 #include "sdk_util/macros.h"
 
-#define TRACE(format, ...) \
-  LOG_TRACE("%s:%d: " format, __FILE__, __LINE__, ##__VA_ARGS__)
-#define ERROR(format, ...) \
-  LOG_ERROR("%s:%d: " format, __FILE__, __LINE__, ##__VA_ARGS__)
-
-
 namespace nacl_io {
 
 JsFsNode::JsFsNode(Filesystem* filesystem, int32_t fd)
     : Node(filesystem),
       ppapi_(filesystem->ppapi()),
       array_iface_(ppapi_->GetVarArrayInterface()),
       buffer_iface_(ppapi_->GetVarArrayBufferInterface()),
       var_iface_(ppapi_->GetVarInterface()),
       fd_(fd) {
 }
@@ skipping 29 matching lines @@
   // GetStat cached the mode in stat_.st_mode. Forward to Node::CanOpen,
   // which will check this mode against open_flags.
   return Node::CanOpen(open_flags);
 }
 
 Error JsFsNode::GetStat(struct stat* stat) {
   AUTO_LOCK(node_lock_);
 
   ScopedVar response(ppapi_);
   if (!SendRequestAndWait(&response, "%s%d", "cmd", "fstat", "fildes", fd_)) {
-    ERROR("Failed to send request.");
+    LOG_ERROR("Failed to send request.");
     return EINVAL;
   }
 
   // TODO(binji): find out the size of bionic stat fields.
 #if defined(__native_client__) && !defined(__BIONIC__)
 #if defined(__GLIBC__)
 const char* format = "%d%lld%d%d%d%d%lld%lld%lld%lld%lld%lld%lld";
 #else
 const char* format = "%d%lld%d%d%d%d%lld%lld%d%d%lld%lld%lld";
 #endif
@@ skipping 34 matching lines @@
                        "st_blksize", &stat->st_blksize,
                        "st_blocks", &stat->st_blocks,
                        "st_atime", &stat->st_atime,
                        "st_mtime", &stat->st_mtime,
                        "st_ctime", &stat->st_ctime);
 
   if (result >= 1 && error)
     return error;
 
   if (result != 13) {
-    ERROR(
+    LOG_ERROR(
         "Expected \"st_*\" and \"error\" fields in response (should be 13 "
         "total).");
     return EINVAL;
   }
 
   stat->st_dev = filesystem()->dev();
 
   return 0;
 }
 
 Error JsFsNode::GetSize(off_t* out_size) {
   *out_size = 0;
 
   struct stat statbuf;
   Error error = GetStat(&statbuf);
   if (error)
     return error;
 
   *out_size = stat_.st_size;
   return 0;
 }
 
 Error JsFsNode::FSync() {
   AUTO_LOCK(node_lock_);
 
   ScopedVar response(ppapi_);
   if (!SendRequestAndWait(&response, "%s%d", "cmd", "fsync", "fildes", fd_)) {
-    ERROR("Failed to send request.");
+    LOG_ERROR("Failed to send request.");
     return EINVAL;
   }
 
   return filesystem()->ErrorFromResponse(response);
 }
 
 Error JsFsNode::FTruncate(off_t length) {
   AUTO_LOCK(node_lock_);
 
   ScopedVar response(ppapi_);
   if (!SendRequestAndWait(&response,
       "%s%d%lld", "cmd", "ftruncate", "fildes", fd_, "length", length)) {
-    ERROR("Failed to send request.");
+    LOG_ERROR("Failed to send request.");
     return EINVAL;
   }
 
   return filesystem()->ErrorFromResponse(response);
 }
 
 Error JsFsNode::Read(const HandleAttr& attr,
                      void* buf,
                      size_t count,
                      int* out_bytes) {
   AUTO_LOCK(node_lock_);
 
   *out_bytes = 0;
 
   ScopedVar response(ppapi_);
   if (!SendRequestAndWait(&response, "%s%d%u%lld",
                           "cmd", "pread",
                           "fildes", fd_,
                           "nbyte", count,
                           "offset", attr.offs)) {
-    ERROR("Failed to send request.");
+    LOG_ERROR("Failed to send request.");
     return EINVAL;
   }
 
   int32_t error;
 
   PP_Var buf_var;
   int result =
       ScanVar(response.pp_var(), "%d%p", "error", &error, "buf", &buf_var);
   ScopedVar scoped_buf_var(ppapi_, buf_var);
 
   if (result >= 1 && error)
     return error;
 
   if (result != 2) {
-    ERROR("Expected \"error\" and \"buf\" fields in response.");
+    LOG_ERROR("Expected \"error\" and \"buf\" fields in response.");
     return EINVAL;
   }
 
   if (buf_var.type != PP_VARTYPE_ARRAY_BUFFER) {
-    ERROR("Expected \"buf\" to be an ArrayBuffer.");
+    LOG_ERROR("Expected \"buf\" to be an ArrayBuffer.");
     return EINVAL;
   }
 
   uint32_t src_buf_len;
   if (!buffer_iface_->ByteLength(buf_var, &src_buf_len)) {
-    ERROR("Unable to get byteLength of \"buf\".");
+    LOG_ERROR("Unable to get byteLength of \"buf\".");
     return EINVAL;
   }
 
   if (src_buf_len > count)
     src_buf_len = count;
 
   void* src_buf = buffer_iface_->Map(buf_var);
   if (src_buf == NULL) {
-    ERROR("Unable to map \"buf\".");
+    LOG_ERROR("Unable to map \"buf\".");
     return EINVAL;
   }
 
   memcpy(buf, src_buf, src_buf_len);
   *out_bytes = src_buf_len;
 
   buffer_iface_->Unmap(buf_var);
 
   return 0;
 }
 
 Error JsFsNode::Write(const HandleAttr& attr,
                       const void* buf,
                       size_t count,
                       int* out_bytes) {
   AUTO_LOCK(node_lock_);
 
   *out_bytes = 0;
 
   PP_Var buf_var = buffer_iface_->Create(count);
   ScopedVar scoped_buf_var(ppapi_, buf_var);
 
   if (buf_var.type != PP_VARTYPE_ARRAY_BUFFER) {
-    ERROR("Unable to create \"buf\" var.");
+    LOG_ERROR("Unable to create \"buf\" var.");
     return EINVAL;
   }
 
   void* dst_buf = buffer_iface_->Map(buf_var);
   if (dst_buf == NULL) {
-    ERROR("Unable to map \"buf\".");
+    LOG_ERROR("Unable to map \"buf\".");
     return EINVAL;
   }
 
   memcpy(dst_buf, buf, count);
 
   buffer_iface_->Unmap(buf_var);
 
   ScopedVar response(ppapi_);
   if (!SendRequestAndWait(&response, "%s%d%p%u%lld",
                           "cmd", "pwrite",
                           "fildes", fd_,
                           "buf", &buf_var,
                           "nbyte", count,
                           "offset", attr.offs)) {
-    ERROR("Failed to send request.");
+    LOG_ERROR("Failed to send request.");
     return EINVAL;
   }
 
   int error;
   uint32_t nwrote;
   int result =
       ScanVar(response.pp_var(), "%d%u", "error", &error, "nwrote", &nwrote);
 
   if (result >= 1 && error)
     return error;
 
   if (result != 2) {
-    ERROR("Expected \"error\" and \"nwrote\" fields in response.");
+    LOG_ERROR("Expected \"error\" and \"nwrote\" fields in response.");
     return EINVAL;
   }
 
   *out_bytes = nwrote;
   return 0;
 }
 
 Error JsFsNode::GetDents(size_t offs,
                          struct dirent* pdir,
                          size_t count,
                          int* out_bytes) {
   AUTO_LOCK(node_lock_);
 
   *out_bytes = 0;
 
   // Round to the nearest sizeof(dirent) and ask for that.
   size_t first = offs / sizeof(dirent);
   size_t last = (offs + count + sizeof(dirent) - 1) / sizeof(dirent);
 
   ScopedVar response(ppapi_);
   if (!SendRequestAndWait(&response, "%s%d%u%u",
                           "cmd", "getdents",
                           "fildes", fd_,
                           "offs", first,
                           "count", last - first)) {
-    ERROR("Failed to send request.");
+    LOG_ERROR("Failed to send request.");
     return EINVAL;
   }
 
   int error;
   PP_Var dirents_var;
   int result = ScanVar(
       response.pp_var(), "%d%p", "error", &error, "dirents", &dirents_var);
 
   ScopedVar scoped_dirents_var(ppapi_, dirents_var);
 
   if (result >= 1 && error)
     return error;
 
   if (result != 2) {
-    ERROR("Expected \"error\" and \"dirents\" fields in response.");
+    LOG_ERROR("Expected \"error\" and \"dirents\" fields in response.");
     return EINVAL;
   }
 
   if (dirents_var.type != PP_VARTYPE_ARRAY) {
-    ERROR("Expected \"dirents\" to be an Array.");
+    LOG_ERROR("Expected \"dirents\" to be an Array.");
     return EINVAL;
   }
 
   uint32_t dirents_len = array_iface_->GetLength(dirents_var);
   uint32_t dirents_byte_len = dirents_len * sizeof(dirent);
 
   // Allocate enough full dirents to copy from. This makes it easier if, for
   // some reason, we are reading unaligned dirents.
   dirent* dirents = static_cast<dirent*>(malloc(dirents_byte_len));
 
   for (uint32_t i = 0; i < dirents_len; ++i) {
     PP_Var dirent_var = array_iface_->Get(dirents_var, i);
     PP_Var d_name_var;
     result = ScanVar(dirent_var,
                      "%lld%p",
                      "d_ino", &dirents[i].d_ino,
                      "d_name", &d_name_var);
     ScopedVar scoped_dirent_var(ppapi_, dirent_var);
     ScopedVar scoped_d_name_var(ppapi_, d_name_var);
 
     if (result != 2) {
-      ERROR("Expected dirent[%d] to have \"d_ino\" and \"d_name\".", i);
+      LOG_ERROR("Expected dirent[%d] to have \"d_ino\" and \"d_name\".", i);
       free(dirents);
       return EINVAL;
     }
 
     uint32_t d_name_len;
     const char* d_name = var_iface_->VarToUtf8(d_name_var, &d_name_len);
 
     dirents[i].d_off = sizeof(dirent);
     dirents[i].d_reclen = sizeof(dirent);
     strncpy(dirents[i].d_name, d_name, sizeof(dirents[i].d_name));
   }
 
   size_t dirents_offs = offs - first * sizeof(dirent);
   if (dirents_offs + count > dirents_byte_len)
     count = dirents_byte_len - dirents_offs;
 
   memcpy(pdir, reinterpret_cast<const char*>(dirents) + dirents_offs, count);
   *out_bytes = count;
 
   free(dirents);
   return 0;
 }
 
 }  // namespace nacl_io