[NaCl SDK] Map active fds to absolute paths.

native_client_sdk/src/libraries/nacl_io/kernel_object.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_object.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
@@ skipping 134 matching lines @@
 
 Error KernelObject::GetFDFlags(int fd, int* out_flags) {
   AUTO_LOCK(handle_lock_);
   if (fd < 0 || fd >= static_cast<int>(handle_map_.size()))
     return EBADF;
 
   *out_flags = handle_map_[fd].flags;
   return 0;
 }
 
+std::string KernelObject::GetFDPath(int fd) {
+  AUTO_LOCK(handle_lock_);
+
+  FdPathMap_t::iterator iter = fd_paths_.find(fd);
+  if (iter == fd_paths_.end())
+    return std::string();
+
+  return iter->second;
+}
+
 Error KernelObject::SetFDFlags(int fd, int flags) {
   AUTO_LOCK(handle_lock_);
   if (fd < 0 || fd >= static_cast<int>(handle_map_.size()))
     return EBADF;
 
   // Only setting of FD_CLOEXEC is supported.
   if (flags & ~FD_CLOEXEC)
     return EINVAL;
 
   handle_map_[fd].flags = flags;
   return 0;
 }
 
 Error KernelObject::AcquireHandle(int fd, ScopedKernelHandle* out_handle) {
   out_handle->reset(NULL);
 
   AUTO_LOCK(handle_lock_);
   if (fd < 0 || fd >= static_cast<int>(handle_map_.size()))
     return EBADF;
 
   *out_handle = handle_map_[fd].handle;
   if (out_handle)
     return 0;
 
   return EBADF;
 }
 
-int KernelObject::AllocateFD(const ScopedKernelHandle& handle) {
+Error KernelObject::AcquireHandleAndPath(int fd, ScopedKernelHandle* out_handle,
+                                         std::string &out_path){

[Sam Clegg, 2014/01/07 23:56:39]

Put '&' next to the type according to the local style.

+  out_handle->reset(NULL);
+
+  AUTO_LOCK(handle_lock_);
+  if (fd < 0 || fd >= static_cast<int>(handle_map_.size()))
+    return EBADF;
+
+  *out_handle = handle_map_[fd].handle;
+  if (!out_handle)
+    return EBADF;
+
+  out_path = fd_paths_[fd];
+
+  return 0;
+}
+
+int KernelObject::AllocateFD(const ScopedKernelHandle& handle,
+                             std::string path) {

[Sam Clegg, 2014/01/07 23:56:39]

Why not pass string by reference here too?

   AUTO_LOCK(handle_lock_);
   int id;
 
   Descriptor_t descriptor(handle);
 
   // If we can recycle and FD, use that first
   if (free_fds_.size()) {
     id = free_fds_.front();
     // Force lower numbered FD to be available first.
     std::pop_heap(free_fds_.begin(), free_fds_.end(), std::greater<int>());
     free_fds_.pop_back();
     handle_map_[id] = descriptor;
   } else {
     id = handle_map_.size();
     handle_map_.push_back(descriptor);
   }
+  // With our final fd identifier, we insert into our fd_paths_ mapping as long
+  // as path is non-NULL.
+  if (!path.empty())
+    fd_paths_[id] = GetAbsParts(path).Join();
+
   return id;
 }
 
-void KernelObject::FreeAndReassignFD(int fd, const ScopedKernelHandle& handle) {
+void KernelObject::FreeAndReassignFD(int fd, const ScopedKernelHandle& handle,
+                                     const std::string &path) {

[Sam Clegg, 2014/01/07 23:56:39]

& next to type name.

   if (NULL == handle) {
     FreeFD(fd);
   } else {
     AUTO_LOCK(handle_lock_);
 
     // If the required FD is larger than the current set, grow the set
     if (fd >= (int)handle_map_.size())
       handle_map_.resize(fd + 1);
 
     handle_map_[fd] = Descriptor_t(handle);
+    // Safe even if oldfd has no path.
+    fd_paths_[fd] = path;
   }
 }
 
 void KernelObject::FreeFD(int fd) {
   AUTO_LOCK(handle_lock_);
 
   handle_map_[fd].handle.reset(NULL);
   free_fds_.push_back(fd);
 
   // Force lower numbered FD to be available first.
   std::push_heap(free_fds_.begin(), free_fds_.end(), std::greater<int>());
+  //
+  // Remove the FD from the map of fd to absolute path
+  fd_paths_.erase(fd);
 }
 
 }  // namespace nacl_io