Transition POSIX shmem to use lockf(), not semaphores.

base/shared_memory_posix.cc

 // Copyright (c) 2006-2008 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 "base/shared_memory.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "base/platform_thread.h"
 #include "base/string_util.h"
 
 namespace base {
 
 namespace {
 // Paranoia. Semaphores and shared memory segments should live in different
 // namespaces, but who knows what's out there.
 const char kSemaphoreSuffix[] = "-sem";
 }
 
 SharedMemory::SharedMemory()
     : mapped_file_(-1),
       memory_(NULL),
       read_only_(false),
-      max_size_(0),
-      lock_(NULL) {
+      max_size_(0) {
 }
 
 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only)
     : mapped_file_(handle),
       memory_(NULL),
       read_only_(read_only),
-      max_size_(0),
-      lock_(NULL) {
+      max_size_(0) {
 }
 
 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only,
                            ProcessHandle process)
     : mapped_file_(handle),
       memory_(NULL),
       read_only_(read_only),
-      max_size_(0),
-      lock_(NULL) {
+      max_size_(0) {
   // We don't handle this case yet (note the ignored parameter); let's die if
   // someone comes calling.
   NOTREACHED();
 }
 
 SharedMemory::~SharedMemory() {
   Close();
-  if (lock_ != NULL)
-    sem_close(lock_);
 }
 
 bool SharedMemory::Create(const std::wstring &name, bool read_only,
                           bool open_existing, size_t size) {
   read_only_ = read_only;
 
   int posix_flags = 0;
   posix_flags |= read_only ? O_RDONLY : O_RDWR;
   if (!open_existing || mapped_file_ <= 0)
     posix_flags |= O_CREAT;
@@ skipping 133 matching lines @@
       // possibly shrink.
       if ((ftruncate(fileno(fp), size) != 0) ||
           (fflush(fp) != 0)) {
         return false;
       }
     }
   }
 
   mapped_file_ = dup(fileno(fp));
   DCHECK(mapped_file_ >= 0);
-
-  mode_t posix_mode =  S_IRUSR | S_IWUSR;  // owner read/write
-  // name_ that includes a tmpdir easily exceeds SEM_NAME_LEN,
-  // so we cannot use it directly as the basis for a sem_name_.
-  sem_name_ = WideToUTF8(name) + kSemaphoreSuffix;
-  lock_ = sem_open(sem_name_.c_str(), O_CREAT, posix_mode, 1);
-  if (lock_ == SEM_FAILED) {
-    close(mapped_file_);
-    mapped_file_ = -1;
-    lock_ = NULL;
-    return false;
-  }
-
   return true;
 }
 
 bool SharedMemory::Map(size_t bytes) {
   if (mapped_file_ == -1)
     return false;
 
   memory_ = mmap(NULL, bytes, PROT_READ | (read_only_ ? 0 : PROT_WRITE),
                  MAP_SHARED, mapped_file_, 0);
 
@@ skipping 25 matching lines @@
 
 void SharedMemory::Close() {
 
   Unmap();
 
   std::string posix_name(WideToUTF8(name_));
   if (mapped_file_ > 0) {
     close(mapped_file_);
     mapped_file_ = -1;
   }
+}
 
-  if (lock_) {
-    sem_unlink(sem_name_.c_str());
-    lock_ = NULL;
+void SharedMemory::LockOrUnlockCommon(int function) {
+  DCHECK(mapped_file_ >= 0);
+  while (lockf(mapped_file_, function, 0) < 0) {
+    if (errno == EINTR) {
+      continue;
+    } else if (errno == ENOLCK) {
+      // temporary kernel resource exaustion
+      PlatformThread::Sleep(500);
+      continue;
+    } else {
+      NOTREACHED() << "lockf() failed."
+                   << " function:" << function
+                   << " fd:" << mapped_file_
+                   << " errno:" << errno
+                   << " msg:" << strerror(errno);
+    }
   }
 }
 
 void SharedMemory::Lock() {
-  DCHECK(lock_ != NULL);
-  while(sem_wait(lock_) < 0) {
-    DCHECK(errno == EAGAIN || errno == EINTR);
-  }
+  LockOrUnlockCommon(F_LOCK);
 }
 
 void SharedMemory::Unlock() {
-  DCHECK(lock_ != NULL);
-  int result = sem_post(lock_);
-  DCHECK(result == 0);
+  LockOrUnlockCommon(F_ULOCK);
 }
 
 }  // namespace base