source: trunk/src/kernel32/hmmutex.cpp@ 6069

Last change on this file since 6069 was 6069, checked in by sandervl, 24 years ago

semaphore update
File size: 14.3 KB
Line 
1/* $Id: hmmutex.cpp,v 1.6 2001-06-22 19:40:28 sandervl Exp $ */
2
3/*
4 * Win32 Mutex Semaphore implementation
5 *
6 * TODO: Inheritance
7 * TODO: No inheritance when CreateMutex is called for existing named event semaphore?
8 * (see HMCreateMutex in handlemanager.cpp)
9 * TODO: Name collisions with files & mutex not allowed. Check if this can happen in OS/2
10 *
11 * Project Odin Software License can be found in LICENSE.TXT
12 *
13 * Copyright 2001 Sander van Leeuwen (sandervl@xs4all.nl)
14 */
15
16#undef DEBUG_LOCAL
17//#define DEBUG_LOCAL
18
19
20/*****************************************************************************
21 * Remark *
22 *****************************************************************************
23
24 */
25
26
27/*****************************************************************************
28 * Includes *
29 *****************************************************************************/
30
31#ifdef USE_OS2SEMAPHORES
32#define INCL_DOSSEMAPHORES
33#define INCL_DOSERRORS
34#include <os2wrap.h>
35#include <win32type.h>
36#include <win32api.h>
37#include <winconst.h>
38#else
39#include <os2win.h>
40#endif
41#include <stdlib.h>
42#include <string.h>
43#include "unicode.h"
44#include "misc.h"
45#include "oslibdos.h"
46
47#include "HandleManager.H"
48#include "HMMutex.h"
49
50#define DBG_LOCALLOG DBG_hmmutex
51#include "dbglocal.h"
52
53/*****************************************************************************
54 * Defines *
55 *****************************************************************************/
56
57/*****************************************************************************
58 * Structures *
59 *****************************************************************************/
60
61/*****************************************************************************
62 * Local Prototypes *
63 *****************************************************************************/
64
65
66/*****************************************************************************
67 * Name : HMCreateMutex
68 * Purpose : router function for CreateMutex
69 * Parameters:
70 * Variables :
71 * Result :
72 * Remark :
73 * Status :
74 *
75 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
76 *****************************************************************************/
77
78DWORD HMDeviceMutexClass::CreateMutex(PHMHANDLEDATA pHMHandleData,
79 LPSECURITY_ATTRIBUTES lpsa,
80 BOOL fInitialOwner,
81 LPCTSTR lpszMutexName)
82{
83#ifdef USE_OS2SEMAPHORES
84 APIRET rc;
85 HMTX htmx;
86 char szSemName[CCHMAXPATH];
87
88 dprintf(("KERNEL32: HandleManager::Mutex::CreateMutex(%08xh,%08xh,%08xh,%s)\n",
89 pHMHandleData,
90 lpsa,
91 fInitialOwner,
92 lpszMutexName));
93
94 if(lpszMutexName) {
95 strcpy(szSemName, "\\SEM32\\");
96 strcat(szSemName, lpszMutexName);
97 lpszMutexName = szSemName;
98 }
99 rc = DosCreateMutexSem(lpszMutexName, &htmx, 0, fInitialOwner);
100
101 if(rc) {
102 dprintf(("DosCreateMutexSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));
103 pHMHandleData->hHMHandle = 0;
104 return error2WinError(rc);
105 }
106 pHMHandleData->dwAccess = MUTEX_ALL_ACCESS_W;
107 pHMHandleData->hHMHandle = htmx;
108 pHMHandleData->dwInternalType = HMTYPE_MUTEXSEM;
109 return ERROR_SUCCESS_W;
110#else
111 HANDLE hOpen32;
112
113 dprintf(("KERNEL32: HandleManager::Mutex::CreateMutex(%08xh,%08xh,%08xh,%s)\n",
114 pHMHandleData,
115 lpsa,
116 fInitialOwner,
117 lpszMutexName));
118
119 hOpen32 = O32_CreateMutex(lpsa, // call Open32
120 fInitialOwner,
121 lpszMutexName);
122
123 if (0 != hOpen32) // check success
124 {
125 pHMHandleData->hHMHandle = hOpen32; // save handle
126 return (NO_ERROR);
127 }
128 else
129 return (O32_GetLastError());
130#endif
131}
132
133
134/*****************************************************************************
135 * Name : HMOpenMutex
136 * Purpose : router function for OpenMutex
137 * Parameters:
138 * Variables :
139 * Result :
140 * Remark :
141 * Status :
142 *
143 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
144 *****************************************************************************/
145
146DWORD HMDeviceMutexClass::OpenMutex(PHMHANDLEDATA pHMHandleData,
147 BOOL fInheritHandle,
148 LPCTSTR lpszMutexName)
149{
150#ifdef USE_OS2SEMAPHORES
151 HMTX hmtx;
152 APIRET rc;
153 char szSemName[CCHMAXPATH];
154
155 dprintf(("KERNEL32: HandleManager::Mutex::OpenMutex(%08xh,%08xh,%s)\n",
156 pHMHandleData,
157 fInheritHandle,
158 lpszMutexName));
159
160 if(lpszMutexName == NULL) {
161 pHMHandleData->hHMHandle = 0;
162 return ERROR_INVALID_PARAMETER_W;
163 }
164
165 strcpy(szSemName, "\\SEM32\\");
166 strcat(szSemName, lpszMutexName);
167 rc = DosOpenMutexSem(szSemName, &hmtx);
168 if(rc) {
169 dprintf(("DosOpenMutexSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));
170 pHMHandleData->hHMHandle = 0;
171 return error2WinError(rc);
172 }
173 pHMHandleData->hHMHandle = hmtx;
174 pHMHandleData->dwInternalType = HMTYPE_MUTEXSEM;
175 return ERROR_SUCCESS_W;
176#else
177 HANDLE hOpen32;
178
179 dprintf(("KERNEL32: HandleManager::Mutex::OpenMutex(%08xh,%08xh,%s)\n",
180 pHMHandleData,
181 fInheritHandle,
182 lpszMutexName));
183
184 hOpen32 = O32_OpenMutex(pHMHandleData->dwAccess, // call Open32
185 fInheritHandle,
186 lpszMutexName);
187
188 if (0 != hOpen32) // check success
189 {
190 pHMHandleData->hHMHandle = hOpen32; // save handle
191 return (NO_ERROR);
192 }
193 else
194 return (O32_GetLastError());
195#endif
196}
197
198/*****************************************************************************
199 * Name : HMDeviceMutexClass::CloseHandle
200 * Purpose : close the handle
201 * Parameters: PHMHANDLEDATA pHMHandleData
202 * Variables :
203 * Result : API returncode
204 * Remark :
205 * Status :
206 *
207 * Author :
208 *****************************************************************************/
209
210#ifdef USE_OS2SEMAPHORES
211BOOL HMDeviceMutexClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
212{
213 APIRET rc;
214
215 if(pHMHandleData->hHMHandle) {
216 rc = DosCloseMutexSem((HEV)pHMHandleData->hHMHandle);
217 if(rc) {
218 dprintf(("DosCloseMutexSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));
219 SetLastError(error2WinError(rc));
220 return FALSE;
221 }
222 }
223 return TRUE;
224}
225#endif
226
227/*****************************************************************************
228 * Name : HMDeviceMutexClass::DuplicateHandle
229 * Purpose :
230 * Parameters:
231 * various parameters as required
232 * Variables :
233 * Result :
234 * Remark : the standard behaviour is to return an error code for non-
235 * existant request codes
236 * Status :
237 *
238 * Author :
239 *****************************************************************************/
240#ifdef USE_OS2SEMAPHORES
241BOOL HMDeviceMutexClass::DuplicateHandle(PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,
242 PHMHANDLEDATA pHMSrcHandle,
243 HANDLE destprocess,
244 PHANDLE desthandle,
245 DWORD fdwAccess,
246 BOOL fInherit,
247 DWORD fdwOptions,
248 DWORD fdwOdinOptions)
249{
250 APIRET rc;
251 HMTX hmtx;
252
253 dprintf(("KERNEL32:HandleManager::DuplicateHandle %s(%08x,%08x,%08x,%08x,%08x) - NOT IMPLEMENTED!!!!!!!!\n",
254 lpHMDeviceName,
255 pHMHandleData,
256 srcprocess, pHMSrcHandle, destprocess, desthandle));
257
258 if(srcprocess != destprocess) {
259 DebugInt3();
260 SetLastError(ERROR_ACCESS_DENIED_W);
261 return FALSE;
262 }
263 hmtx = (HMTX)pHMSrcHandle->hHMHandle;
264 rc = DosOpenMutexSem(NULL, &hmtx);
265 if(rc) {
266 dprintf(("DosOpenMutexSem %x failed with rc %d", pHMSrcHandle->hHMHandle, rc));
267 pHMHandleData->hHMHandle = 0;
268 SetLastError(error2WinError(rc));
269 return FALSE;
270 }
271 pHMHandleData->dwAccess = fdwAccess;
272 pHMHandleData->hHMHandle = hmtx;
273 pHMHandleData->dwInternalType = HMTYPE_MUTEXSEM;
274 SetLastError(ERROR_SUCCESS_W);
275 return TRUE;
276}
277#endif
278
279
280#ifdef USE_OS2SEMAPHORES
281/*****************************************************************************
282 * Name : DWORD HMDeviceOpen32Class::WaitForSingleObject
283 * Purpose : object synchronization
284 * Parameters: PHMHANDLEDATA pHMHandleData
285 * DWORD dwTimeout
286 * Variables :
287 * Result : API returncode
288 * Remark :
289 * Status :
290 *
291 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
292 *****************************************************************************/
293
294DWORD HMDeviceMutexClass::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
295 DWORD dwTimeout)
296{
297 DWORD rc;
298
299 dprintf2(("KERNEL32: HMDeviceMutexClass::WaitForSingleObject(%08xh %08xh)",
300 pHMHandleData->hHMHandle, dwTimeout));
301
302 if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
303 {
304 dprintf(("ERROR: Access denied!!"));
305 SetLastError(ERROR_ACCESS_DENIED_W);
306 return FALSE;
307 }
308
309 rc = DosRequestMutexSem(pHMHandleData->hHMHandle, dwTimeout);
310 if(rc && rc != ERROR_INTERRUPT && rc != ERROR_TIMEOUT && rc != ERROR_SEM_OWNER_DIED) {
311 dprintf(("DosWaitEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));
312 SetLastError(error2WinError(rc));
313 return WAIT_FAILED_W;
314 }
315 SetLastError(ERROR_SUCCESS_W);
316 if(rc == ERROR_INTERRUPT || rc == ERROR_SEM_OWNER_DIED) {
317 return WAIT_ABANDONED_W;
318 }
319 else
320 if(rc == ERROR_TIMEOUT) {
321 return WAIT_TIMEOUT_W;
322 }
323 return WAIT_OBJECT_0_W;
324}
325#endif
326
327#ifdef USE_OS2SEMAPHORES
328/*****************************************************************************
329 * Name : DWORD HMDeviceOpen32Class::WaitForSingleObjectEx
330 * Purpose : object synchronization
331 * Parameters: PHMHANDLEDATA pHMHandleData
332 * DWORD dwTimeout
333 * BOOL fAlertable
334 * Variables :
335 * Result : API returncode
336 * Remark :
337 * Status :
338 *
339 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
340 *****************************************************************************/
341
342DWORD HMDeviceMutexClass::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
343 DWORD dwTimeout,
344 BOOL fAlertable)
345{
346 dprintf2(("KERNEL32: HMDeviceMutexClass::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",
347 pHMHandleData->hHMHandle, dwTimeout, fAlertable));
348
349 if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
350 {
351 dprintf(("ERROR: Access denied!!"));
352 SetLastError(ERROR_ACCESS_DENIED_W);
353 return WAIT_FAILED_W;
354 }
355
356 return WaitForSingleObject(pHMHandleData, dwTimeout);
357}
358#endif
359
360#ifdef USE_OS2SEMAPHORES
361/*****************************************************************************
362 * Name : BOOL HMDeviceMutexClass::MsgWaitForMultipleObjects
363 * Purpose :
364 * Variables :
365 * Result :
366 * Remark :
367 * Status :
368 *
369 * Author : SvL
370 *****************************************************************************/
371DWORD HMDeviceMutexClass::MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
372 DWORD nCount,
373 PHANDLE pHandles,
374 BOOL fWaitAll,
375 DWORD dwMilliseconds,
376 DWORD dwWakeMask)
377{
378 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::MsgWaitForMultipleObjects %08x %d %x %d %d %x",
379 pHMHandleData->hHMHandle, nCount, pHandles, fWaitAll, dwMilliseconds, dwWakeMask));
380
381 if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
382 {
383 dprintf(("ERROR: Access denied!!"));
384 SetLastError(ERROR_ACCESS_DENIED_W);
385 return WAIT_FAILED_W;
386 }
387 return WAIT_FAILED_W;
388}
389#endif
390
391#ifdef USE_OS2SEMAPHORES
392/*****************************************************************************
393 * Name : BOOL HMDeviceMutexClass::WaitForMultipleObjects
394 * Purpose :
395 * Variables :
396 * Result :
397 * Remark :
398 * Status :
399 *
400 * Author : SvL
401 *****************************************************************************/
402DWORD HMDeviceMutexClass::WaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
403 DWORD cObjects,
404 PHANDLE lphObjects,
405 BOOL fWaitAll,
406 DWORD dwTimeout)
407{
408 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForMultipleObjects %08x %d %x %d %x",
409 pHMHandleData->hHMHandle, cObjects, lphObjects, fWaitAll, dwTimeout));
410
411 if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
412 {
413 dprintf(("ERROR: Access denied!!"));
414 SetLastError(ERROR_ACCESS_DENIED_W);
415 return WAIT_FAILED_W;
416 }
417 return WAIT_FAILED_W;
418}
419#endif
420
421/*****************************************************************************
422 * Name : HMReleaseMutex
423 * Purpose : router function for ReleaseMutex
424 * Parameters:
425 * Variables :
426 * Result :
427 * Remark :
428 * Status :
429 *
430 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
431 *****************************************************************************/
432
433BOOL HMDeviceMutexClass::ReleaseMutex(PHMHANDLEDATA pHMHandleData)
434{
435#ifdef USE_OS2SEMAPHORES
436 APIRET rc;
437
438 dprintf(("KERNEL32: HandleManager::Mutex::ReleaseMutex(%08xh)\n",
439 pHMHandleData->hHMHandle));
440
441 rc = DosReleaseMutexSem(pHMHandleData->hHMHandle);
442 if(rc) {
443 dprintf(("DosReleaseMutexSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));
444 SetLastError(error2WinError(rc));
445 return FALSE;
446 }
447 SetLastError(ERROR_SUCCESS_W);
448 return TRUE;
449#else
450 dprintf(("KERNEL32: HandleManager::Mutex::ReleaseMutex(%08xh)\n",
451 pHMHandleData->hHMHandle));
452
453 return (O32_ReleaseMutex(pHMHandleData->hHMHandle));
454#endif
455}
456
Note: See TracBrowser for help on using the repository browser.