VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/os2/sems-os2.cpp@ 76553

Last change on this file since 76553 was 76553, checked in by vboxsync, 5 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 10.4 KB
Line 
1/* $Id: sems-os2.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * IPRT - Semaphores, OS/2.
4 */
5
6/*
7 * Copyright (C) 2006-2019 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*********************************************************************************************************************************
29* Header Files *
30*********************************************************************************************************************************/
31#define INCL_DOSSEMAPHORES
32#define INCL_ERRORS
33#include <os2.h>
34#undef RT_MAX
35
36#include <iprt/semaphore.h>
37#include <iprt/assert.h>
38#include <iprt/err.h>
39
40
41/** Converts semaphore to OS/2 handle. */
42#define SEM2HND(Sem) ((LHANDLE)(uintptr_t)Sem)
43
44
45
46RTDECL(int) RTSemEventCreate(PRTSEMEVENT phEventSem)
47{
48 return RTSemEventCreateEx(phEventSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
49}
50
51
52RTDECL(int) RTSemEventCreateEx(PRTSEMEVENT phEventSem, uint32_t fFlags, RTLOCKVALCLASS hClass, const char *pszNameFmt, ...)
53{
54 AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL | RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
55 Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) || (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
56
57 /*
58 * Create the semaphore.
59 * (Auto reset, not signaled, private event object.)
60 */
61 HEV hev;
62 int rc = DosCreateEventSem(NULL, &hev, DCE_AUTORESET | DCE_POSTONE, 0);
63 if (!rc)
64 {
65 *phEventSem = (RTSEMEVENT)(void *)hev;
66 return VINF_SUCCESS;
67 }
68 return RTErrConvertFromOS2(rc);
69}
70
71
72RTDECL(int) RTSemEventDestroy(RTSEMEVENT hEventSem)
73{
74 if (hEventSem == NIL_RTSEMEVENT)
75 return VINF_SUCCESS;
76
77 /*
78 * Close semaphore handle.
79 */
80 int rc = DosCloseEventSem(SEM2HND(hEventSem));
81 if (!rc)
82 return VINF_SUCCESS;
83 AssertMsgFailed(("Destroy hEventSem %p failed, rc=%d\n", hEventSem, rc));
84 return RTErrConvertFromOS2(rc);
85}
86
87
88RTDECL(int) RTSemEventWaitNoResume(RTSEMEVENT hEventSem, RTMSINTERVAL cMillies)
89{
90 /*
91 * Wait for condition.
92 */
93 int rc = DosWaitEventSem(SEM2HND(hEventSem), cMillies == RT_INDEFINITE_WAIT ? SEM_INDEFINITE_WAIT : cMillies);
94 switch (rc)
95 {
96 case NO_ERROR: return VINF_SUCCESS;
97 case ERROR_SEM_TIMEOUT:
98 case ERROR_TIMEOUT: return VERR_TIMEOUT;
99 case ERROR_INTERRUPT: return VERR_INTERRUPTED;
100 default:
101 {
102 AssertMsgFailed(("Wait on hEventSem %p failed, rc=%d\n", hEventSem, rc));
103 return RTErrConvertFromOS2(rc);
104 }
105 }
106}
107
108
109RTDECL(int) RTSemEventSignal(RTSEMEVENT hEventSem)
110{
111 /*
112 * Signal the object.
113 */
114 int rc = DosPostEventSem(SEM2HND(hEventSem));
115 switch (rc)
116 {
117 case NO_ERROR:
118 case ERROR_ALREADY_POSTED:
119 case ERROR_TOO_MANY_POSTS:
120 return VINF_SUCCESS;
121 default:
122 return RTErrConvertFromOS2(rc);
123 }
124}
125
126
127RTDECL(void) RTSemEventSetSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread)
128{
129/** @todo implement RTSemEventSetSignaller and friends for OS/2 */
130}
131
132
133RTDECL(void) RTSemEventAddSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread)
134{
135
136}
137
138
139RTDECL(void) RTSemEventRemoveSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread)
140{
141
142}
143
144
145
146
147RTDECL(int) RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
148{
149 return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
150}
151
152
153RTDECL(int) RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
154 const char *pszNameFmt, ...)
155{
156 AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
157
158 /*
159 * Create the semaphore.
160 * (Manual reset, not signaled, private event object.)
161 */
162 HEV hev;
163 int rc = DosCreateEventSem(NULL, &hev, 0, FALSE);
164 if (!rc)
165 {
166 *phEventMultiSem = (RTSEMEVENTMULTI)(void *)hev;
167 return VINF_SUCCESS;
168 }
169 return RTErrConvertFromOS2(rc);
170}
171
172
173RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
174{
175 if (hEventMultiSem == NIL_RTSEMEVENTMULTI)
176 return VINF_SUCCESS;
177
178 /*
179 * Close semaphore handle.
180 */
181 int rc = DosCloseEventSem(SEM2HND(hEventMultiSem));
182 if (!rc)
183 return VINF_SUCCESS;
184 AssertMsgFailed(("Destroy hEventMultiSem %p failed, rc=%d\n", hEventMultiSem, rc));
185 return RTErrConvertFromOS2(rc);
186}
187
188
189RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
190{
191 /*
192 * Signal the object.
193 */
194 int rc = DosPostEventSem(SEM2HND(hEventMultiSem));
195 switch (rc)
196 {
197 case NO_ERROR:
198 case ERROR_ALREADY_POSTED:
199 case ERROR_TOO_MANY_POSTS:
200 return VINF_SUCCESS;
201 default:
202 return RTErrConvertFromOS2(rc);
203 }
204}
205
206
207RTDECL(int) RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
208{
209 /*
210 * Reset the object.
211 */
212 ULONG ulIgnore;
213 int rc = DosResetEventSem(SEM2HND(hEventMultiSem), &ulIgnore);
214 switch (rc)
215 {
216 case NO_ERROR:
217 case ERROR_ALREADY_RESET:
218 return VINF_SUCCESS;
219 default:
220 return RTErrConvertFromOS2(rc);
221 }
222}
223
224
225RTDECL(int) RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, RTMSINTERVAL cMillies)
226{
227 /*
228 * Wait for condition.
229 */
230 int rc = DosWaitEventSem(SEM2HND(hEventMultiSem), cMillies == RT_INDEFINITE_WAIT ? SEM_INDEFINITE_WAIT : cMillies);
231 switch (rc)
232 {
233 case NO_ERROR: return VINF_SUCCESS;
234 case ERROR_SEM_TIMEOUT:
235 case ERROR_TIMEOUT: return VERR_TIMEOUT;
236 case ERROR_INTERRUPT: return VERR_INTERRUPTED;
237 default:
238 {
239 AssertMsgFailed(("Wait on hEventMultiSem %p failed, rc=%d\n", hEventMultiSem, rc));
240 return RTErrConvertFromOS2(rc);
241 }
242 }
243}
244
245
246RTDECL(void) RTSemEventMultiSetSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread)
247{
248 /** @todo implement RTSemEventMultiSetSignaller on OS/2 */
249}
250
251
252RTDECL(void) RTSemEventMultiAddSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread)
253{
254}
255
256
257RTDECL(void) RTSemEventMultiRemoveSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread)
258{
259}
260
261
262
263#undef RTSemMutexCreate
264RTDECL(int) RTSemMutexCreate(PRTSEMMUTEX phMutexSem)
265{
266 return RTSemMutexCreateEx(phMutexSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, NULL);
267}
268
269
270RTDECL(int) RTSemMutexCreateEx(PRTSEMMUTEX phMutexSem, uint32_t fFlags,
271 RTLOCKVALCLASS hClass, uint32_t uSubClass, const char *pszNameFmt, ...)
272{
273 AssertReturn(!(fFlags & ~RTSEMMUTEX_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
274
275 /*
276 * Create the semaphore.
277 */
278 HMTX hmtx;
279 int rc = DosCreateMutexSem(NULL, &hmtx, 0, FALSE);
280 if (!rc)
281 {
282 /** @todo implement lock validation of OS/2 mutex semaphores. */
283 *phMutexSem = (RTSEMMUTEX)(void *)hmtx;
284 return VINF_SUCCESS;
285 }
286
287 return RTErrConvertFromOS2(rc);
288}
289
290
291RTDECL(int) RTSemMutexDestroy(RTSEMMUTEX hMutexSem)
292{
293 if (hMutexSem == NIL_RTSEMMUTEX)
294 return VINF_SUCCESS;
295
296 /*
297 * Close semaphore handle.
298 */
299 int rc = DosCloseMutexSem(SEM2HND(hMutexSem));
300 if (!rc)
301 return VINF_SUCCESS;
302 AssertMsgFailed(("Destroy hMutexSem %p failed, rc=%d\n", hMutexSem, rc));
303 return RTErrConvertFromOS2(rc);
304}
305
306
307
308RTDECL(uint32_t) RTSemMutexSetSubClass(RTSEMMUTEX hMutexSem, uint32_t uSubClass)
309{
310#if 0 /** @todo def RTSEMMUTEX_STRICT */
311 /*
312 * Validate.
313 */
314 RTSEMMUTEXINTERNAL *pThis = hMutexSem;
315 AssertPtrReturn(pThis, RTLOCKVAL_SUB_CLASS_INVALID);
316 AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, RTLOCKVAL_SUB_CLASS_INVALID);
317
318 return RTLockValidatorRecExclSetSubClass(&pThis->ValidatorRec, uSubClass);
319#else
320 return RTLOCKVAL_SUB_CLASS_INVALID;
321#endif
322}
323
324
325#undef RTSemMutexRequestNoResume
326RTDECL(int) RTSemMutexRequestNoResume(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies)
327{
328 /*
329 * Lock mutex semaphore.
330 */
331 int rc = DosRequestMutexSem(SEM2HND(hMutexSem), cMillies == RT_INDEFINITE_WAIT ? SEM_INDEFINITE_WAIT : cMillies);
332 switch (rc)
333 {
334 case NO_ERROR: return VINF_SUCCESS;
335 case ERROR_SEM_TIMEOUT:
336 case ERROR_TIMEOUT: return VERR_TIMEOUT;
337 case ERROR_INTERRUPT: return VERR_INTERRUPTED;
338 case ERROR_SEM_OWNER_DIED: return VERR_SEM_OWNER_DIED;
339 default:
340 {
341 AssertMsgFailed(("Wait on hMutexSem %p failed, rc=%d\n", hMutexSem, rc));
342 return RTErrConvertFromOS2(rc);
343 }
344 }
345}
346
347RTDECL(int) RTSemMutexRequestNoResumeDebug(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
348{
349// RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
350// return rtSemMutexRequestNoResume(hMutexSem, cMillies, &SrcPos);
351 return RTSemMutexRequestNoResume(hMutexSem, cMillies);
352}
353
354
355RTDECL(int) RTSemMutexRelease(RTSEMMUTEX hMutexSem)
356{
357 /*
358 * Unlock mutex semaphore.
359 */
360 int rc = DosReleaseMutexSem(SEM2HND(hMutexSem));
361 if (!rc)
362 return VINF_SUCCESS;
363 AssertMsgFailed(("Release hMutexSem %p failed, rc=%d\n", hMutexSem, rc));
364 return RTErrConvertFromOS2(rc);
365}
366
367
368RTDECL(bool) RTSemMutexIsOwned(RTSEMMUTEX hMutexSem)
369{
370 /*
371 * Unlock mutex semaphore.
372 */
373 PID pid;
374 TID tid;
375 ULONG cRecursions;
376 int rc = DosQueryMutexSem(SEM2HND(hMutexSem), &pid, &tid, &cRecursions);
377 if (!rc)
378 return cRecursions != 0;
379 AssertMsgFailed(("DosQueryMutexSem %p failed, rc=%d\n", hMutexSem, rc));
380 return rc == ERROR_SEM_OWNER_DIED;
381}
382
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use