[NaCl SDK] Upate atomic ops in 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 <pthread.h>
@@ skipping 336 matching lines @@
 }
 
 ssize_t KernelProxy::read(int fd, void* buf, size_t nbytes) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
-  AutoLock lock(&handle->lock_);
   int cnt = 0;
-  error = handle->node_->Read(handle->offs_, buf, nbytes, &cnt);
+  error = handle->Read(buf, nbytes, &cnt);
   if (error) {
     errno = error;
     return -1;
   }
 
-  if (cnt > 0)
-    handle->offs_ += cnt;
-
   return cnt;
 }
 
 ssize_t KernelProxy::write(int fd, const void* buf, size_t nbytes) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
-  AutoLock lock(&handle->lock_);
   int cnt = 0;
-  error = handle->node_->Write(handle->offs_, buf, nbytes, &cnt);
+  error = handle->Write(buf, nbytes, &cnt);
   if (error) {
     errno = error;
     return -1;
   }
 
-  if (cnt > 0)
-    handle->offs_ += cnt;
-
   return cnt;
 }
 
 int KernelProxy::fstat(int fd, struct stat* buf) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
-  error = handle->node_->GetStat(buf);
+  error = handle->node()->GetStat(buf);
   if (error) {
     errno = error;
     return -1;
   }
 
   return 0;
 }
 
 int KernelProxy::getdents(int fd, void* buf, unsigned int count) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
-  AutoLock lock(&handle->lock_);
   int cnt = 0;
-  error = handle->node_
-      ->GetDents(handle->offs_, static_cast<dirent*>(buf), count, &cnt);
+  error = handle->GetDents(static_cast<dirent*>(buf), count, &cnt);
   if (error)
     errno = error;
 
-  if (cnt > 0)
-    handle->offs_ += cnt;
-
   return cnt;
 }
 
 int KernelProxy::ftruncate(int fd, off_t length) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
-  error = handle->node_->FTruncate(length);
+  error = handle->node()->FTruncate(length);
   if (error) {
     errno = error;
     return -1;
   }
 
   return 0;
 }
 
 int KernelProxy::fsync(int fd) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
-  error = handle->node_->FSync();
+  error = handle->node()->FSync();
   if (error) {
     errno = error;
     return -1;
   }
 
   return 0;
 }
 
 int KernelProxy::isatty(int fd) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
-  error = handle->node_->IsaTTY();
+  error = handle->node()->IsaTTY();
   if (error) {
     errno = error;
     return -1;
   }
 
   return 0;
 }
 
 int KernelProxy::ioctl(int d, int request, char* argp) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(d, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
-  error = handle->node_->Ioctl(request, argp);
+  error = handle->node()->Ioctl(request, argp);
   if (error) {
     errno = error;
     return -1;
   }
 
   return 0;
 }
 
 off_t KernelProxy::lseek(int fd, off_t offset, int whence) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
-  AutoLock lock(&handle->lock_);
   off_t new_offset;
   error = handle->Seek(offset, whence, &new_offset);
   if (error) {
     errno = error;
     return -1;
   }
 
   return new_offset;
 }
 
@@ skipping 87 matching lines @@
   assert(fd != -1);
 
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return MAP_FAILED;
   }
 
   void* new_addr;
-  AutoLock lock(&handle->lock_);
-  error = handle->node_->MMap(addr, length, prot, flags, offset, &new_addr);
+  error = handle->node()->MMap(addr, length, prot, flags, offset, &new_addr);
   if (error) {
     errno = error;
     return MAP_FAILED;
   }
 
   return new_addr;
 }
 
 int KernelProxy::munmap(void* addr, size_t length) {
   // NOTE: The comment below is from a previous discarded implementation that
@@ skipping 23 matching lines @@
   // Unfortunately, munmap still needs to acquire other locks; see the call to
   // ReleaseHandle below which takes the process lock. This is safe as long as
   // this is never executed from free() -- we can be reasonably sure this is
   // true, because malloc only makes anonymous mmap() requests, and should only
   // be munmapping those allocations. We never add to mmap_info_list_ for
   // anonymous maps, so the unmap_list should always be empty when called from
   // free().
   return 0;
 }