[NaCl SDK] Upate atomic ops in nacl_io

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>
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "nacl_io/kernel_handle.h"
 #include "nacl_io/mount.h"
 #include "nacl_io/mount_node.h"
 
 #include "sdk_util/auto_lock.h"
 #include "sdk_util/ref_object.h"
 #include "sdk_util/scoped_ref.h"
 
 KernelObject::KernelObject() {
-  pthread_mutex_init(&mount_lock_, NULL);
-  pthread_mutex_init(&handle_lock_, NULL);
-  pthread_mutex_init(&cwd_lock_,NULL);
-
   cwd_ = "/";
 }
 
-KernelObject::~KernelObject() {
-  pthread_mutex_destroy(&cwd_lock_);
-  pthread_mutex_destroy(&handle_lock_);
-  pthread_mutex_destroy(&mount_lock_);
-}
+KernelObject::~KernelObject() {};
 
 Error KernelObject::AttachMountAtPath(const ScopedMount& mnt,
                                 const std::string& path) {
   std::string abs_path = GetAbsParts(path).Join();
 
-  AutoLock lock(&mount_lock_);
+  AUTO_LOCK(mount_lock_);
   if (mounts_.find(abs_path) != mounts_.end())
     return EBUSY;
 
   mounts_[abs_path] = mnt;
   return 0;
 }
 
 Error KernelObject::DetachMountAtPath(const std::string& path) {
   std::string abs_path = GetAbsParts(path).Join();
 
-  AutoLock lock(&mount_lock_);
+  AUTO_LOCK(mount_lock_);
   MountMap_t::iterator it = mounts_.find(abs_path);
   if (mounts_.end() == it)
     return EINVAL;
 
   // It is only legal to unmount if there are no open references
   if (it->second->RefCount() != 1)
     return EBUSY;
 
   mounts_.erase(it);
   return 0;
 }
 
 // Uses longest prefix to find the mount for the give path, then
 // acquires the mount and returns it with a relative path.
 Error KernelObject::AcquireMountAndRelPath(const std::string& path,
                                            ScopedMount* out_mount,
                                            Path* rel_parts) {
   Path abs_parts = GetAbsParts(path);
 
   out_mount->reset(NULL);
   *rel_parts = Path();
 
-  AutoLock lock(&mount_lock_);
+  AUTO_LOCK(mount_lock_);
 
   // Find longest prefix
   size_t max = abs_parts.Size();
   for (size_t len = 0; len < abs_parts.Size(); len++) {
     MountMap_t::iterator it = mounts_.find(abs_parts.Range(0, max - len));
     if (it != mounts_.end()) {
       rel_parts->Set("/");
       rel_parts->Append(abs_parts.Range(max - len, max));
 
       *out_mount = it->second;
@@ skipping 18 matching lines @@
     return error;
 
   error = (*out_mount)->Open(rel_parts, oflags, out_node);
   if (error)
     return error;
 
   return 0;
 }
 
 Path KernelObject::GetAbsParts(const std::string& path) {
-  AutoLock lock(&cwd_lock_);
+  AUTO_LOCK(cwd_lock_);
 
   Path abs_parts(cwd_);
   if (path[0] == '/') {
     abs_parts = path;
   } else {
     abs_parts = cwd_;
     abs_parts.Append(path);
   }
 
   return abs_parts;
 }
 
 std::string KernelObject::GetCWD() {
-  AutoLock lock(&cwd_lock_);
+  AUTO_LOCK(cwd_lock_);
   std::string out = cwd_;
 
   return out;
 }
 
 Error KernelObject::SetCWD(const std::string& path) {
   std::string abs_path = GetAbsParts(path).Join();
 
   ScopedMount mnt;
   ScopedMountNode node;
 
   Error error = AcquireMountAndNode(abs_path, O_RDONLY, &mnt, &node);
   if (error)
     return error;
 
   if ((node->GetType() & S_IFDIR) == 0)
     return ENOTDIR;
 
-  AutoLock lock(&cwd_lock_);
+  AUTO_LOCK(cwd_lock_);
   cwd_ = abs_path;
   return 0;
 }
 
 Error KernelObject::AcquireHandle(int fd, ScopedKernelHandle* out_handle) {
   out_handle->reset(NULL);
 
-  AutoLock lock(&handle_lock_);
+  AUTO_LOCK(handle_lock_);
   if (fd < 0 || fd >= static_cast<int>(handle_map_.size()))
     return EBADF;
 
   *out_handle = handle_map_[fd];
   if (out_handle) return 0;
 
   return EBADF;
 }
 
 int KernelObject::AllocateFD(const ScopedKernelHandle& handle) {
-  AutoLock lock(&handle_lock_);
+  AUTO_LOCK(handle_lock_);
   int id;
 
   // 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] = handle;
   } else {
     id = handle_map_.size();
     handle_map_.push_back(handle);
   }
   return id;
 }
 
 void KernelObject::FreeAndReassignFD(int fd, const ScopedKernelHandle& handle) {
   if (NULL == handle) {
     FreeFD(fd);
   } else {
-    AutoLock lock(&handle_lock_);
+    AUTO_LOCK(handle_lock_);
 
     // If the required FD is larger than the current set, grow the set
     if (fd >= handle_map_.size())
       handle_map_.resize(fd + 1, ScopedRef<KernelHandle>());
 
     handle_map_[fd] = handle;
   }
 }
 
 void KernelObject::FreeFD(int fd) {
-  AutoLock lock(&handle_lock_);
+  AUTO_LOCK(handle_lock_);
 
   handle_map_[fd].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>());
 }