ipc/glue/CrossProcessSemaphore_posix.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "CrossProcessSemaphore.h"
   8 #include "mozilla/Unused.h"
   9 #include "nsDebug.h"
  10 #include "nsISupportsImpl.h"
  11 #include <errno.h>
  12
  13 static const uint64_t kNsPerMs = 1000000;
  14 static const uint64_t kNsPerSec = 1000000000;
  15
  16 namespace {
  17
  18 struct SemaphoreData {
  19   sem_t mSemaphore;
  20   mozilla::Atomic<int32_t> mRefCount;
  21   uint32_t mInitialValue;
  22 };
  23
  24 }  // namespace
  25
  26 namespace mozilla {
  27
  28 /* static */
  29 CrossProcessSemaphore* CrossProcessSemaphore::Create(const char*,
  30                                                      uint32_t aInitialValue) {
  31   RefPtr<ipc::SharedMemoryBasic> sharedBuffer = new ipc::SharedMemoryBasic;
  32   if (!sharedBuffer->Create(sizeof(SemaphoreData))) {
  33     return nullptr;
  34   }
  35
  36   if (!sharedBuffer->Map(sizeof(SemaphoreData))) {
  37     return nullptr;
  38   }
  39
  40   SemaphoreData* data = static_cast<SemaphoreData*>(sharedBuffer->memory());
  41
  42   if (!data) {
  43     return nullptr;
  44   }
  45
  46   if (sem_init(&data->mSemaphore, 1, aInitialValue)) {
  47     return nullptr;
  48   }
  49
  50   CrossProcessSemaphore* sem = new CrossProcessSemaphore;
  51   sem->mSharedBuffer = sharedBuffer;
  52   sem->mSemaphore = &data->mSemaphore;
  53   sem->mRefCount = &data->mRefCount;
  54   *sem->mRefCount = 1;
  55
  56   data->mInitialValue = aInitialValue;
  57
  58   return sem;
  59 }
  60
  61 /* static */
  62 CrossProcessSemaphore* CrossProcessSemaphore::Create(
  63     CrossProcessSemaphoreHandle aHandle) {
  64   RefPtr<ipc::SharedMemoryBasic> sharedBuffer = new ipc::SharedMemoryBasic;
  65
  66   if (!sharedBuffer->IsHandleValid(aHandle)) {
  67     return nullptr;
  68   }
  69
  70   if (!sharedBuffer->SetHandle(std::move(aHandle),
  71                                ipc::SharedMemory::RightsReadWrite)) {
  72     return nullptr;
  73   }
  74
  75   if (!sharedBuffer->Map(sizeof(SemaphoreData))) {
  76     return nullptr;
  77   }
  78
  79   sharedBuffer->CloseHandle();
  80
  81   SemaphoreData* data = static_cast<SemaphoreData*>(sharedBuffer->memory());
  82
  83   if (!data) {
  84     return nullptr;
  85   }
  86
  87   int32_t oldCount = data->mRefCount++;
  88   if (oldCount == 0) {
  89     // The other side has already let go of their CrossProcessSemaphore, so now
  90     // mSemaphore is garbage. We need to re-initialize it.
  91     if (sem_init(&data->mSemaphore, 1, data->mInitialValue)) {
  92       data->mRefCount--;
  93       return nullptr;
  94     }
  95   }
  96
  97   CrossProcessSemaphore* sem = new CrossProcessSemaphore;
  98   sem->mSharedBuffer = sharedBuffer;
  99   sem->mSemaphore = &data->mSemaphore;
 100   sem->mRefCount = &data->mRefCount;
 101   return sem;
 102 }
 103
 104 CrossProcessSemaphore::CrossProcessSemaphore()
 105     : mSemaphore(nullptr), mRefCount(nullptr) {
 106   MOZ_COUNT_CTOR(CrossProcessSemaphore);
 107 }
 108
 109 CrossProcessSemaphore::~CrossProcessSemaphore() {
 110   int32_t oldCount = --(*mRefCount);
 111
 112   if (oldCount == 0) {
 113     // Nothing can be done if the destroy fails so ignore return code.
 114     Unused << sem_destroy(mSemaphore);
 115   }
 116
 117   MOZ_COUNT_DTOR(CrossProcessSemaphore);
 118 }
 119
 120 bool CrossProcessSemaphore::Wait(const Maybe<TimeDuration>& aWaitTime) {
 121   MOZ_ASSERT(*mRefCount > 0,
 122              "Attempting to wait on a semaphore with zero ref count");
 123   int ret;
 124   if (aWaitTime.isSome()) {
 125     struct timespec ts;
 126     if (clock_gettime(CLOCK_REALTIME, &ts) == -1) {
 127       return false;
 128     }
 129
 130     uint64_t ns = uint64_t(kNsPerMs * aWaitTime->ToMilliseconds()) + ts.tv_nsec;
 131     ts.tv_sec += ns / kNsPerSec;
 132     ts.tv_nsec = ns % kNsPerSec;
 133
 134     while ((ret = sem_timedwait(mSemaphore, &ts)) == -1 && errno == EINTR) {
 135     }
 136   } else {
 137     while ((ret = sem_wait(mSemaphore)) == -1 && errno == EINTR) {
 138     }
 139   }
 140   return ret == 0;
 141 }
 142
 143 void CrossProcessSemaphore::Signal() {
 144   MOZ_ASSERT(*mRefCount > 0,
 145              "Attempting to signal a semaphore with zero ref count");
 146   sem_post(mSemaphore);
 147 }
 148
 149 CrossProcessSemaphoreHandle CrossProcessSemaphore::CloneHandle() {
 150   CrossProcessSemaphoreHandle result = ipc::SharedMemoryBasic::NULLHandle();
 151
 152   if (mSharedBuffer) {
 153     result = mSharedBuffer->CloneHandle();
 154     if (!result) {
 155       MOZ_CRASH();
 156     }
 157   }
 158
 159   return result;
 160 }
 161
 162 void CrossProcessSemaphore::CloseHandle() { mSharedBuffer->CloseHandle(); }
 163
 164 }  // namespace mozilla