[NaCl SDK] Add some more logging to nacl_io.

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>
@@ skipping 400 matching lines @@
                                  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())
+  if (factory == factories_.end()) {
+    LOG_ERROR("Unknown filesystem type: %s", filesystemtype);
     return ENODEV;
+  }
 
   // Create a map of settings
   StringMap_t smap;
   smap["SOURCE"] = source;
 
   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();
@@ skipping 19 matching lines @@
   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)
+    if (error) {
+      DetachFsAtPath(abs_path, &fs);
       return error;
+    }
   }
 
   *out_filesystem = fs;
   return 0;
 }
 
 Error KernelProxy::CreateFsNode(const ScopedFilesystem& fs) {
   assert(dev_fs_);
 
   return dev_fs_->CreateFsNode(fs.get());
@@ skipping 359 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) {
+  LOG_TRACE("readlink is not implemented.");
   errno = EINVAL;
   return -1;
 }
 
 int KernelProxy::utimes(const char* filename, const struct timeval times[2]) {
+  LOG_TRACE("utimes is not implemented.");
   errno = EINVAL;
   return -1;
 }
 
 // TODO(noelallen): Needs implementation.
 int KernelProxy::link(const char* oldpath, const char* newpath) {
+  LOG_TRACE("link is not implemented.");
   errno = EINVAL;
   return -1;
 }
 
 int KernelProxy::symlink(const char* oldpath, const char* newpath) {
+  LOG_TRACE("symlink is not implemented.");
   errno = EINVAL;
   return -1;
 }
 
 void* KernelProxy::mmap(void* addr,
                         size_t length,
                         int prot,
                         int flags,
                         int fd,
                         size_t offset) {
@@ skipping 125 matching lines @@
           sigwinch_handler_.sa_handler != SIG_DFL) {
         sigwinch_handler_.sa_handler(SIGWINCH);
       }
       break;
 
     case SIGUSR1:
     case SIGUSR2:
       break;
 
     default:
+      LOG_TRACE("Unsupported signal: %d", sig);
       errno = EINVAL;
       return -1;
   }
   return 0;
 }
 
 int KernelProxy::sigaction(int signum,
                            const struct sigaction* action,
                            struct sigaction* oaction) {
   if (action && action->sa_flags & SA_SIGINFO) {
@@ skipping 23 matching lines @@
     case SIGCHLD:
     case SIGURG:
     case SIGFPE:
     case SIGILL:
     case SIGQUIT:
     case SIGSEGV:
     case SIGTRAP:
       if (action && action->sa_handler != SIG_DFL) {
         // Trying to set this action to anything other than SIG_DFL
         // is not yet supported.
+        LOG_TRACE("sigaction on signal %d != SIG_DFL not supported.", sig);
         errno = EINVAL;
         return -1;
       }
 
       if (oaction) {
         memset(oaction, 0, sizeof(*oaction));
         oaction->sa_handler = SIG_DFL;
       }
       return 0;
 
     // KILL and STOP cannot be handled
     case SIGKILL:
     case SIGSTOP:
+      LOG_TRACE("sigaction on SIGKILL/SIGSTOP not supported.");
       errno = EINVAL;
       return -1;
   }
 
   // Unknown signum
   errno = EINVAL;
   return -1;
 }
 
 #ifdef PROVIDES_SOCKET_API
@@ skipping 32 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)) {
+      LOG_TRACE("Invalid timeout: tv_sec=%d tv_usec=%d.",
+                timeout->tv_sec,
+                timeout->tv_usec);
       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 555 matching lines @@
     errno = ENOTSOCK;
     return -1;
   }
 
   return 0;
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 }  // namespace_nacl_io