Changeset 9748 for trunk/src/kernel32/hmthread.cpp

Timestamp:

Feb 4, 2003, 12:29:03 PM (23 years ago)

Author:

sandervl

Message:

Support DuplicateHandle for threads; cleaned up semaphore code

File:

• trunk/src/kernel32/hmthread.cpp (modified) (15 diffs)

trunk/src/kernel32/hmthread.cpp

@@ -1 @@
-/* $Id: hmthread.cpp,v 1.17 2003-01-13 16:51:39 sandervl Exp $ */
+/* $Id: hmthread.cpp,v 1.18 2003-02-04 11:29:00 sandervl Exp $ */
 
 /*
@@ -40 +40 @@
 #include "dbglocal.h"
 
+
+typedef struct {
+  HANDLE hDupThread;    //original thread handle if duplicated
+  DWORD  dwState;       //THREAD_ALIVE, THREAD_TERMINATED
+} OBJ_THREAD;
+
+#define GET_THREADHANDLE(hThread) (threadobj && threadobj->hDupThread) ? threadobj->hDupThread : hThread
 
 //******************************************************************************
@@ -60 +67 @@
     }
     pHMHandleData->dwInternalType = HMTYPE_THREAD;
-    pHMHandleData->dwUserData     = THREAD_ALIVE;
+    OBJ_THREAD *threadobj = (OBJ_THREAD *)malloc(sizeof(OBJ_THREAD));
+    if(threadobj == 0) {
+        DebugInt3();
+        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+        return(0);
+    }
+    threadobj->hDupThread = 0;  //not a duplicate
+    threadobj->dwState = THREAD_ALIVE;
+    pHMHandleData->dwUserData = (DWORD)threadobj;
 
     //SvL: This doesn't really create a thread, but only sets up the
     //     handle of thread 0
     if(fFirstThread) {
-            pHMHandleData->hHMHandle = O32_GetCurrentThread(); //return Open32 handle of thread
-            return pHMHandleData->hHMHandle;
+        pHMHandleData->hHMHandle = O32_GetCurrentThread(); //return Open32 handle of thread
+        return pHMHandleData->hHMHandle;
     }
     winthread = new Win32Thread(lpStartAddr, lpvThreadParm, fdwCreate, hThread);
@@ -112 +127 @@
     return pHMHandleData->hHMHandle;
 }
+/*****************************************************************************
+ * Name      : HMDeviceFileClass::DuplicateHandle
+ * Purpose   :
+ * Parameters:
+ *             various parameters as required
+ * Variables :
+ * Result    :
+ * Remark    : DUPLICATE_CLOSE_SOURCE flag handled in HMDuplicateHandle
+ *
+ * Status    : partially implemented
+ *
+ * Author    : SvL
+ *****************************************************************************/
+BOOL HMDeviceThreadClass::DuplicateHandle(HANDLE srchandle, PHMHANDLEDATA pHMHandleData,
+                                          HANDLE  srcprocess,
+                                          PHMHANDLEDATA pHMSrcHandle,
+                                          HANDLE  destprocess,
+                                          PHANDLE desthandle,
+                                          DWORD   fdwAccess,
+                                          BOOL    fInherit,
+                                          DWORD   fdwOptions,
+                                          DWORD   fdwOdinOptions)
+{
+  BOOL ret;
+  OBJ_THREAD *threadsrc = (OBJ_THREAD *)pHMSrcHandle->dwUserData;
+
+  dprintf(("KERNEL32:HMDeviceThreadClass::DuplicateHandle (%08x,%08x,%08x,%08x,%08x)",
+           pHMHandleData, srcprocess, pHMSrcHandle->hHMHandle, destprocess, desthandle));
+
+  if(destprocess != srcprocess)
+  {
+      dprintf(("ERROR: DuplicateHandle; different processes not supported!!"));
+      SetLastError(ERROR_INVALID_HANDLE); //??
+      return FALSE;
+  }
+  ret = O32_DuplicateHandle(srcprocess, pHMSrcHandle->hHMHandle, destprocess, desthandle, fdwAccess, fInherit, fdwOptions);
+
+  if(ret == TRUE) {
+       OBJ_THREAD *threaddest = (OBJ_THREAD *)malloc(sizeof(OBJ_THREAD));
+       if(threaddest == NULL) {
+           O32_CloseHandle(*desthandle);
+           SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+           return FALSE;
+       }
+       threaddest->hDupThread = 0;
+       threaddest->dwState    = THREAD_ALIVE;
+       pHMHandleData->dwUserData = (DWORD)threaddest;
+
+       if(threadsrc) {
+           threaddest->hDupThread = (threadsrc->hDupThread) ? threadsrc->hDupThread : srchandle;
+           threaddest->dwState    = threadsrc->dwState;
+       }
+
+       pHMHandleData->hHMHandle = *desthandle;
+       return TRUE;
+  }
+  else return FALSE;
+}
 //******************************************************************************
 //******************************************************************************
@@ -117 +190 @@
 {
     DWORD dwSuspend;
-
-    TEB *teb = GetTEBFromThreadHandle(hThread);
+    OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData;
+
+    TEB *teb = GetTEBFromThreadHandle(GET_THREADHANDLE(hThread));
     if(teb) {
         teb->o.odin.dwSuspend++;
@@ -135 +209 @@
 {
     DWORD dwSuspend;
-    TEB *teb = GetTEBFromThreadHandle(hThread);
+    OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData;
+
+    TEB *teb = GetTEBFromThreadHandle(GET_THREADHANDLE(hThread));
     if(teb) {
         teb->o.odin.dwSuspend--;
@@ -151 +227 @@
 INT HMDeviceThreadClass::GetThreadPriority(HANDLE hThread, PHMHANDLEDATA pHMHandleData)
 {
-    TEB *teb;
+    OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData;
 
     dprintf(("GetThreadPriority(%08xh)\n", pHMHandleData->hHMHandle));
 
-    teb = GetTEBFromThreadHandle(hThread);
+    TEB *teb = GetTEBFromThreadHandle(GET_THREADHANDLE(hThread));
     if(teb == NULL) {
         dprintf(("!WARNING!: TEB not found!!"));
@@ -167 +243 @@
 BOOL HMDeviceThreadClass::SetThreadPriority(HANDLE hThread, PHMHANDLEDATA pHMHandleData, int priority)
 {
-    TEB  *teb;
+    OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData;
 
     dprintf(("SetThreadPriority (%08xh,%08xh)", pHMHandleData->hHMHandle, priority));
 
-    teb = GetTEBFromThreadHandle(hThread);
+    TEB *teb = GetTEBFromThreadHandle(GET_THREADHANDLE(hThread));
     if(teb == NULL) {
         dprintf(("!WARNING!: TEB not found!!"));
@@ -214 +290 @@
   return FALSE;
 }
+/*****************************************************************************
+ * Name      : BOOL GetThreadTimes
+ * Purpose   : The GetThreadTimes function obtains timing information about a specified thread.
+ * Parameters: HANDLE     hThread       specifies the thread of interest
+ *             LPFILETIME lpCreationTime when the thread was created
+ *             LPFILETIME lpExitTime     when the thread exited
+ *             LPFILETIME lpKernelTime   time the thread has spent in kernel mode
+ *             LPFILETIME lpUserTime     time the thread has spent in user mode
+ * Variables :
+ * Result    : TRUE / FALSE
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
+ *****************************************************************************/
+
+BOOL HMDeviceThreadClass::GetThreadTimes(HANDLE        hThread,
+                                         PHMHANDLEDATA pHMHandleData,
+                                         LPFILETIME lpCreationTime,
+                                         LPFILETIME lpExitTime,
+                                         LPFILETIME lpKernelTime,
+                                         LPFILETIME lpUserTime)
+{
+  dprintf(("Kernel32: GetThreadTimes(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
+           hThread,
+           lpCreationTime,
+           lpExitTime,
+           lpKernelTime,
+           lpUserTime));
+
+  return (FALSE);
+}
 //******************************************************************************
 //******************************************************************************
 BOOL HMDeviceThreadClass::TerminateThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData, DWORD exitcode)
 {
+    OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData;
+
     dprintf(("TerminateThread (%08xh,%08xh)\n",
              pHMHandleData->hHMHandle,
              exitcode));
 
-    pHMHandleData->dwUserData = THREAD_TERMINATED;
+    if(threadobj) {
+        threadobj->dwState = THREAD_TERMINATED;
+    }
+    else DebugInt3();
     return O32_TerminateThread(pHMHandleData->hHMHandle, exitcode);
 }
@@ -229 +342 @@
 BOOL HMDeviceThreadClass::SetThreadTerminated(HANDLE hThread, PHMHANDLEDATA pHMHandleData)
 {
-    pHMHandleData->dwUserData = THREAD_TERMINATED;
+    OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData;
+
+    if(threadobj) {
+        threadobj->dwState = THREAD_TERMINATED;
+    }
+    else DebugInt3();
+
     return TRUE;
 }
@@ -241 +360 @@
 
 #if 0
-    if(pHMHandleData->dwUserData == THREAD_ALIVE) {
+    OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData;
+
+    if(threadobj && threadobj->dwState == THREAD_ALIVE) {
         lpExitCode == STILL_ALIVE;
         return TRUE;
     }
+    else DebugInt3();
 #endif
     return O32_GetExitCodeThread(pHMHandleData->hHMHandle, lpExitCode);
@@ -252 +374 @@
 BOOL HMDeviceThreadClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
 {
+    OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData;
+
     dprintf(("HMThread::CloseHandle %08x", pHMHandleData->hHMHandle));
+
+    if(threadobj) {
+        pHMHandleData->dwUserData = 0;
+        free(threadobj);
+    }
     return O32_CloseHandle(pHMHandleData->hHMHandle);
 }
@@ -260 +389 @@
                                                DWORD  dwTimeout)
 {
+  OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData;
+
   dprintf(("HMThread::WaitForSingleObject (%08xh,%08xh)\n",
            pHMHandleData->hHMHandle,
@@ -265 +396 @@
   
   //This doesn't work very well in Open32 (object's state never signaled)
-  if(pHMHandleData->dwUserData == THREAD_TERMINATED) {
+  if(threadobj && threadobj->dwState == THREAD_TERMINATED) {
         return WAIT_OBJECT_0;
   }
@@ -276 +407 @@
                                                  BOOL   fAlertable)
 {
-  if(pHMHandleData->dwUserData == THREAD_TERMINATED) {
+  OBJ_THREAD *threadobj = (OBJ_THREAD *)pHMHandleData->dwUserData;
+
+  //This doesn't work very well in Open32 (object's state never signaled)
+  if(threadobj && threadobj->dwState == THREAD_TERMINATED) {
         return WAIT_OBJECT_0;
   }