- Timestamp:
- Feb 4, 2003, 12:29:03 PM (23 years ago)
- Location:
- trunk/src/kernel32
- Files:
-
- 18 edited
-
HandleManager.cpp (modified) (3 diffs)
-
hmdevice.cpp (modified) (3 diffs)
-
hmdevice.h (modified) (3 diffs)
-
hmevent.cpp (modified) (10 diffs)
-
hmevent.h (modified) (3 diffs)
-
hmfile.cpp (modified) (2 diffs)
-
hmfile.h (modified) (2 diffs)
-
hmmutex.cpp (modified) (7 diffs)
-
hmmutex.h (modified) (3 diffs)
-
hmopen32.cpp (modified) (2 diffs)
-
hmopen32.h (modified) (2 diffs)
-
hmsemaphore.cpp (modified) (10 diffs)
-
hmsemaphore.h (modified) (5 diffs)
-
hmthread.cpp (modified) (15 diffs)
-
hmthread.h (modified) (2 diffs)
-
kobjects.cpp (modified) (2 diffs)
-
stubs.cpp (modified) (2 diffs)
-
thread.cpp (modified) (2 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/kernel32/HandleManager.cpp
r9660 r9748 1 /* $Id: HandleManager.cpp,v 1.9 3 2003-01-10 15:19:53sandervl Exp $ */1 /* $Id: HandleManager.cpp,v 1.94 2003-02-04 11:28:55 sandervl Exp $ */ 2 2 3 3 /* … … 959 959 TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler; 960 960 /* call the device handler */ 961 rc = pDeviceHandler->DuplicateHandle(&TabWin32Handles[iIndexNew].hmHandleData, 961 rc = pDeviceHandler->DuplicateHandle(srchandle, 962 &TabWin32Handles[iIndexNew].hmHandleData, 962 963 srcprocess, 963 964 &TabWin32Handles[srchandle].hmHandleData, … … 4285 4286 } 4286 4287 /***************************************************************************** 4288 * Name : HMGetThreadTimes 4289 * Purpose : router function for HMGetThreadTimes 4290 * Parameters: 4291 * Variables : 4292 * Result : 4293 * Remark : 4294 * Status : 4295 * 4296 * Author : SvL 4297 *****************************************************************************/ 4298 BOOL HMGetThreadTimes(HANDLE hThread, LPFILETIME lpCreationTime, 4299 LPFILETIME lpExitTime, LPFILETIME lpKernelTime, 4300 LPFILETIME lpUserTime) 4301 { 4302 int iIndex; /* index into the handle table */ 4303 BOOL lpResult; /* result from the device handler's API */ 4304 PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */ 4305 4306 SetLastError(ERROR_SUCCESS); 4307 /* validate handle */ 4308 iIndex = _HMHandleQuery(hThread); /* get the index */ 4309 if (-1 == iIndex) /* error ? */ 4310 { 4311 SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */ 4312 return FALSE; /* signal failure */ 4313 } 4314 4315 pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */ 4316 lpResult = pHMHandle->pDeviceHandler->GetThreadTimes(hThread, &TabWin32Handles[iIndex].hmHandleData, 4317 lpCreationTime, lpExitTime, 4318 lpKernelTime, lpUserTime); 4319 4320 return (lpResult); /* deliver return code */ 4321 } 4322 /***************************************************************************** 4287 4323 * Name : HMTerminateThread 4288 4324 * Purpose : router function for TerminateThread -
trunk/src/kernel32/hmdevice.cpp
r9653 r9748 1 /* $Id: hmdevice.cpp,v 1.3 3 2003-01-10 12:57:12sandervl Exp $ */1 /* $Id: hmdevice.cpp,v 1.34 2003-02-04 11:28:56 sandervl Exp $ */ 2 2 3 3 /* … … 135 135 * Author : Patrick Haller [Wed, 1998/02/11 20:44] 136 136 *****************************************************************************/ 137 BOOL HMDeviceHandler::DuplicateHandle( PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,137 BOOL HMDeviceHandler::DuplicateHandle(HANDLE srchandle, PHMHANDLEDATA pHMHandleData, HANDLE srcprocess, 138 138 PHMHANDLEDATA pHMSrcHandle, 139 139 HANDLE destprocess, … … 1507 1507 return FALSE; 1508 1508 } 1509 /***************************************************************************** 1510 * Name : DWORD HMDeviceHandler::SetThreadContext 1511 * Purpose : 1512 * Variables : 1513 * Result : 1514 * Remark : 1515 * Status : 1516 * 1517 * Author : SvL 1518 *****************************************************************************/ 1519 BOOL HMDeviceHandler::GetThreadTimes(HANDLE hThread, 1520 PHMHANDLEDATA pHMHandleData, 1521 LPFILETIME lpCreationTime, 1522 LPFILETIME lpExitTime, 1523 LPFILETIME lpKernelTime, 1524 LPFILETIME lpUserTime) 1525 { 1526 dprintf(("Kernel32: ERROR: GetThreadTimes(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n", 1527 hThread, 1528 lpCreationTime, 1529 lpExitTime, 1530 lpKernelTime, 1531 lpUserTime)); 1532 1533 return FALSE; 1534 } 1535 1509 1536 /***************************************************************************** 1510 1537 * Name : DWORD HMDeviceHandler::TerminateThread -
trunk/src/kernel32/hmdevice.h
r9653 r9748 1 /* $Id: hmdevice.h,v 1.3 3 2003-01-10 12:57:13sandervl Exp $ */1 /* $Id: hmdevice.h,v 1.34 2003-02-04 11:28:56 sandervl Exp $ */ 2 2 3 3 /* … … 92 92 ULONG arg4); 93 93 94 virtual BOOL DuplicateHandle( PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,94 virtual BOOL DuplicateHandle(HANDLE srchandle, PHMHANDLEDATA pHMHandleData, HANDLE srcprocess, 95 95 PHMHANDLEDATA pHMSrcHandle, 96 96 HANDLE destprocess, … … 397 397 virtual BOOL GetThreadContext(HANDLE hThread, PHMHANDLEDATA pHMHandleData, PCONTEXT lpContext); 398 398 virtual BOOL SetThreadContext(HANDLE hThread, PHMHANDLEDATA pHMHandleData, const CONTEXT *lpContext); 399 virtual BOOL GetThreadTimes(HANDLE hThread, PHMHANDLEDATA pHMHandleData, 400 FILETIME *lpCreationTime, FILETIME *lpExitTime, 401 FILETIME *lpKernelTime, FILETIME *lpUserTime); 399 402 400 403 virtual BOOL TerminateThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData, DWORD exitcode); -
trunk/src/kernel32/hmevent.cpp
r6084 r9748 1 /* $Id: hmevent.cpp,v 1. 8 2001-06-23 16:59:27 sandervl Exp $ */1 /* $Id: hmevent.cpp,v 1.9 2003-02-04 11:28:57 sandervl Exp $ */ 2 2 3 3 /* … … 30 30 *****************************************************************************/ 31 31 32 #ifdef USE_OS2SEMAPHORES33 #define INCL_DOSSEMAPHORES34 #define INCL_DOSERRORS35 #include <os2wrap.h>36 #include <win32type.h>37 #include <win32api.h>38 #include <winconst.h>39 #else40 32 #include <os2win.h> 41 #endif42 33 43 34 #include <stdlib.h> … … 53 44 #define DBG_LOCALLOG DBG_hmevent 54 45 #include "dbglocal.h" 55 56 #ifndef DCE_AUTORESET57 #define DCE_AUTORESET 0x1000 /* DosCreateEventSem option to auto-reset */58 /* event semaphore on post. */59 #define DCE_POSTONE 0x0800 /* DosCreateEventSem option to post only */60 /* waiter and auto-reset the semaphore when*/61 /* there are multiple waiters. */62 #endif63 46 64 47 /***************************************************************************** … … 93 76 LPCTSTR lpszEventName) 94 77 { 95 #ifdef USE_OS2SEMAPHORES96 APIRET rc;97 HEV hev;98 char szSemName[CCHMAXPATH];99 100 dprintf(("KERNEL32: HandleManager::Event::CreateEvent(%08xh,%08xh,%08xh,%08xh,%s)\n",101 pHMHandleData,102 lpsa,103 fManualReset,104 fInitialState,105 lpszEventName));106 107 if(lpszEventName) {108 strcpy(szSemName, "\\SEM32\\");109 strcat(szSemName, lpszEventName);110 lpszEventName = szSemName;111 FixSemName((char *)lpszEventName);112 }113 //Manual reset means all threads waiting on the event semaphore will be114 //unblocked and the app must manually reset the event semaphore115 //Automatic reset -> only one waiting thread unblocked & state reset116 rc = DosCreateEventSem(lpszEventName, &hev, (fManualReset) ? 0 : (DCE_POSTONE|DCE_AUTORESET), fInitialState);117 118 if(rc) {119 dprintf(("DosCreateEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));120 pHMHandleData->hHMHandle = 0;121 return error2WinError(rc);122 }123 pHMHandleData->dwAccess = EVENT_ALL_ACCESS_W;124 pHMHandleData->dwFlags = fManualReset;125 pHMHandleData->hHMHandle = hev;126 pHMHandleData->dwInternalType = HMTYPE_EVENTSEM;127 return ERROR_SUCCESS_W;128 #else129 78 HANDLE hOpen32; 130 79 … … 147 96 } 148 97 else 149 return (O32_GetLastError()); 150 #endif 98 return (GetLastError()); 151 99 } 152 100 … … 168 116 LPCTSTR lpszEventName) 169 117 { 170 #ifdef USE_OS2SEMAPHORES171 HEV hev;172 APIRET rc;173 char szSemName[CCHMAXPATH];174 175 dprintf(("KERNEL32: HandleManager::Event::OpenEvent(%08xh,%08xh,%s)\n",176 pHMHandleData,177 fInheritHandle,178 lpszEventName));179 180 if(lpszEventName == NULL) {181 pHMHandleData->hHMHandle = 0;182 return ERROR_INVALID_PARAMETER_W;183 }184 185 strcpy(szSemName, "\\SEM32\\");186 strcat(szSemName, lpszEventName);187 FixSemName(szSemName);188 rc = DosOpenEventSem(szSemName, &hev);189 if(rc) {190 dprintf(("DosOpenEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));191 pHMHandleData->hHMHandle = 0;192 return error2WinError(rc);193 }194 pHMHandleData->dwInternalType = HMTYPE_EVENTSEM;195 pHMHandleData->hHMHandle = hev;196 return ERROR_SUCCESS_W;197 #else198 118 HANDLE hOpen32; 199 119 … … 213 133 } 214 134 else 215 return (O32_GetLastError()); 216 #endif 135 return (GetLastError()); 217 136 } 218 219 /*****************************************************************************220 * Name : HMDeviceEventClass::CloseHandle221 * Purpose : close the handle222 * Parameters: PHMHANDLEDATA pHMHandleData223 * Variables :224 * Result : API returncode225 * Remark :226 * Status :227 *228 * Author :229 *****************************************************************************/230 231 #ifdef USE_OS2SEMAPHORES232 BOOL HMDeviceEventClass::CloseHandle(PHMHANDLEDATA pHMHandleData)233 {234 APIRET rc;235 236 if(pHMHandleData->hHMHandle) {237 rc = DosCloseEventSem((HEV)pHMHandleData->hHMHandle);238 if(rc) {239 dprintf(("DosCloseEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));240 SetLastError(error2WinError(rc));241 return FALSE;242 }243 }244 return TRUE;245 }246 #endif247 248 /*****************************************************************************249 * Name : HMDeviceEventClass::DuplicateHandle250 * Purpose :251 * Parameters:252 * various parameters as required253 * Variables :254 * Result :255 * Remark : the standard behaviour is to return an error code for non-256 * existant request codes257 * Status :258 *259 * Author :260 *****************************************************************************/261 #ifdef USE_OS2SEMAPHORES262 BOOL HMDeviceEventClass::DuplicateHandle(PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,263 PHMHANDLEDATA pHMSrcHandle,264 HANDLE destprocess,265 PHANDLE desthandle,266 DWORD fdwAccess,267 BOOL fInherit,268 DWORD fdwOptions,269 DWORD fdwOdinOptions)270 {271 APIRET rc;272 HEV hev;273 274 dprintf(("KERNEL32:HandleManager::DuplicateHandle %s(%08x,%08x,%08x,%08x,%08x) - NOT IMPLEMENTED!!!!!!!!\n",275 lpHMDeviceName,276 pHMHandleData,277 srcprocess, pHMSrcHandle, destprocess, desthandle));278 279 if(srcprocess != destprocess) {280 DebugInt3();281 SetLastError(ERROR_ACCESS_DENIED_W);282 return FALSE;283 }284 hev = (HEV)pHMSrcHandle->hHMHandle;285 rc = DosOpenEventSem(NULL, &hev);286 if(rc) {287 dprintf(("DosOpenEventSem %x failed with rc %d", pHMSrcHandle->hHMHandle, rc));288 pHMHandleData->hHMHandle = 0;289 SetLastError(error2WinError(rc));290 return FALSE;291 }292 pHMHandleData->dwAccess = fdwAccess;293 pHMHandleData->dwFlags = pHMSrcHandle->dwFlags; //fManualReset294 pHMHandleData->hHMHandle = hev;295 pHMHandleData->dwInternalType = HMTYPE_EVENTSEM;296 SetLastError(ERROR_SUCCESS_W);297 return TRUE;298 }299 #endif300 301 #ifdef USE_OS2SEMAPHORES302 /*****************************************************************************303 * Name : DWORD HMDeviceEventClass::WaitForSingleObject304 * Purpose : object synchronization305 * Parameters: PHMHANDLEDATA pHMHandleData306 * DWORD dwTimeout307 * Variables :308 * Result : API returncode309 * Remark :310 * Status :311 *312 * Author : SvL313 *****************************************************************************/314 315 DWORD HMDeviceEventClass::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,316 DWORD dwTimeout)317 {318 DWORD rc;319 320 dprintf2(("KERNEL32: HMDeviceEventClass::WaitForSingleObject(%08xh %08xh)",321 pHMHandleData->hHMHandle, dwTimeout));322 323 if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )324 {325 dprintf(("ERROR: Access denied!!"));326 SetLastError(ERROR_ACCESS_DENIED_W);327 return WAIT_FAILED_W;328 }329 330 rc = DosWaitEventSem(pHMHandleData->hHMHandle, dwTimeout);331 if(rc && rc != ERROR_INTERRUPT && rc != ERROR_TIMEOUT && rc != ERROR_SEM_OWNER_DIED) {332 dprintf(("DosWaitEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));333 SetLastError(error2WinError(rc));334 return WAIT_FAILED_W;335 }336 SetLastError(ERROR_SUCCESS_W);337 if(rc == ERROR_INTERRUPT || rc == ERROR_SEM_OWNER_DIED) {338 return WAIT_ABANDONED_W;339 }340 else341 if(rc == ERROR_TIMEOUT) {342 return WAIT_TIMEOUT_W;343 }344 return WAIT_OBJECT_0_W;345 }346 #endif347 348 #ifdef USE_OS2SEMAPHORES349 /*****************************************************************************350 * Name : DWORD HMDeviceEventClass::WaitForSingleObjectEx351 * Purpose : object synchronization352 * Parameters: PHMHANDLEDATA pHMHandleData353 * DWORD dwTimeout354 * BOOL fAlertable355 * Variables :356 * Result : API returncode357 * Remark :358 * Status :359 *360 * Author : SvL361 *****************************************************************************/362 363 DWORD HMDeviceEventClass::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,364 DWORD dwTimeout,365 BOOL fAlertable)366 {367 dprintf2(("KERNEL32: HMDeviceEventClass::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",368 pHMHandleData->hHMHandle, dwTimeout, fAlertable));369 370 if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )371 {372 dprintf(("ERROR: Access denied!!"));373 SetLastError(ERROR_ACCESS_DENIED_W);374 return WAIT_FAILED_W;375 }376 377 return WaitForSingleObject(pHMHandleData, dwTimeout);378 }379 #endif380 381 #ifdef USE_OS2SEMAPHORES382 /*****************************************************************************383 * Name : BOOL HMDeviceEventClass::MsgWaitForMultipleObjects384 * Purpose :385 * Variables :386 * Result :387 * Remark :388 * Status :389 *390 * Author : SvL391 *****************************************************************************/392 DWORD HMDeviceEventClass::MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,393 DWORD nCount,394 PHANDLE pHandles,395 BOOL fWaitAll,396 DWORD dwMilliseconds,397 DWORD dwWakeMask)398 {399 return HMSemMsgWaitForMultipleObjects(nCount, pHandles, fWaitAll, dwMilliseconds, dwWakeMask);400 }401 #endif402 403 #ifdef USE_OS2SEMAPHORES404 /*****************************************************************************405 * Name : BOOL HMDeviceHandler::WaitForMultipleObjects406 * Purpose :407 * Variables :408 * Result :409 * Remark :410 * Status :411 *412 * Author : SvL413 *****************************************************************************/414 DWORD HMDeviceEventClass::WaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,415 DWORD cObjects,416 PHANDLE lphObjects,417 BOOL fWaitAll,418 DWORD dwTimeout)419 {420 return HMSemWaitForMultipleObjects(cObjects, lphObjects, fWaitAll, dwTimeout);421 }422 #endif423 137 424 138 /***************************************************************************** … … 436 150 BOOL HMDeviceEventClass::SetEvent(PHMHANDLEDATA pHMHandleData) 437 151 { 438 #ifdef USE_OS2SEMAPHORES439 APIRET rc;440 441 dprintf(("KERNEL32: HandleManager::Event::SetEvent(%08xh)\n",442 pHMHandleData->hHMHandle));443 444 if(!(pHMHandleData->dwAccess & EVENT_MODIFY_STATE_W) )445 {446 dprintf(("ERROR: Access denied!!"));447 SetLastError(ERROR_ACCESS_DENIED_W);448 return FALSE;449 }450 451 rc = DosPostEventSem(pHMHandleData->hHMHandle);452 if(rc && rc != ERROR_ALREADY_POSTED) {453 dprintf(("DosPostEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));454 SetLastError(error2WinError(rc));455 return FALSE;456 }457 SetLastError(ERROR_SUCCESS_W);458 return TRUE;459 #else460 152 dprintf(("KERNEL32: HandleManager::Event::SetEvent(%08xh)\n", 461 153 pHMHandleData->hHMHandle)); 462 154 463 155 return (O32_SetEvent(pHMHandleData->hHMHandle)); 464 #endif465 156 } 466 157 … … 480 171 BOOL HMDeviceEventClass::PulseEvent(PHMHANDLEDATA pHMHandleData) 481 172 { 482 #ifdef USE_OS2SEMAPHORES483 APIRET rc;484 ULONG count;485 486 dprintf2(("KERNEL32: HandleManager::Event::PulseEvent(%08xh)\n",487 pHMHandleData->hHMHandle));488 489 if(!(pHMHandleData->dwAccess & EVENT_MODIFY_STATE_W) )490 {491 dprintf(("ERROR: Access denied!!"));492 SetLastError(ERROR_ACCESS_DENIED_W);493 return FALSE;494 }495 496 rc = DosPostEventSem(pHMHandleData->hHMHandle);497 if(rc && rc != ERROR_ALREADY_POSTED) {498 dprintf(("DosPostEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));499 SetLastError(error2WinError(rc));500 return FALSE;501 }502 if(pHMHandleData->dwFlags == TRUE) {//fManualReset503 rc = DosResetEventSem(pHMHandleData->hHMHandle, &count);504 if(rc && rc != ERROR_ALREADY_RESET) {505 dprintf(("DosResetEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));506 SetLastError(error2WinError(rc));507 return FALSE;508 }509 }510 SetLastError(ERROR_SUCCESS_W);511 return TRUE;512 #else513 173 dprintf2(("KERNEL32: HandleManager::Event::PulseEvent(%08xh)\n", 514 174 pHMHandleData->hHMHandle)); 515 175 516 176 return (O32_PulseEvent(pHMHandleData->hHMHandle)); 517 #endif518 177 } 519 178 … … 533 192 BOOL HMDeviceEventClass::ResetEvent(PHMHANDLEDATA pHMHandleData) 534 193 { 535 #ifdef USE_OS2SEMAPHORES536 APIRET rc;537 ULONG count;538 539 dprintf2(("KERNEL32: HandleManager::Event::ResetEvent(%08xh)\n",540 pHMHandleData->hHMHandle));541 542 if(!(pHMHandleData->dwAccess & EVENT_MODIFY_STATE_W) )543 {544 dprintf(("ERROR: Access denied!!"));545 SetLastError(ERROR_ACCESS_DENIED_W);546 return FALSE;547 }548 549 rc = DosResetEventSem(pHMHandleData->hHMHandle, &count);550 if(rc && rc != ERROR_ALREADY_RESET) {551 dprintf(("DosResetEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));552 SetLastError(error2WinError(rc));553 return FALSE;554 }555 SetLastError(ERROR_SUCCESS_W);556 return TRUE;557 #else558 194 dprintf2(("KERNEL32: HandleManager::Event::ResetEvent(%08xh)\n", 559 195 pHMHandleData->hHMHandle)); 560 196 561 197 return (O32_ResetEvent(pHMHandleData->hHMHandle)); 562 #endif563 198 } 564 199 -
trunk/src/kernel32/hmevent.h
r6060 r9748 1 /* $Id: hmevent.h,v 1. 4 2001-06-21 21:07:53sandervl Exp $ */1 /* $Id: hmevent.h,v 1.5 2003-02-04 11:28:57 sandervl Exp $ */ 2 2 3 3 /* … … 29 29 *****************************************************************************/ 30 30 31 #ifdef USE_OS2SEMAPHORES32 class HMDeviceEventClass : public HMDeviceHandler33 #else34 31 class HMDeviceEventClass : public HMDeviceOpen32Class 35 #endif36 32 { 37 33 public: 38 #ifdef USE_OS2SEMAPHORES39 HMDeviceEventClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName) {}40 #else41 34 HMDeviceEventClass(LPCSTR lpDeviceName) : HMDeviceOpen32Class(lpDeviceName) {} 42 #endif43 35 44 36 /* this is a handler method for calls to CreateEvent() */ … … 48 40 BOOL fInitialState, 49 41 LPCTSTR lpszEventName); 50 51 #ifdef USE_OS2SEMAPHORES52 virtual BOOL CloseHandle(PHMHANDLEDATA pHMHandleData);53 54 virtual BOOL DuplicateHandle(PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,55 PHMHANDLEDATA pHMSrcHandle,56 HANDLE destprocess,57 PHANDLE desthandle,58 DWORD fdwAccess,59 BOOL fInherit,60 DWORD fdwOptions,61 DWORD fdwOdinOptions);62 63 /* this is a handler method for calls to WaitForSingleObject */64 virtual DWORD WaitForSingleObject (PHMHANDLEDATA pHMHandleData,65 DWORD dwTimeout);66 67 /* this is a handler method for calls to WaitForSingleObjectEx */68 virtual DWORD WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,69 DWORD dwTimeout,70 BOOL fAlertable);71 72 virtual DWORD MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,73 DWORD nCount,74 PHANDLE pHandles,75 BOOL fWaitAll,76 DWORD dwMilliseconds,77 DWORD dwWakeMask);78 79 virtual DWORD WaitForMultipleObjects (PHMHANDLEDATA pHMHandleData,80 DWORD cObjects,81 PHANDLE lphObjects,82 BOOL fWaitAll,83 DWORD dwTimeout);84 85 #endif86 42 87 43 /* this is a handler method for calls to OpenEvent() */ -
trunk/src/kernel32/hmfile.cpp
r9653 r9748 1 /* $Id: hmfile.cpp,v 1.3 8 2003-01-10 12:57:13sandervl Exp $ */1 /* $Id: hmfile.cpp,v 1.39 2003-02-04 11:28:57 sandervl Exp $ */ 2 2 3 3 /* … … 305 305 * Author : SvL 306 306 *****************************************************************************/ 307 BOOL HMDeviceFileClass::DuplicateHandle( PHMHANDLEDATA pHMHandleData,307 BOOL HMDeviceFileClass::DuplicateHandle(HANDLE srchandle, PHMHANDLEDATA pHMHandleData, 308 308 HANDLE srcprocess, 309 309 PHMHANDLEDATA pHMSrcHandle, -
trunk/src/kernel32/hmfile.h
r9653 r9748 1 /* $Id: hmfile.h,v 1. 8 2003-01-10 12:57:13sandervl Exp $ */1 /* $Id: hmfile.h,v 1.9 2003-02-04 11:28:58 sandervl Exp $ */ 2 2 3 3 /* … … 56 56 UINT fuMode); 57 57 58 virtual BOOL DuplicateHandle( PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,58 virtual BOOL DuplicateHandle(HANDLE srchandle, PHMHANDLEDATA pHMHandleData, HANDLE srcprocess, 59 59 PHMHANDLEDATA pHMSrcHandle, 60 60 HANDLE destprocess, -
trunk/src/kernel32/hmmutex.cpp
r6084 r9748 1 /* $Id: hmmutex.cpp,v 1. 7 2001-06-23 16:59:28 sandervl Exp $ */1 /* $Id: hmmutex.cpp,v 1.8 2003-02-04 11:28:58 sandervl Exp $ */ 2 2 3 3 /* … … 29 29 *****************************************************************************/ 30 30 31 #ifdef USE_OS2SEMAPHORES32 #define INCL_DOSSEMAPHORES33 #define INCL_DOSERRORS34 #include <os2wrap.h>35 #include <win32type.h>36 #include <win32api.h>37 #include <winconst.h>38 #else39 31 #include <os2win.h> 40 #endif41 32 #include <stdlib.h> 42 33 #include <string.h> … … 82 73 LPCTSTR lpszMutexName) 83 74 { 84 #ifdef USE_OS2SEMAPHORES85 APIRET rc;86 HMTX htmx;87 char szSemName[CCHMAXPATH];88 89 dprintf(("KERNEL32: HandleManager::Mutex::CreateMutex(%08xh,%08xh,%08xh,%s)\n",90 pHMHandleData,91 lpsa,92 fInitialOwner,93 lpszMutexName));94 95 if(lpszMutexName) {96 strcpy(szSemName, "\\SEM32\\");97 strcat(szSemName, lpszMutexName);98 lpszMutexName = szSemName;99 FixSemName((char *)lpszMutexName);100 }101 rc = DosCreateMutexSem(lpszMutexName, &htmx, 0, fInitialOwner);102 103 if(rc) {104 dprintf(("DosCreateMutexSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));105 pHMHandleData->hHMHandle = 0;106 return error2WinError(rc);107 }108 pHMHandleData->dwAccess = MUTEX_ALL_ACCESS_W;109 pHMHandleData->hHMHandle = htmx;110 pHMHandleData->dwInternalType = HMTYPE_MUTEXSEM;111 return ERROR_SUCCESS_W;112 #else113 75 HANDLE hOpen32; 114 76 … … 129 91 } 130 92 else 131 return (O32_GetLastError()); 132 #endif 93 return (GetLastError()); 133 94 } 134 95 … … 150 111 LPCTSTR lpszMutexName) 151 112 { 152 #ifdef USE_OS2SEMAPHORES153 HMTX hmtx;154 APIRET rc;155 char szSemName[CCHMAXPATH];156 157 dprintf(("KERNEL32: HandleManager::Mutex::OpenMutex(%08xh,%08xh,%s)\n",158 pHMHandleData,159 fInheritHandle,160 lpszMutexName));161 162 if(lpszMutexName == NULL) {163 pHMHandleData->hHMHandle = 0;164 return ERROR_INVALID_PARAMETER_W;165 }166 167 strcpy(szSemName, "\\SEM32\\");168 strcat(szSemName, lpszMutexName);169 FixSemName(szSemName);170 rc = DosOpenMutexSem(szSemName, &hmtx);171 if(rc) {172 dprintf(("DosOpenMutexSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));173 pHMHandleData->hHMHandle = 0;174 return error2WinError(rc);175 }176 pHMHandleData->hHMHandle = hmtx;177 pHMHandleData->dwInternalType = HMTYPE_MUTEXSEM;178 return ERROR_SUCCESS_W;179 #else180 113 HANDLE hOpen32; 181 114 … … 195 128 } 196 129 else 197 return (O32_GetLastError()); 198 #endif 130 return (GetLastError()); 199 131 } 200 201 /*****************************************************************************202 * Name : HMDeviceMutexClass::CloseHandle203 * Purpose : close the handle204 * Parameters: PHMHANDLEDATA pHMHandleData205 * Variables :206 * Result : API returncode207 * Remark :208 * Status :209 *210 * Author :211 *****************************************************************************/212 213 #ifdef USE_OS2SEMAPHORES214 BOOL HMDeviceMutexClass::CloseHandle(PHMHANDLEDATA pHMHandleData)215 {216 APIRET rc;217 218 if(pHMHandleData->hHMHandle) {219 rc = DosCloseMutexSem((HEV)pHMHandleData->hHMHandle);220 if(rc) {221 dprintf(("DosCloseMutexSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));222 SetLastError(error2WinError(rc));223 return FALSE;224 }225 }226 return TRUE;227 }228 #endif229 230 /*****************************************************************************231 * Name : HMDeviceMutexClass::DuplicateHandle232 * Purpose :233 * Parameters:234 * various parameters as required235 * Variables :236 * Result :237 * Remark : the standard behaviour is to return an error code for non-238 * existant request codes239 * Status :240 *241 * Author :242 *****************************************************************************/243 #ifdef USE_OS2SEMAPHORES244 BOOL HMDeviceMutexClass::DuplicateHandle(PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,245 PHMHANDLEDATA pHMSrcHandle,246 HANDLE destprocess,247 PHANDLE desthandle,248 DWORD fdwAccess,249 BOOL fInherit,250 DWORD fdwOptions,251 DWORD fdwOdinOptions)252 {253 APIRET rc;254 HMTX hmtx;255 256 dprintf(("KERNEL32:HandleManager::DuplicateHandle %s(%08x,%08x,%08x,%08x,%08x) - NOT IMPLEMENTED!!!!!!!!\n",257 lpHMDeviceName,258 pHMHandleData,259 srcprocess, pHMSrcHandle, destprocess, desthandle));260 261 if(srcprocess != destprocess) {262 DebugInt3();263 SetLastError(ERROR_ACCESS_DENIED_W);264 return FALSE;265 }266 hmtx = (HMTX)pHMSrcHandle->hHMHandle;267 rc = DosOpenMutexSem(NULL, &hmtx);268 if(rc) {269 dprintf(("DosOpenMutexSem %x failed with rc %d", pHMSrcHandle->hHMHandle, rc));270 pHMHandleData->hHMHandle = 0;271 SetLastError(error2WinError(rc));272 return FALSE;273 }274 pHMHandleData->dwAccess = fdwAccess;275 pHMHandleData->hHMHandle = hmtx;276 pHMHandleData->dwInternalType = HMTYPE_MUTEXSEM;277 SetLastError(ERROR_SUCCESS_W);278 return TRUE;279 }280 #endif281 282 283 #ifdef USE_OS2SEMAPHORES284 /*****************************************************************************285 * Name : DWORD HMDeviceOpen32Class::WaitForSingleObject286 * Purpose : object synchronization287 * Parameters: PHMHANDLEDATA pHMHandleData288 * DWORD dwTimeout289 * Variables :290 * Result : API returncode291 * Remark :292 * Status :293 *294 * Author : Patrick Haller [Wed, 1999/06/17 20:44]295 *****************************************************************************/296 297 DWORD HMDeviceMutexClass::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,298 DWORD dwTimeout)299 {300 DWORD rc;301 302 dprintf2(("KERNEL32: HMDeviceMutexClass::WaitForSingleObject(%08xh %08xh)",303 pHMHandleData->hHMHandle, dwTimeout));304 305 if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )306 {307 dprintf(("ERROR: Access denied!!"));308 SetLastError(ERROR_ACCESS_DENIED_W);309 return FALSE;310 }311 312 rc = DosRequestMutexSem(pHMHandleData->hHMHandle, dwTimeout);313 if(rc && rc != ERROR_INTERRUPT && rc != ERROR_TIMEOUT && rc != ERROR_SEM_OWNER_DIED) {314 dprintf(("DosWaitEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));315 SetLastError(error2WinError(rc));316 return WAIT_FAILED_W;317 }318 SetLastError(ERROR_SUCCESS_W);319 if(rc == ERROR_INTERRUPT || rc == ERROR_SEM_OWNER_DIED) {320 return WAIT_ABANDONED_W;321 }322 else323 if(rc == ERROR_TIMEOUT) {324 return WAIT_TIMEOUT_W;325 }326 return WAIT_OBJECT_0_W;327 }328 #endif329 330 #ifdef USE_OS2SEMAPHORES331 /*****************************************************************************332 * Name : DWORD HMDeviceOpen32Class::WaitForSingleObjectEx333 * Purpose : object synchronization334 * Parameters: PHMHANDLEDATA pHMHandleData335 * DWORD dwTimeout336 * BOOL fAlertable337 * Variables :338 * Result : API returncode339 * Remark :340 * Status :341 *342 * Author : Patrick Haller [Wed, 1999/06/17 20:44]343 *****************************************************************************/344 345 DWORD HMDeviceMutexClass::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,346 DWORD dwTimeout,347 BOOL fAlertable)348 {349 dprintf2(("KERNEL32: HMDeviceMutexClass::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",350 pHMHandleData->hHMHandle, dwTimeout, fAlertable));351 352 if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )353 {354 dprintf(("ERROR: Access denied!!"));355 SetLastError(ERROR_ACCESS_DENIED_W);356 return WAIT_FAILED_W;357 }358 359 return WaitForSingleObject(pHMHandleData, dwTimeout);360 }361 #endif362 363 #ifdef USE_OS2SEMAPHORES364 /*****************************************************************************365 * Name : BOOL HMDeviceMutexClass::MsgWaitForMultipleObjects366 * Purpose :367 * Variables :368 * Result :369 * Remark :370 * Status :371 *372 * Author : SvL373 *****************************************************************************/374 DWORD HMDeviceMutexClass::MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,375 DWORD nCount,376 PHANDLE pHandles,377 BOOL fWaitAll,378 DWORD dwMilliseconds,379 DWORD dwWakeMask)380 {381 return HMSemMsgWaitForMultipleObjects(nCount, pHandles, fWaitAll, dwMilliseconds, dwWakeMask);382 }383 #endif384 385 #ifdef USE_OS2SEMAPHORES386 /*****************************************************************************387 * Name : BOOL HMDeviceMutexClass::WaitForMultipleObjects388 * Purpose :389 * Variables :390 * Result :391 * Remark :392 * Status :393 *394 * Author : SvL395 *****************************************************************************/396 DWORD HMDeviceMutexClass::WaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,397 DWORD cObjects,398 PHANDLE lphObjects,399 BOOL fWaitAll,400 DWORD dwTimeout)401 {402 return HMSemWaitForMultipleObjects(cObjects, lphObjects, fWaitAll, dwTimeout);403 }404 #endif405 132 406 133 /***************************************************************************** … … 418 145 BOOL HMDeviceMutexClass::ReleaseMutex(PHMHANDLEDATA pHMHandleData) 419 146 { 420 #ifdef USE_OS2SEMAPHORES421 APIRET rc;422 423 dprintf(("KERNEL32: HandleManager::Mutex::ReleaseMutex(%08xh)\n",424 pHMHandleData->hHMHandle));425 426 rc = DosReleaseMutexSem(pHMHandleData->hHMHandle);427 if(rc) {428 dprintf(("DosReleaseMutexSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));429 SetLastError(error2WinError(rc));430 return FALSE;431 }432 SetLastError(ERROR_SUCCESS_W);433 return TRUE;434 #else435 147 dprintf(("KERNEL32: HandleManager::Mutex::ReleaseMutex(%08xh)\n", 436 148 pHMHandleData->hHMHandle)); 437 149 438 150 return (O32_ReleaseMutex(pHMHandleData->hHMHandle)); 439 #endif440 151 } 441 152 -
trunk/src/kernel32/hmmutex.h
r6060 r9748 1 /* $Id: hmmutex.h,v 1. 4 2001-06-21 21:07:54sandervl Exp $ */1 /* $Id: hmmutex.h,v 1.5 2003-02-04 11:28:59 sandervl Exp $ */ 2 2 3 3 /* … … 29 29 *****************************************************************************/ 30 30 31 #ifdef USE_OS2SEMAPHORES32 class HMDeviceMutexClass : public HMDeviceHandler33 #else34 31 class HMDeviceMutexClass : public HMDeviceOpen32Class 35 #endif36 32 { 37 33 public: 38 #ifdef USE_OS2SEMAPHORES39 HMDeviceMutexClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName) {}40 #else41 34 HMDeviceMutexClass(LPCSTR lpDeviceName) : HMDeviceOpen32Class(lpDeviceName) {} 42 #endif43 35 44 36 /* this is a handler method for calls to CreateMutex() */ … … 52 44 BOOL fInheritHandle, 53 45 LPCTSTR lpszMutexName); 54 55 #ifdef USE_OS2SEMAPHORES56 virtual BOOL CloseHandle(PHMHANDLEDATA pHMHandleData);57 58 virtual BOOL DuplicateHandle(PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,59 PHMHANDLEDATA pHMSrcHandle,60 HANDLE destprocess,61 PHANDLE desthandle,62 DWORD fdwAccess,63 BOOL fInherit,64 DWORD fdwOptions,65 DWORD fdwOdinOptions);66 67 /* this is a handler method for calls to WaitForSingleObject */68 virtual DWORD WaitForSingleObject (PHMHANDLEDATA pHMHandleData,69 DWORD dwTimeout);70 71 /* this is a handler method for calls to WaitForSingleObjectEx */72 virtual DWORD WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,73 DWORD dwTimeout,74 BOOL fAlertable);75 76 virtual DWORD MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,77 DWORD nCount,78 PHANDLE pHandles,79 BOOL fWaitAll,80 DWORD dwMilliseconds,81 DWORD dwWakeMask);82 83 virtual DWORD WaitForMultipleObjects (PHMHANDLEDATA pHMHandleData,84 DWORD cObjects,85 PHANDLE lphObjects,86 BOOL fWaitAll,87 DWORD dwTimeout);88 #endif89 46 90 47 /* this is a handle method for calls to ReleaseMutex() */ -
trunk/src/kernel32/hmopen32.cpp
r5587 r9748 1 /* $Id: hmopen32.cpp,v 1. 29 2001-04-26 13:22:47sandervl Exp $ */1 /* $Id: hmopen32.cpp,v 1.30 2003-02-04 11:28:59 sandervl Exp $ */ 2 2 3 3 /* … … 111 111 * Author : Patrick Haller [Wed, 1998/02/11 20:44] 112 112 *****************************************************************************/ 113 BOOL HMDeviceOpen32Class::DuplicateHandle( PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,113 BOOL HMDeviceOpen32Class::DuplicateHandle(HANDLE srchandle, PHMHANDLEDATA pHMHandleData, HANDLE srcprocess, 114 114 PHMHANDLEDATA pHMSrcHandle, 115 115 HANDLE destprocess, -
trunk/src/kernel32/hmopen32.h
r5587 r9748 1 /* $Id: hmopen32.h,v 1. 8 2001-04-26 13:22:47sandervl Exp $ */1 /* $Id: hmopen32.h,v 1.9 2003-02-04 11:28:59 sandervl Exp $ */ 2 2 3 3 /* … … 42 42 ULONG arg4); 43 43 44 virtual BOOL DuplicateHandle( PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,44 virtual BOOL DuplicateHandle(HANDLE srchandle, PHMHANDLEDATA pHMHandleData, HANDLE srcprocess, 45 45 PHMHANDLEDATA pHMSrcHandle, 46 46 HANDLE destprocess, -
trunk/src/kernel32/hmsemaphore.cpp
r6086 r9748 1 /* $Id: hmsemaphore.cpp,v 1. 9 2001-06-23 19:43:50 sandervl Exp $ */1 /* $Id: hmsemaphore.cpp,v 1.10 2003-02-04 11:29:00 sandervl Exp $ */ 2 2 3 3 /* … … 10 10 * TODO: OpenSemaphore does not work. (get SEM_INFO pointer) 11 11 * TODO: Name collisions with files & mutex not allowed. Check if this can happen in OS/2 12 * 13 * TODO: Use DosQueryEventSem to test the posted count against maximum count!! 12 14 * 13 15 * Project Odin Software License can be found in LICENSE.TXT … … 31 33 *****************************************************************************/ 32 34 33 #ifdef USE_OS2SEMAPHORES34 #define INCL_DOSSEMAPHORES35 #define INCL_DOSERRORS36 #define INCL_WIN37 #include <os2wrap.h>38 #include <win32type.h>39 #include <win32api.h>40 #include <winconst.h>41 #else42 35 #include <os2win.h> 43 #endif44 36 #include <stdlib.h> 45 37 #include <string.h> … … 54 46 #define DBG_LOCALLOG DBG_hmsemaphore 55 47 #include "dbglocal.h" 56 57 #ifndef DCE_AUTORESET58 #define DCE_AUTORESET 0x1000 /* DosCreateEventSem option to auto-reset */59 /* event semaphore on post. */60 #define DCE_POSTONE 0x0800 /* DosCreateEventSem option to post only */61 /* waiter and auto-reset the semaphore when*/62 /* there are multiple waiters. */63 64 #endif65 48 66 49 /***************************************************************************** … … 95 78 LPCTSTR lpszSemaphoreName) 96 79 { 97 #ifdef USE_OS2SEMAPHORES98 APIRET rc;99 HEV hev;100 char szSemName[CCHMAXPATH];101 102 103 dprintf(("KERNEL32: HandleManager::Semaphore::CreateSemaphore(%08xh,%08xh,%08xh,%08xh,%s)\n",104 pHMHandleData,105 lpsa,106 lInitialCount,107 lMaximumCount,108 lpszSemaphoreName));109 110 if(lMaximumCount <= 0 || lInitialCount < 0 || lInitialCount > lMaximumCount) {111 dprintf(("ERROR: invalid parameter"));112 return ERROR_INVALID_PARAMETER_W;113 }114 115 if(lpszSemaphoreName) {116 strcpy(szSemName, "\\SEM32\\");117 strcat(szSemName, lpszSemaphoreName);118 lpszSemaphoreName = szSemName;119 FixSemName((char *)lpszSemaphoreName);120 }121 rc = DosCreateEventSem(lpszSemaphoreName, &hev, DCE_POSTONE, lInitialCount);122 123 if(rc) {124 dprintf(("DosCreateEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));125 pHMHandleData->hHMHandle = 0;126 return error2WinError(rc);127 }128 pHMHandleData->dwAccess = SEMAPHORE_ALL_ACCESS_W;129 PSEM_INFO pSemInfo = (PSEM_INFO)_smalloc(sizeof(SEM_INFO));130 pSemInfo->refCount = 1;131 pSemInfo->hev = hev;132 pSemInfo->maximumCount = lMaximumCount;133 pSemInfo->currentCount = lInitialCount;134 pHMHandleData->hHMHandle = (DWORD)pSemInfo;135 pHMHandleData->dwInternalType = HMTYPE_SEMAPHORE;136 return ERROR_SUCCESS_W;137 #else138 80 HANDLE hOpen32; 139 81 … … 156 98 } 157 99 else 158 return (O32_GetLastError()); 159 #endif 100 return (GetLastError()); 160 101 } 161 102 … … 177 118 LPCTSTR lpszSemaphoreName) 178 119 { 179 #ifdef USE_OS2SEMAPHORES180 HEV hev;181 APIRET rc;182 char szSemName[CCHMAXPATH];183 184 //TODO: NOT WORKING (initialcount/maximumcount)185 dprintf(("KERNEL32: HandleManager::Semaphore::OpenSemaphore(%08xh,%08xh,%s)\n",186 pHMHandleData,187 fInheritHandle,188 lpszSemaphoreName));189 190 if(lpszSemaphoreName == NULL) {191 pHMHandleData->hHMHandle = 0;192 return ERROR_INVALID_PARAMETER_W;193 }194 195 strcpy(szSemName, "\\SEM32\\");196 strcat(szSemName, lpszSemaphoreName);197 FixSemName(szSemName);198 rc = DosOpenEventSem(szSemName, &hev);199 if(rc) {200 dprintf(("DosOpenEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));201 pHMHandleData->hHMHandle = 0;202 return error2WinError(rc);203 }204 pHMHandleData->hHMHandle = hev;205 pHMHandleData->dwInternalType = HMTYPE_SEMAPHORE;206 return ERROR_SUCCESS_W;207 #else208 120 HANDLE hOpen32; 209 121 … … 223 135 } 224 136 else 225 return (O32_GetLastError()); 226 #endif 137 return (GetLastError()); 227 138 } 228 139 229 /*****************************************************************************230 * Name : HMDeviceEventClass::CloseHandle231 * Purpose : close the handle232 * Parameters: PHMHANDLEDATA pHMHandleData233 * Variables :234 * Result : API returncode235 * Remark :236 * Status :237 *238 * Author :239 *****************************************************************************/240 241 #ifdef USE_OS2SEMAPHORES242 BOOL HMDeviceSemaphoreClass::CloseHandle(PHMHANDLEDATA pHMHandleData)243 {244 APIRET rc;245 PSEM_INFO pSemInfo = (PSEM_INFO)pHMHandleData->hHMHandle;246 247 if(pSemInfo) {248 rc = DosCloseEventSem(pSemInfo->hev);249 if(rc) {250 dprintf(("DosCloseEventSem %x failed with rc %d", pSemInfo->hev, rc));251 SetLastError(error2WinError(rc));252 return FALSE;253 }254 if(InterlockedDecrement(&pSemInfo->refCount) == 0) {255 free(pSemInfo);256 }257 }258 return TRUE;259 }260 #endif261 262 263 /*****************************************************************************264 * Name : HMDeviceEventClass::DuplicateHandle265 * Purpose :266 * Parameters:267 * various parameters as required268 * Variables :269 * Result :270 * Remark : the standard behaviour is to return an error code for non-271 * existant request codes272 * Status :273 *274 * Author :275 *****************************************************************************/276 #ifdef USE_OS2SEMAPHORES277 BOOL HMDeviceSemaphoreClass::DuplicateHandle(PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,278 PHMHANDLEDATA pHMSrcHandle,279 HANDLE destprocess,280 PHANDLE desthandle,281 DWORD fdwAccess,282 BOOL fInherit,283 DWORD fdwOptions,284 DWORD fdwOdinOptions)285 {286 APIRET rc;287 HEV hev;288 PSEM_INFO pSemInfo = (PSEM_INFO)pHMSrcHandle->hHMHandle;289 290 dprintf(("KERNEL32:HandleManager::DuplicateHandle %s(%08x,%08x,%08x,%08x,%08x)",291 lpHMDeviceName,292 pHMHandleData,293 srcprocess, pHMSrcHandle, destprocess, desthandle));294 295 if(srcprocess != destprocess) {296 DebugInt3();297 SetLastError(ERROR_ACCESS_DENIED_W);298 return FALSE;299 }300 InterlockedIncrement(&pSemInfo->refCount);301 pHMHandleData->dwAccess = fdwAccess;302 pHMHandleData->hHMHandle = (DWORD)pSemInfo;303 pHMHandleData->dwInternalType = HMTYPE_SEMAPHORE;304 SetLastError(ERROR_SUCCESS_W);305 return TRUE;306 }307 #endif308 309 #ifdef USE_OS2SEMAPHORES310 /*****************************************************************************311 * Name : DWORD HMDeviceSemaphoreClass::WaitForSingleObject312 * Purpose : object synchronization313 * Parameters: PHMHANDLEDATA pHMHandleData314 * DWORD dwTimeout315 * Variables :316 * Result : API returncode317 * Remark :318 * Status :319 *320 * Author : SvL321 *****************************************************************************/322 323 DWORD HMDeviceSemaphoreClass::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,324 DWORD dwTimeout)325 {326 DWORD rc;327 328 dprintf2(("KERNEL32: HMDeviceSemaphoreClass::WaitForSingleObject(%08xh %08xh)",329 pHMHandleData->hHMHandle, dwTimeout));330 331 if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )332 {333 dprintf(("ERROR: Access denied!!"));334 SetLastError(ERROR_ACCESS_DENIED_W);335 return WAIT_FAILED_W;336 }337 338 PSEM_INFO pSemInfo = (PSEM_INFO)pHMHandleData->hHMHandle;339 340 if(InterlockedDecrement(&pSemInfo->currentCount) >= 0) {341 SetLastError(ERROR_SUCCESS_W);342 return WAIT_OBJECT_0_W;343 }344 345 rc = DosWaitEventSem(pSemInfo->hev, dwTimeout);346 if(rc && rc != ERROR_INTERRUPT && rc != ERROR_TIMEOUT && rc != ERROR_SEM_OWNER_DIED) {347 dprintf(("DosWaitEventSem %x failed with rc %d", pSemInfo->hev, rc));348 SetLastError(error2WinError(rc));349 return WAIT_FAILED_W;350 }351 SetLastError(ERROR_SUCCESS_W);352 if(rc == ERROR_INTERRUPT || rc == ERROR_SEM_OWNER_DIED) {353 return WAIT_ABANDONED_W;354 }355 else356 if(rc == ERROR_TIMEOUT) {357 return WAIT_TIMEOUT_W;358 }359 return WAIT_OBJECT_0_W;360 }361 #endif362 363 #ifdef USE_OS2SEMAPHORES364 /*****************************************************************************365 * Name : DWORD HMDeviceSemaphoreClass::WaitForSingleObjectEx366 * Purpose : object synchronization367 * Parameters: PHMHANDLEDATA pHMHandleData368 * DWORD dwTimeout369 * BOOL fAlertable370 * Variables :371 * Result : API returncode372 * Remark :373 * Status :374 *375 * Author : SvL376 *****************************************************************************/377 378 DWORD HMDeviceSemaphoreClass::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,379 DWORD dwTimeout,380 BOOL fAlertable)381 {382 dprintf2(("KERNEL32: HMDeviceSemaphoreClass::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",383 pHMHandleData->hHMHandle, dwTimeout, fAlertable));384 385 if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )386 {387 dprintf(("ERROR: Access denied!!"));388 SetLastError(ERROR_ACCESS_DENIED_W);389 return WAIT_FAILED_W;390 }391 392 return WaitForSingleObject(pHMHandleData, dwTimeout);393 }394 #endif395 396 #ifdef USE_OS2SEMAPHORES397 /*****************************************************************************398 * Name : BOOL HMDeviceSemaphoreClass::MsgWaitForMultipleObjects399 * Purpose :400 * Variables :401 * Result :402 * Remark :403 * Status :404 *405 * Author : SvL406 *****************************************************************************/407 DWORD HMDeviceSemaphoreClass::MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,408 DWORD nCount,409 PHANDLE pHandles,410 BOOL fWaitAll,411 DWORD dwMilliseconds,412 DWORD dwWakeMask)413 {414 return HMSemMsgWaitForMultipleObjects(nCount, pHandles, fWaitAll, dwMilliseconds, dwWakeMask);415 }416 417 DWORD HMSemMsgWaitForMultipleObjects(DWORD cObjects,418 PHANDLE lphObjects,419 BOOL fWaitAll,420 DWORD dwTimeout,421 DWORD dwWakeMask)422 {423 PHMHANDLEDATA *pHandles;424 HMUX hmux;425 PSEMRECORD pSemRec;426 int i, j;427 APIRET rc;428 ULONG ulUser;429 static HMODULE hUser32 = 0;430 static BOOL (* WINAPI pfnPeekMessageA)(LPMSG,HWND,UINT,UINT,UINT);431 432 dprintf(("KERNEL32: WaitForMultipleObjects %d %x %d %x",433 cObjects, lphObjects, fWaitAll, dwTimeout));434 435 if(pfnPeekMessageA == NULL) {436 hUser32 = LoadLibraryA("USER32.DLL");437 *(FARPROC *)&pfnPeekMessageA = GetProcAddress(hUser32,"PeekMessageA");438 }439 440 if(cObjects == 1) {441 //Can't use DosCreateMuxWaitSem here (will return error 292)442 PHMHANDLEDATA pHandle = HMQueryHandleData(lphObjects[0]);443 if(pHandle == NULL) {444 return WAIT_FAILED_W;445 }446 if(!(pHandle->dwAccess & SYNCHRONIZE_W) )447 {448 dprintf(("ERROR: Access denied (handle %x, index 0)!!", lphObjects[0]));449 SetLastError(ERROR_ACCESS_DENIED_W);450 return WAIT_FAILED_W;451 }452 453 switch(pHandle->dwInternalType) {454 case HMTYPE_SEMAPHORE:455 {456 PSEM_INFO pSemInfo = (PSEM_INFO)pHandle->hHMHandle;457 458 dprintf(("KERNEL32: HMWaitForMultipleObjects(S): handle 0: ODIN-%08xh, OS/2-%08xh",459 lphObjects[0], pSemInfo->hev));460 if(InterlockedDecrement(&pSemInfo->currentCount) >= 0) {461 return WAIT_OBJECT_0_W;462 }463 rc = WinWaitEventSem(pSemInfo->hev, dwTimeout);464 break;465 }466 case HMTYPE_EVENTSEM:467 dprintf(("KERNEL32: HMWaitForMultipleObjects(E): handle 0: ODIN-%08xh, OS/2-%08xh",468 lphObjects[0], pHandle->hHMHandle));469 rc = WinWaitEventSem((HEV)pHandle->hHMHandle, dwTimeout);470 break;471 case HMTYPE_MUTEXSEM:472 dprintf(("KERNEL32: HMWaitForMultipleObjects(M): handle 0: ODIN-%08xh, OS/2-%08xh",473 lphObjects[0], pHandle->hHMHandle));474 rc = WinRequestMutexSem((HMTX)pHandle->hHMHandle, dwTimeout);475 break;476 }477 if(rc && rc != ERROR_INTERRUPT && rc != ERROR_TIMEOUT && rc != ERROR_SEM_OWNER_DIED) {478 dprintf(("WinWaitEventSem/WinRequestMutexSem %x failed with rc %d", pHandle->hHMHandle, rc));479 SetLastError(error2WinError(rc));480 return WAIT_FAILED_W;481 }482 SetLastError(ERROR_SUCCESS_W);483 if(rc == ERROR_INTERRUPT || rc == ERROR_SEM_OWNER_DIED) {484 dprintf(("WAIT_ABANDONED_W (rc %d)", rc));485 return WAIT_ABANDONED_W;486 }487 else488 if(rc == ERROR_TIMEOUT) {489 dprintf(("WAIT_TIMEOUT_W (rc %d)", rc));490 return WAIT_TIMEOUT_W;491 }492 MSG msg ;493 494 if(pfnPeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE_W) == TRUE) {495 dprintf(("WAIT_OBJECT_0_W+1 (rc %d)", rc));496 return WAIT_OBJECT_0_W + 1;497 }498 dprintf(("WAIT_OBJECT_0_W+1 (rc %d)", rc));499 return WAIT_OBJECT_0_W;500 }501 pHandles = (PHMHANDLEDATA *)alloca(cObjects * sizeof(PHMHANDLEDATA));502 pSemRec = (PSEMRECORD)alloca(cObjects * sizeof(SEMRECORD));503 if(pHandles == NULL || pSemRec == NULL) {504 dprintf(("ERROR: out of memory!!"));505 SetLastError(ERROR_OUTOFMEMORY_W);506 return WAIT_FAILED_W;507 }508 for(i=0;i<cObjects;i++) {509 pHandles[i] = HMQueryHandleData(lphObjects[i]);510 if(pHandles[i] == NULL) {511 dprintf(("ERROR: handle %x not recognized", lphObjects[i]));512 SetLastError(ERROR_INVALID_HANDLE_W);513 return WAIT_FAILED_W;514 }515 if(!(pHandles[i]->dwAccess & SYNCHRONIZE_W) )516 {517 dprintf(("ERROR: Access denied (handle %x, index %d)!!", lphObjects[i], i));518 SetLastError(ERROR_ACCESS_DENIED_W);519 return WAIT_FAILED_W;520 }521 if(pHandles[i]->dwInternalType == HMTYPE_SEMAPHORE) {522 PSEM_INFO pSemInfo = (PSEM_INFO)pHandles[i]->hHMHandle;523 dprintf(("KERNEL32: HMWaitForMultipleObjects: handle %3i: ODIN-%08xh, OS/2-%08xh",524 i, lphObjects[i], pSemInfo->hev));525 }526 else527 dprintf(("KERNEL32: HMWaitForMultipleObjects: handle %3i: ODIN-%08xh, OS/2-%08xh",528 i, lphObjects[i], pHandles[i]->hHMHandle));529 530 }531 j = 0;532 for(i=0;i<cObjects;i++) {533 if(pHandles[i]->dwInternalType == HMTYPE_SEMAPHORE) {534 PSEM_INFO pSemInfo = (PSEM_INFO)pHandles[i]->hHMHandle;535 536 if(InterlockedDecrement(&pSemInfo->currentCount) >= 0) {537 if(!fWaitAll) {538 return WAIT_OBJECT_0_W + i;539 }540 }541 else {542 pSemRec[j].hsemCur = (HSEM)pSemInfo->hev;543 pSemRec[j].ulUser = j;544 j++;545 }546 }547 else {548 pSemRec[j].hsemCur = (HSEM)pHandles[i]->hHMHandle;549 pSemRec[j].ulUser = j;550 j++;551 }552 }553 rc = DosCreateMuxWaitSem(NULL, &hmux, j, pSemRec, (fWaitAll) ? DCMW_WAIT_ALL : DCMW_WAIT_ANY);554 if(rc) {555 dprintf(("DosCreateMuxWaitSem failed with rc %d", rc));556 SetLastError(error2WinError(rc));557 return WAIT_FAILED_W;558 }559 ulUser = -1;560 rc = WinWaitMuxWaitSem(hmux, dwTimeout, &ulUser);561 DosCloseMuxWaitSem(hmux);562 if(rc && rc != ERROR_INTERRUPT && rc != ERROR_TIMEOUT && rc != ERROR_SEM_OWNER_DIED) {563 dprintf(("DosWaitMuxWaitSem %x failed with rc %d", hmux, rc));564 SetLastError(error2WinError(rc));565 return WAIT_FAILED_W;566 }567 SetLastError(ERROR_SUCCESS_W);568 if(rc == ERROR_INTERRUPT || rc == ERROR_SEM_OWNER_DIED) {569 //TODO: add index of handle that caused the error....570 dprintf(("WAIT_ABANDONED_W"));571 return WAIT_ABANDONED_W;572 }573 else574 if(rc == ERROR_TIMEOUT) {575 dprintf(("WAIT_TIMEOUT_W"));576 return WAIT_TIMEOUT_W;577 }578 if(ulUser == -1) {579 dprintf(("WAIT_OBJECT_0_W+%d", cObjects));580 return WAIT_OBJECT_0_W + cObjects; //message waiting581 }582 dprintf(("WAIT_OBJECT_0_W+%d", ulUser));583 return WAIT_OBJECT_0_W + ulUser;584 }585 586 #endif587 588 #ifdef USE_OS2SEMAPHORES589 /*****************************************************************************590 * Name : BOOL HMDeviceSemaphoreClass::WaitForMultipleObjects591 * Purpose :592 * Variables :593 * Result :594 * Remark :595 * Status :596 *597 * Author : SvL598 *****************************************************************************/599 DWORD HMDeviceSemaphoreClass::WaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,600 DWORD cObjects,601 PHANDLE lphObjects,602 BOOL fWaitAll,603 DWORD dwTimeout)604 {605 return HMSemWaitForMultipleObjects(cObjects, lphObjects, fWaitAll, dwTimeout);606 }607 608 DWORD HMSemWaitForMultipleObjects(DWORD cObjects,609 PHANDLE lphObjects,610 BOOL fWaitAll,611 DWORD dwTimeout)612 {613 PHMHANDLEDATA *pHandles;614 HMUX hmux;615 PSEMRECORD pSemRec;616 int i, j;617 APIRET rc;618 ULONG ulUser;619 620 dprintf(("KERNEL32: WaitForMultipleObjects %d %x %d %x",621 cObjects, lphObjects, fWaitAll, dwTimeout));622 623 pHandles = (PHMHANDLEDATA *)alloca(cObjects * sizeof(PHMHANDLEDATA));624 pSemRec = (PSEMRECORD)alloca(cObjects * sizeof(SEMRECORD));625 if(pHandles == NULL || pSemRec == NULL) {626 dprintf(("ERROR: out of memory!!"));627 SetLastError(ERROR_OUTOFMEMORY_W);628 return WAIT_FAILED_W;629 }630 for(i=0;i<cObjects;i++) {631 pHandles[i] = HMQueryHandleData(lphObjects[i]);632 if(pHandles[i] == NULL) {633 dprintf(("ERROR: handle %x not recognized", lphObjects[i]));634 }635 if(!(pHandles[i]->dwAccess & EVENT_MODIFY_STATE_W) )636 {637 dprintf(("ERROR: Access denied (handle %x, index %d)!!", lphObjects[i], i));638 SetLastError(ERROR_INVALID_HANDLE_W);639 return WAIT_FAILED_W;640 }641 if(pHandles[i]->dwInternalType == HMTYPE_SEMAPHORE) {642 PSEM_INFO pSemInfo = (PSEM_INFO)pHandles[i]->hHMHandle;643 dprintf(("KERNEL32: HMWaitForMultipleObjects: handle %3i: ODIN-%08xh, OS/2-%08xh",644 i, lphObjects[i], pSemInfo->hev));645 }646 else647 dprintf(("KERNEL32: HMWaitForMultipleObjects: handle %3i: ODIN-%08xh, OS/2-%08xh",648 i, lphObjects[i], pHandles[i]->hHMHandle));649 650 }651 j = 0;652 for(i=0;i<cObjects;i++) {653 if(pHandles[i]->dwInternalType == HMTYPE_SEMAPHORE) {654 PSEM_INFO pSemInfo = (PSEM_INFO)pHandles[i]->hHMHandle;655 656 if(InterlockedDecrement(&pSemInfo->currentCount) >= 0) {657 if(!fWaitAll) {658 return WAIT_OBJECT_0_W + i;659 }660 }661 else {662 pSemRec[j].hsemCur = (HSEM)pSemInfo->hev;663 pSemRec[j].ulUser = j;664 j++;665 }666 }667 else {668 pSemRec[j].hsemCur = (HSEM)pHandles[i]->hHMHandle;669 pSemRec[j].ulUser = j;670 j++;671 }672 }673 rc = DosCreateMuxWaitSem(NULL, &hmux, j, pSemRec, (fWaitAll) ? DCMW_WAIT_ALL : DCMW_WAIT_ANY);674 if(rc) {675 dprintf(("DosCreateMuxWaitSem failed with rc %d", rc));676 SetLastError(error2WinError(rc));677 return WAIT_FAILED_W;678 }679 rc = DosWaitMuxWaitSem(hmux, dwTimeout, &ulUser);680 DosCloseMuxWaitSem(hmux);681 if(rc && rc != ERROR_INTERRUPT && rc != ERROR_TIMEOUT && rc != ERROR_SEM_OWNER_DIED) {682 dprintf(("DosWaitMuxWaitSem %x failed with rc %d", hmux, rc));683 SetLastError(error2WinError(rc));684 return WAIT_FAILED_W;685 }686 SetLastError(ERROR_SUCCESS_W);687 if(rc == ERROR_INTERRUPT || rc == ERROR_SEM_OWNER_DIED) {688 //TODO: add index of handle that caused the error....689 return WAIT_ABANDONED_W;690 }691 else692 if(rc == ERROR_TIMEOUT) {693 return WAIT_TIMEOUT_W;694 }695 return WAIT_OBJECT_0_W + ulUser;696 }697 698 #endif699 140 700 141 /***************************************************************************** … … 714 155 LPLONG lpPreviousCount) 715 156 { 716 #ifdef USE_OS2SEMAPHORES717 APIRET rc;718 ULONG count;719 720 dprintf2(("KERNEL32: HandleManager::Semaphore::ReleaseSemaphore(%08xh,%08xh,%08xh)\n",721 pHMHandleData->hHMHandle,722 cReleaseCount,723 lpPreviousCount));724 725 if(!(pHMHandleData->dwAccess & SEMAPHORE_MODIFY_STATE_W) )726 {727 dprintf(("ERROR: Access denied!!"));728 SetLastError(ERROR_ACCESS_DENIED_W);729 return FALSE;730 }731 732 PSEM_INFO pSemInfo = (PSEM_INFO)pHMHandleData->hHMHandle;733 734 if(InterlockedIncrement(&pSemInfo->currentCount) > 0) {735 //TODO: this is NOT thread safe:736 if(pSemInfo->currentCount > pSemInfo->maximumCount) {737 pSemInfo->currentCount = pSemInfo->maximumCount;738 }739 SetLastError(ERROR_SUCCESS_W);740 return TRUE;741 }742 743 rc = DosResetEventSem(pSemInfo->hev, &count);744 if(rc && rc != ERROR_ALREADY_RESET) {745 dprintf(("DosResetEventSem %x failed with rc %d", pSemInfo->hev, rc));746 SetLastError(error2WinError(rc));747 return FALSE;748 }749 SetLastError(ERROR_SUCCESS_W);750 return TRUE;751 #else752 157 dprintf(("KERNEL32: HandleManager::Semaphore::ReleaseSemaphore(%08xh,%08xh,%08xh)\n", 753 158 pHMHandleData->hHMHandle, … … 758 163 cReleaseCount, 759 164 lpPreviousCount)); 760 #endif761 165 } 762 166 763 167 //****************************************************************************** 764 //Replaces illegal characters in semaphore name (or else OS/2 will return765 //ERROR_INVALID_NAME766 168 //****************************************************************************** 767 void FixSemName(char *lpszSemaphoreName)768 {769 while(TRUE) {770 switch(*lpszSemaphoreName) {771 case 0:772 return;773 case '?':774 case ':':775 *lpszSemaphoreName = '_';776 break;777 }778 lpszSemaphoreName++;779 }780 }781 //******************************************************************************782 //****************************************************************************** -
trunk/src/kernel32/hmsemaphore.h
r6084 r9748 1 /* $Id: hmsemaphore.h,v 1. 5 2001-06-23 16:59:28sandervl Exp $ */1 /* $Id: hmsemaphore.h,v 1.6 2003-02-04 11:29:00 sandervl Exp $ */ 2 2 3 3 /* … … 24 24 #include "HMOpen32.h" 25 25 26 #ifdef USE_OS2SEMAPHORES27 typedef struct {28 LONG currentCount;29 LONG maximumCount;30 LONG refCount;31 ULONG hev;32 } SEM_INFO, *PSEM_INFO;33 #endif34 35 26 36 27 /***************************************************************************** … … 38 29 *****************************************************************************/ 39 30 40 #ifdef USE_OS2SEMAPHORES41 class HMDeviceSemaphoreClass : public HMDeviceHandler42 #else43 31 class HMDeviceSemaphoreClass : public HMDeviceOpen32Class 44 #endif45 32 { 46 33 public: 47 #ifdef USE_OS2SEMAPHORES48 HMDeviceSemaphoreClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName) {}49 #else50 34 HMDeviceSemaphoreClass(LPCSTR lpDeviceName) : HMDeviceOpen32Class(lpDeviceName) {} 51 #endif52 35 53 36 /* this is a handler method for calls to CreateSemaphore() */ … … 62 45 BOOL fInheritHandle, 63 46 LPCTSTR lpszSemaphoreName); 64 65 #ifdef USE_OS2SEMAPHORES66 virtual BOOL CloseHandle(PHMHANDLEDATA pHMHandleData);67 68 virtual BOOL DuplicateHandle(PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,69 PHMHANDLEDATA pHMSrcHandle,70 HANDLE destprocess,71 PHANDLE desthandle,72 DWORD fdwAccess,73 BOOL fInherit,74 DWORD fdwOptions,75 DWORD fdwOdinOptions);76 77 /* this is a handler method for calls to WaitForSingleObject */78 virtual DWORD WaitForSingleObject (PHMHANDLEDATA pHMHandleData,79 DWORD dwTimeout);80 81 /* this is a handler method for calls to WaitForSingleObjectEx */82 virtual DWORD WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,83 DWORD dwTimeout,84 BOOL fAlertable);85 86 virtual DWORD MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,87 DWORD nCount,88 PHANDLE pHandles,89 BOOL fWaitAll,90 DWORD dwMilliseconds,91 DWORD dwWakeMask);92 93 virtual DWORD WaitForMultipleObjects (PHMHANDLEDATA pHMHandleData,94 DWORD cObjects,95 PHANDLE lphObjects,96 BOOL fWaitAll,97 DWORD dwTimeout);98 99 #endif100 47 101 48 /* this is a handle method for calls to ReleaseSemaphore() */ … … 117 64 DWORD dwWakeMask); 118 65 119 void FixSemName(char *lpszSemaphoreName);120 66 121 67 #endif /* _HM_DEVICE_SEMAPHORE_H_ */ -
trunk/src/kernel32/hmthread.cpp
r9667 r9748 1 /* $Id: hmthread.cpp,v 1.1 7 2003-01-13 16:51:39sandervl Exp $ */1 /* $Id: hmthread.cpp,v 1.18 2003-02-04 11:29:00 sandervl Exp $ */ 2 2 3 3 /* … … 40 40 #include "dbglocal.h" 41 41 42 43 typedef struct { 44 HANDLE hDupThread; //original thread handle if duplicated 45 DWORD dwState; //THREAD_ALIVE, THREAD_TERMINATED 46 } OBJ_THREAD; 47 48 #define GET_THREADHANDLE(hThread) (threadobj && threadobj->hDupThread) ? threadobj->hDupThread : hThread 42 49 43 50 //****************************************************************************** … … 60 67 } 61 68 pHMHandleData->dwInternalType = HMTYPE_THREAD; 62 pHMHandleData->dwUserData = THREAD_ALIVE; 69 OBJ_THREAD *threadobj = (OBJ_THREAD *)malloc(sizeof(OBJ_THREAD)); 70 if(threadobj == 0) { 71 DebugInt3(); 72 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 73 return(0); 74 } 75 threadobj->hDupThread = 0; //not a duplicate 76 threadobj->dwState = THREAD_ALIVE; 77 pHMHandleData->dwUserData = (DWORD)threadobj; 63 78 64 79 //SvL: This doesn't really create a thread, but only sets up the 65 80 // handle of thread 0 66 81 if(fFirstThread) { 67 68 82 pHMHandleData->hHMHandle = O32_GetCurrentThread(); //return Open32 handle of thread 83 return pHMHandleData->hHMHandle; 69 84 } 70 85 winthread = new Win32Thread(lpStartAddr, lpvThreadParm, fdwCreate, hThread); … … 112 127 return pHMHandleData->hHMHandle; 113 128 } 129 /***************************************************************************** 130 * Name : HMDeviceFileClass::DuplicateHandle 131 * Purpose : 132 * Parameters: 133 * various parameters as required 134 * Variables : 135 * Result : 136 * Remark : DUPLICATE_CLOSE_SOURCE flag handled in HMDuplicateHandle 137 * 138 * Status : partially implemented 139 * 140 * Author : SvL 141 *****************************************************************************/ 142 BOOL HMDeviceThreadClass::DuplicateHandle(HANDLE srchandle, PHMHANDLEDATA pHMHandleData, 143 HANDLE srcprocess, 144 PHMHANDLEDATA pHMSrcHandle, 145 HANDLE destprocess, 146 PHANDLE desthandle, 147 DWORD fdwAccess, 148 BOOL fInherit, 149 DWORD fdwOptions, 150 DWORD fdwOdinOptions) 151 { 152 BOOL ret; 153 OBJ_THREAD *threadsrc = (OBJ_THREAD *)pHMSrcHandle->dwUserData; 154 155 dprintf(("KERNEL32:HMDeviceThreadClass::DuplicateHandle (%08x,%08x,%08x,%08x,%08x)", 156 pHMHandleData, srcprocess, pHMSrcHandle->hHMHandle, destprocess, desthandle)); 157 158 if(destprocess != srcprocess) 159 { 160 dprintf(("ERROR: DuplicateHandle; different processes not supported!!")); 161 SetLastError(ERROR_INVALID_HANDLE); //?? 162 return FALSE; 163 } 164 ret = O32_DuplicateHandle(srcprocess, pHMSrcHandle->hHMHandle, destprocess, desthandle, fdwAccess, fInherit, fdwOptions); 165 166 if(ret == TRUE) { 167 OBJ_THREAD *threaddest = (OBJ_THREAD *)malloc(sizeof(OBJ_THREAD)); 168 if(threaddest == NULL) { 169 O32_CloseHandle(*desthandle); 170 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 171 return FALSE; 172 } 173 threaddest->hDupThread = 0; 174 threaddest->dwState = THREAD_ALIVE; 175 pHMHandleData->dwUserData = (DWORD)threaddest; 176 177 if(threadsrc) { 178 threaddest->hDupThread = (threadsrc->hDupThread) ? threadsrc->hDupThread : srchandle; 179 threaddest->dwState = threadsrc->dwState; 180 } 181 182 pHMHandleData->hHMHandle = *desthandle; 183 return TRUE; 184 } 185 else return FALSE; 186 } 114 187 //****************************************************************************** 115 188 //****************************************************************************** … … 117 190 { 118 191 DWORD dwSuspend; 119 120 TEB *teb = GetTEBFromThreadHandle(hThread); 192 OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData; 193 194 TEB *teb = GetTEBFromThreadHandle(GET_THREADHANDLE(hThread)); 121 195 if(teb) { 122 196 teb->o.odin.dwSuspend++; … … 135 209 { 136 210 DWORD dwSuspend; 137 TEB *teb = GetTEBFromThreadHandle(hThread); 211 OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData; 212 213 TEB *teb = GetTEBFromThreadHandle(GET_THREADHANDLE(hThread)); 138 214 if(teb) { 139 215 teb->o.odin.dwSuspend--; … … 151 227 INT HMDeviceThreadClass::GetThreadPriority(HANDLE hThread, PHMHANDLEDATA pHMHandleData) 152 228 { 153 TEB *teb;229 OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData; 154 230 155 231 dprintf(("GetThreadPriority(%08xh)\n", pHMHandleData->hHMHandle)); 156 232 157 teb = GetTEBFromThreadHandle(hThread);233 TEB *teb = GetTEBFromThreadHandle(GET_THREADHANDLE(hThread)); 158 234 if(teb == NULL) { 159 235 dprintf(("!WARNING!: TEB not found!!")); … … 167 243 BOOL HMDeviceThreadClass::SetThreadPriority(HANDLE hThread, PHMHANDLEDATA pHMHandleData, int priority) 168 244 { 169 TEB *teb;245 OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData; 170 246 171 247 dprintf(("SetThreadPriority (%08xh,%08xh)", pHMHandleData->hHMHandle, priority)); 172 248 173 teb = GetTEBFromThreadHandle(hThread);249 TEB *teb = GetTEBFromThreadHandle(GET_THREADHANDLE(hThread)); 174 250 if(teb == NULL) { 175 251 dprintf(("!WARNING!: TEB not found!!")); … … 214 290 return FALSE; 215 291 } 292 /***************************************************************************** 293 * Name : BOOL GetThreadTimes 294 * Purpose : The GetThreadTimes function obtains timing information about a specified thread. 295 * Parameters: HANDLE hThread specifies the thread of interest 296 * LPFILETIME lpCreationTime when the thread was created 297 * LPFILETIME lpExitTime when the thread exited 298 * LPFILETIME lpKernelTime time the thread has spent in kernel mode 299 * LPFILETIME lpUserTime time the thread has spent in user mode 300 * Variables : 301 * Result : TRUE / FALSE 302 * Remark : 303 * Status : UNTESTED STUB 304 * 305 * Author : Patrick Haller [Mon, 1998/06/15 08:00] 306 *****************************************************************************/ 307 308 BOOL HMDeviceThreadClass::GetThreadTimes(HANDLE hThread, 309 PHMHANDLEDATA pHMHandleData, 310 LPFILETIME lpCreationTime, 311 LPFILETIME lpExitTime, 312 LPFILETIME lpKernelTime, 313 LPFILETIME lpUserTime) 314 { 315 dprintf(("Kernel32: GetThreadTimes(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n", 316 hThread, 317 lpCreationTime, 318 lpExitTime, 319 lpKernelTime, 320 lpUserTime)); 321 322 return (FALSE); 323 } 216 324 //****************************************************************************** 217 325 //****************************************************************************** 218 326 BOOL HMDeviceThreadClass::TerminateThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData, DWORD exitcode) 219 327 { 328 OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData; 329 220 330 dprintf(("TerminateThread (%08xh,%08xh)\n", 221 331 pHMHandleData->hHMHandle, 222 332 exitcode)); 223 333 224 pHMHandleData->dwUserData = THREAD_TERMINATED; 334 if(threadobj) { 335 threadobj->dwState = THREAD_TERMINATED; 336 } 337 else DebugInt3(); 225 338 return O32_TerminateThread(pHMHandleData->hHMHandle, exitcode); 226 339 } … … 229 342 BOOL HMDeviceThreadClass::SetThreadTerminated(HANDLE hThread, PHMHANDLEDATA pHMHandleData) 230 343 { 231 pHMHandleData->dwUserData = THREAD_TERMINATED; 344 OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData; 345 346 if(threadobj) { 347 threadobj->dwState = THREAD_TERMINATED; 348 } 349 else DebugInt3(); 350 232 351 return TRUE; 233 352 } … … 241 360 242 361 #if 0 243 if(pHMHandleData->dwUserData == THREAD_ALIVE) { 362 OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData; 363 364 if(threadobj && threadobj->dwState == THREAD_ALIVE) { 244 365 lpExitCode == STILL_ALIVE; 245 366 return TRUE; 246 367 } 368 else DebugInt3(); 247 369 #endif 248 370 return O32_GetExitCodeThread(pHMHandleData->hHMHandle, lpExitCode); … … 252 374 BOOL HMDeviceThreadClass::CloseHandle(PHMHANDLEDATA pHMHandleData) 253 375 { 376 OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData; 377 254 378 dprintf(("HMThread::CloseHandle %08x", pHMHandleData->hHMHandle)); 379 380 if(threadobj) { 381 pHMHandleData->dwUserData = 0; 382 free(threadobj); 383 } 255 384 return O32_CloseHandle(pHMHandleData->hHMHandle); 256 385 } … … 260 389 DWORD dwTimeout) 261 390 { 391 OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData; 392 262 393 dprintf(("HMThread::WaitForSingleObject (%08xh,%08xh)\n", 263 394 pHMHandleData->hHMHandle, … … 265 396 266 397 //This doesn't work very well in Open32 (object's state never signaled) 267 if( pHMHandleData->dwUserData== THREAD_TERMINATED) {398 if(threadobj && threadobj->dwState == THREAD_TERMINATED) { 268 399 return WAIT_OBJECT_0; 269 400 } … … 276 407 BOOL fAlertable) 277 408 { 278 if(pHMHandleData->dwUserData == THREAD_TERMINATED) { 409 OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData; 410 411 //This doesn't work very well in Open32 (object's state never signaled) 412 if(threadobj && threadobj->dwState == THREAD_TERMINATED) { 279 413 return WAIT_OBJECT_0; 280 414 } -
trunk/src/kernel32/hmthread.h
r7532 r9748 1 /* $Id: hmthread.h,v 1. 4 2001-12-03 12:13:09sandervl Exp $ */1 /* $Id: hmthread.h,v 1.5 2003-02-04 11:29:01 sandervl Exp $ */ 2 2 3 3 /* … … 46 46 virtual BOOL SetThreadPriority(HANDLE hThread, PHMHANDLEDATA pHMHandleData, int priority); 47 47 48 virtual BOOL DuplicateHandle(HANDLE srchandle, PHMHANDLEDATA pHMHandleData, HANDLE srcprocess, 49 PHMHANDLEDATA pHMSrcHandle, 50 HANDLE destprocess, 51 PHANDLE desthandle, 52 DWORD fdwAccess, 53 BOOL fInherit, 54 DWORD fdwOptions, 55 DWORD fdwOdinOptions); 56 48 57 virtual BOOL GetThreadContext(HANDLE hThread, PHMHANDLEDATA pHMHandleData, PCONTEXT lpContext); 49 58 virtual BOOL SetThreadContext(HANDLE hThread, PHMHANDLEDATA pHMHandleData, const CONTEXT *lpContext); 59 60 virtual BOOL GetThreadTimes(HANDLE hThread, PHMHANDLEDATA pHMHandleData, 61 LPFILETIME lpCreationTime, LPFILETIME lpExitTime, 62 LPFILETIME lpKernelTime, LPFILETIME lpUserTime); 50 63 51 64 virtual BOOL TerminateThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData, DWORD exitcode); -
trunk/src/kernel32/kobjects.cpp
r7854 r9748 1 /* $Id: kobjects.cpp,v 1.1 5 2002-02-09 17:27:32sandervl Exp $ */1 /* $Id: kobjects.cpp,v 1.16 2003-02-04 11:29:01 sandervl Exp $ */ 2 2 3 3 /* … … 747 747 //****************************************************************************** 748 748 //****************************************************************************** 749 BOOL WIN32API GetThreadTimes(HANDLE hThread, 750 LPFILETIME lpCreationTime, 751 LPFILETIME lpExitTime, 752 LPFILETIME lpKernelTime, 753 LPFILETIME lpUserTime) 754 { 755 return HMGetThreadTimes(hThread, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime); 756 } 757 //****************************************************************************** 758 //****************************************************************************** 749 759 BOOL WIN32API TerminateThread(HANDLE hThread, DWORD exitcode) 750 760 { -
trunk/src/kernel32/stubs.cpp
r9653 r9748 1 /* $Id: stubs.cpp,v 1.3 7 2003-01-10 12:57:14sandervl Exp $1 /* $Id: stubs.cpp,v 1.38 2003-02-04 11:29:02 sandervl Exp $ 2 2 * 3 3 * Win32 KERNEL32 Subsystem for OS/2 … … 1061 1061 1062 1062 1063 /*****************************************************************************1064 * Name : BOOL GetThreadTimes1065 * Purpose : The GetThreadTimes function obtains timing information about a specified thread.1066 * Parameters: HANDLE hThread specifies the thread of interest1067 * LPFILETIME lpCreationTime when the thread was created1068 * LPFILETIME lpExitTime when the thread exited1069 * LPFILETIME lpKernelTime time the thread has spent in kernel mode1070 * LPFILETIME lpUserTime time the thread has spent in user mode1071 * Variables :1072 * Result : TRUE / FALSE1073 * Remark :1074 * Status : UNTESTED STUB1075 *1076 * Author : Patrick Haller [Mon, 1998/06/15 08:00]1077 *****************************************************************************/1078 1079 BOOL WIN32API GetThreadTimes(HANDLE hThread,1080 LPFILETIME lpCreationTime,1081 LPFILETIME lpExitTime,1082 LPFILETIME lpKernelTime,1083 LPFILETIME lpUserTime)1084 {1085 dprintf(("Kernel32: GetThreadTimes(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",1086 hThread,1087 lpCreationTime,1088 lpExitTime,1089 lpKernelTime,1090 lpUserTime));1091 1092 return (FALSE);1093 }1094 1063 1095 1064 -
trunk/src/kernel32/thread.cpp
r9693 r9748 1 /* $Id: thread.cpp,v 1. 49 2003-01-20 10:46:28sandervl Exp $ */1 /* $Id: thread.cpp,v 1.50 2003-02-04 11:29:03 sandervl Exp $ */ 2 2 3 3 /* … … 65 65 teb = GetThreadTEB(); 66 66 if(teb == 0) { 67 DebugInt3(); 67 68 SetLastError(ERROR_INVALID_HANDLE); //todo 68 69 return 0;
Note:
See TracChangeset
for help on using the changeset viewer.
