ipc/glue/CrossProcessMutex_posix.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "CrossProcessMutex.h"
   7 #include "mozilla/unused.h"
   8 #include "nsDebug.h"
   9 #include "nsISupportsImpl.h"
  10
  11 namespace {
  12
  13 struct MutexData {
  14   pthread_mutex_t mMutex;
  15   mozilla::Atomic<int32_t> mCount;
  16 };
  17
  18 }
  19
  20 namespace mozilla {
  21
  22 static void
  23 InitMutex(pthread_mutex_t* mMutex)
  24 {
  25   pthread_mutexattr_t mutexAttributes;
  26   pthread_mutexattr_init(&mutexAttributes);
  27   // Make the mutex reentrant so it behaves the same as a win32 mutex
  28   if (pthread_mutexattr_settype(&mutexAttributes, PTHREAD_MUTEX_RECURSIVE)) {
  29     MOZ_CRASH();
  30   }
  31   if (pthread_mutexattr_setpshared(&mutexAttributes, PTHREAD_PROCESS_SHARED)) {
  32     MOZ_CRASH();
  33   }
  34
  35   if (pthread_mutex_init(mMutex, &mutexAttributes)) {
  36     MOZ_CRASH();
  37   }
  38 }
  39
  40 CrossProcessMutex::CrossProcessMutex(const char*)
  41     : mMutex(nullptr)
  42     , mCount(nullptr)
  43 {
  44   mSharedBuffer = new ipc::SharedMemoryBasic;
  45   if (!mSharedBuffer->Create(sizeof(MutexData))) {
  46     MOZ_CRASH();
  47   }
  48
  49   if (!mSharedBuffer->Map(sizeof(MutexData))) {
  50     MOZ_CRASH();
  51   }
  52
  53   MutexData* data = static_cast<MutexData*>(mSharedBuffer->memory());
  54
  55   if (!data) {
  56     MOZ_CRASH();
  57   }
  58
  59   mMutex = &(data->mMutex);
  60   mCount = &(data->mCount);
  61
  62   *mCount = 1;
  63   InitMutex(mMutex);
  64
  65   MOZ_COUNT_CTOR(CrossProcessMutex);
  66 }
  67
  68 CrossProcessMutex::CrossProcessMutex(CrossProcessMutexHandle aHandle)
  69     : mMutex(nullptr)
  70     , mCount(nullptr)
  71 {
  72   if (!ipc::SharedMemoryBasic::IsHandleValid(aHandle)) {
  73     MOZ_CRASH();
  74   }
  75
  76   mSharedBuffer = new ipc::SharedMemoryBasic(aHandle);
  77
  78   if (!mSharedBuffer->Map(sizeof(MutexData))) {
  79     MOZ_CRASH();
  80   }
  81
  82   MutexData* data = static_cast<MutexData*>(mSharedBuffer->memory());
  83
  84   if (!data) {
  85     MOZ_CRASH();
  86   }
  87
  88   mMutex = &(data->mMutex);
  89   mCount = &(data->mCount);
  90   int32_t count = (*mCount)++;
  91
  92   if (count == 0) {
  93     // The other side has already let go of their CrossProcessMutex, so now
  94     // mMutex is garbage. We need to re-initialize it.
  95     InitMutex(mMutex);
  96   }
  97
  98   MOZ_COUNT_CTOR(CrossProcessMutex);
  99 }
 100
 101 CrossProcessMutex::~CrossProcessMutex()
 102 {
 103   int32_t count = --(*mCount);
 104
 105   if (count == 0) {
 106     // Nothing can be done if the destroy fails so ignore return code.
 107     unused << pthread_mutex_destroy(mMutex);
 108   }
 109
 110   MOZ_COUNT_DTOR(CrossProcessMutex);
 111 }
 112
 113 void
 114 CrossProcessMutex::Lock()
 115 {
 116   MOZ_ASSERT(*mCount > 0, "Attempting to lock mutex with zero ref count");
 117   pthread_mutex_lock(mMutex);
 118 }
 119
 120 void
 121 CrossProcessMutex::Unlock()
 122 {
 123   MOZ_ASSERT(*mCount > 0, "Attempting to unlock mutex with zero ref count");
 124   pthread_mutex_unlock(mMutex);
 125 }
 126
 127 CrossProcessMutexHandle
 128 CrossProcessMutex::ShareToProcess(base::ProcessHandle aHandle)
 129 {
 130   CrossProcessMutexHandle result = ipc::SharedMemoryBasic::NULLHandle();
 131
 132   if (mSharedBuffer && !mSharedBuffer->ShareToProcess(aHandle, &result)) {
 133     MOZ_CRASH();
 134   }
 135
 136   return result;
 137 }
 138
 139 }