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
231
232
233
234
235
|
/*-------------------------------------------------------------------------
*
* win32_sema.c
* Microsoft Windows Win32 Semaphores Emulation
*
* Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
*
* IDENTIFICATION
* src/backend/port/win32_sema.c
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "miscadmin.h"
#include "storage/ipc.h"
#include "storage/pg_sema.h"
static HANDLE *mySemSet; /* IDs of sema sets acquired so far */
static int numSems; /* number of sema sets acquired so far */
static int maxSems; /* allocated size of mySemaSet array */
static void ReleaseSemaphores(int code, Datum arg);
/*
* Report amount of shared memory needed for semaphores
*/
Size
PGSemaphoreShmemSize(int maxSemas)
{
/* No shared memory needed on Windows */
return 0;
}
/*
* PGReserveSemaphores --- initialize semaphore support
*
* In the Win32 implementation, we acquire semaphores on-demand; the
* maxSemas parameter is just used to size the array that keeps track of
* acquired semas for subsequent releasing. We use anonymous semaphores
* so the semaphores are automatically freed when the last referencing
* process exits.
*/
void
PGReserveSemaphores(int maxSemas)
{
mySemSet = (HANDLE *) malloc(maxSemas * sizeof(HANDLE));
if (mySemSet == NULL)
elog(PANIC, "out of memory");
numSems = 0;
maxSems = maxSemas;
on_shmem_exit(ReleaseSemaphores, 0);
}
/*
* Release semaphores at shutdown or shmem reinitialization
*
* (called as an on_shmem_exit callback, hence funny argument list)
*/
static void
ReleaseSemaphores(int code, Datum arg)
{
int i;
for (i = 0; i < numSems; i++)
CloseHandle(mySemSet[i]);
free(mySemSet);
}
/*
* PGSemaphoreCreate
*
* Allocate a PGSemaphore structure with initial count 1
*/
PGSemaphore
PGSemaphoreCreate(void)
{
HANDLE cur_handle;
SECURITY_ATTRIBUTES sec_attrs;
/* Can't do this in a backend, because static state is postmaster's */
Assert(!IsUnderPostmaster);
if (numSems >= maxSems)
elog(PANIC, "too many semaphores created");
ZeroMemory(&sec_attrs, sizeof(sec_attrs));
sec_attrs.nLength = sizeof(sec_attrs);
sec_attrs.lpSecurityDescriptor = NULL;
sec_attrs.bInheritHandle = TRUE;
/* We don't need a named semaphore */
cur_handle = CreateSemaphore(&sec_attrs, 1, 32767, NULL);
if (cur_handle)
{
/* Successfully done */
mySemSet[numSems++] = cur_handle;
}
else
ereport(PANIC,
(errmsg("could not create semaphore: error code %lu",
GetLastError())));
return (PGSemaphore) cur_handle;
}
/*
* PGSemaphoreReset
*
* Reset a previously-initialized PGSemaphore to have count 0
*/
void
PGSemaphoreReset(PGSemaphore sema)
{
/*
* There's no direct API for this in Win32, so we have to ratchet the
* semaphore down to 0 with repeated trylock's.
*/
while (PGSemaphoreTryLock(sema))
/* loop */ ;
}
/*
* PGSemaphoreLock
*
* Lock a semaphore (decrement count), blocking if count would be < 0.
*/
void
PGSemaphoreLock(PGSemaphore sema)
{
HANDLE wh[2];
bool done = false;
/*
* Note: pgwin32_signal_event should be first to ensure that it will be
* reported when multiple events are set. We want to guarantee that
* pending signals are serviced.
*/
wh[0] = pgwin32_signal_event;
wh[1] = sema;
/*
* As in other implementations of PGSemaphoreLock, we need to check for
* cancel/die interrupts each time through the loop. But here, there is
* no hidden magic about whether the syscall will internally service a
* signal --- we do that ourselves.
*/
while (!done)
{
DWORD rc;
CHECK_FOR_INTERRUPTS();
rc = WaitForMultipleObjectsEx(2, wh, FALSE, INFINITE, TRUE);
switch (rc)
{
case WAIT_OBJECT_0:
/* Signal event is set - we have a signal to deliver */
pgwin32_dispatch_queued_signals();
break;
case WAIT_OBJECT_0 + 1:
/* We got it! */
done = true;
break;
case WAIT_IO_COMPLETION:
/*
* The system interrupted the wait to execute an I/O
* completion routine or asynchronous procedure call in this
* thread. PostgreSQL does not provoke either of these, but
* atypical loaded DLLs or even other processes might do so.
* Now, resume waiting.
*/
break;
case WAIT_FAILED:
ereport(FATAL,
(errmsg("could not lock semaphore: error code %lu",
GetLastError())));
break;
default:
elog(FATAL, "unexpected return code from WaitForMultipleObjectsEx(): %lu", rc);
break;
}
}
}
/*
* PGSemaphoreUnlock
*
* Unlock a semaphore (increment count)
*/
void
PGSemaphoreUnlock(PGSemaphore sema)
{
if (!ReleaseSemaphore(sema, 1, NULL))
ereport(FATAL,
(errmsg("could not unlock semaphore: error code %lu",
GetLastError())));
}
/*
* PGSemaphoreTryLock
*
* Lock a semaphore only if able to do so without blocking
*/
bool
PGSemaphoreTryLock(PGSemaphore sema)
{
DWORD ret;
ret = WaitForSingleObject(sema, 0);
if (ret == WAIT_OBJECT_0)
{
/* We got it! */
return true;
}
else if (ret == WAIT_TIMEOUT)
{
/* Can't get it */
errno = EAGAIN;
return false;
}
/* Otherwise we are in trouble */
ereport(FATAL,
(errmsg("could not try-lock semaphore: error code %lu",
GetLastError())));
/* keep compiler quiet */
return false;
}
|
