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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
/*
* File: w32ipcsem.c
* Description: implements named semaphores for NT and WIN95.
*/
#include "primpl.h"
#ifdef WINCE
static HANDLE OpenSemaphore(DWORD inDesiredAccess,
BOOL inInheritHandle,
const char *inName)
{
HANDLE retval = NULL;
HANDLE semaphore = NULL;
PRUnichar wideName[MAX_PATH]; /* name size is limited to MAX_PATH */
MultiByteToWideChar(CP_ACP, 0, inName, -1, wideName, MAX_PATH);
/* 0x7fffffff is the max count for our semaphore */
semaphore = CreateSemaphoreW(NULL, 0, 0x7fffffff, wideName);
if (NULL != semaphore) {
DWORD lastErr = GetLastError();
if (ERROR_ALREADY_EXISTS != lastErr) {
CloseHandle(semaphore);
}
else {
retval = semaphore;
}
}
return retval;
}
#endif
/*
* NSPR-to-NT access right mapping table for semaphore objects.
*
* The SYNCHRONIZE access is required by WaitForSingleObject.
* The SEMAPHORE_MODIFY_STATE access is required by ReleaseSemaphore.
* The OR of these three access masks must equal SEMAPHORE_ALL_ACCESS.
* This is because if a semaphore object with the specified name
* exists, CreateSemaphore requests SEMAPHORE_ALL_ACCESS access to
* the existing object.
*/
static DWORD semAccessTable[] = {
STANDARD_RIGHTS_REQUIRED|0x1, /* read (0x1 is "query state") */
STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|SEMAPHORE_MODIFY_STATE, /* write */
0 /* execute */
};
#ifndef _PR_GLOBAL_THREADS_ONLY
/*
* A fiber cannot call WaitForSingleObject because that
* will block the other fibers running on the same thread.
* If a fiber needs to wait on a (semaphore) handle, we
* create a native thread to call WaitForSingleObject and
* have the fiber join the native thread.
*/
/*
* Arguments, return value, and error code for WaitForSingleObject
*/
struct WaitSingleArg {
HANDLE handle;
DWORD timeout;
DWORD rv;
DWORD error;
};
static void WaitSingleThread(void *arg)
{
struct WaitSingleArg *warg = (struct WaitSingleArg *) arg;
warg->rv = WaitForSingleObject(warg->handle, warg->timeout);
if (warg->rv == WAIT_FAILED) {
warg->error = GetLastError();
}
}
static DWORD FiberSafeWaitForSingleObject(
HANDLE hHandle,
DWORD dwMilliseconds
)
{
PRThread *me = _PR_MD_CURRENT_THREAD();
if (_PR_IS_NATIVE_THREAD(me)) {
return WaitForSingleObject(hHandle, dwMilliseconds);
} else {
PRThread *waitThread;
struct WaitSingleArg warg;
PRStatus rv;
warg.handle = hHandle;
warg.timeout = dwMilliseconds;
waitThread = PR_CreateThread(
PR_USER_THREAD, WaitSingleThread, &warg,
PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0);
if (waitThread == NULL) {
return WAIT_FAILED;
}
rv = PR_JoinThread(waitThread);
PR_ASSERT(rv == PR_SUCCESS);
if (rv == PR_FAILURE) {
return WAIT_FAILED;
}
if (warg.rv == WAIT_FAILED) {
SetLastError(warg.error);
}
return warg.rv;
}
}
#endif /* !_PR_GLOBAL_THREADS_ONLY */
PRSem *_PR_MD_OPEN_SEMAPHORE(
const char *osname, PRIntn flags, PRIntn mode, PRUintn value)
{
PRSem *sem;
SECURITY_ATTRIBUTES sa;
LPSECURITY_ATTRIBUTES lpSA = NULL;
PSECURITY_DESCRIPTOR pSD = NULL;
PACL pACL = NULL;
sem = PR_NEW(PRSem);
if (sem == NULL) {
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return NULL;
}
if (flags & PR_SEM_CREATE) {
if (_PR_NT_MakeSecurityDescriptorACL(mode, semAccessTable,
&pSD, &pACL) == PR_SUCCESS) {
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = pSD;
sa.bInheritHandle = FALSE;
lpSA = &sa;
}
#ifdef WINCE
{
/* The size of a sem's name is limited to MAX_PATH. */
PRUnichar wosname[MAX_PATH];
MultiByteToWideChar(CP_ACP, 0, osname, -1, wosname, MAX_PATH);
sem->sem = CreateSemaphoreW(lpSA, value, 0x7fffffff, wosname);
}
#else
sem->sem = CreateSemaphoreA(lpSA, value, 0x7fffffff, osname);
#endif
if (lpSA != NULL) {
_PR_NT_FreeSecurityDescriptorACL(pSD, pACL);
}
if (sem->sem == NULL) {
_PR_MD_MAP_DEFAULT_ERROR(GetLastError());
PR_DELETE(sem);
return NULL;
}
if ((flags & PR_SEM_EXCL) && (GetLastError() == ERROR_ALREADY_EXISTS)) {
PR_SetError(PR_FILE_EXISTS_ERROR, ERROR_ALREADY_EXISTS);
CloseHandle(sem->sem);
PR_DELETE(sem);
return NULL;
}
} else {
sem->sem = OpenSemaphore(
SEMAPHORE_MODIFY_STATE|SYNCHRONIZE, FALSE, osname);
if (sem->sem == NULL) {
DWORD err = GetLastError();
/*
* If we open a nonexistent named semaphore, NT
* returns ERROR_FILE_NOT_FOUND, while Win95
* returns ERROR_INVALID_NAME
*/
if (err == ERROR_INVALID_NAME) {
PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
} else {
_PR_MD_MAP_DEFAULT_ERROR(GetLastError());
}
PR_DELETE(sem);
return NULL;
}
}
return sem;
}
PRStatus _PR_MD_WAIT_SEMAPHORE(PRSem *sem)
{
DWORD rv;
#ifdef _PR_GLOBAL_THREADS_ONLY
rv = WaitForSingleObject(sem->sem, INFINITE);
#else
rv = FiberSafeWaitForSingleObject(sem->sem, INFINITE);
#endif
PR_ASSERT(rv == WAIT_FAILED || rv == WAIT_OBJECT_0);
if (rv == WAIT_FAILED) {
_PR_MD_MAP_DEFAULT_ERROR(GetLastError());
return PR_FAILURE;
}
if (rv != WAIT_OBJECT_0) {
/* Should not happen */
PR_SetError(PR_UNKNOWN_ERROR, 0);
return PR_FAILURE;
}
return PR_SUCCESS;
}
PRStatus _PR_MD_POST_SEMAPHORE(PRSem *sem)
{
if (ReleaseSemaphore(sem->sem, 1, NULL) == FALSE) {
_PR_MD_MAP_DEFAULT_ERROR(GetLastError());
return PR_FAILURE;
}
return PR_SUCCESS;
}
PRStatus _PR_MD_CLOSE_SEMAPHORE(PRSem *sem)
{
if (CloseHandle(sem->sem) == FALSE) {
_PR_MD_MAP_CLOSE_ERROR(GetLastError());
return PR_FAILURE;
}
PR_DELETE(sem);
return PR_SUCCESS;
}
|
