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