Changeset 7567 for trunk/src/kernel32/overlappedio.cpp

Timestamp:

Dec 7, 2001, 3:13:39 PM (24 years ago)

Author:

sandervl

Message:

overlapped io, com, thread & process updates

File:

• trunk/src/kernel32/overlappedio.cpp (modified) (12 diffs)

trunk/src/kernel32/overlappedio.cpp

@@ -1 @@
-/* $Id: overlappedio.cpp,v 1.6 2001-12-07 11:28:11 sandervl Exp $ */
+/* $Id: overlappedio.cpp,v 1.7 2001-12-07 14:13:38 sandervl Exp $ */
 
 /*
@@ -36 +36 @@
     }
 
-    pending[ASYNC_INDEX_READ] = pending[ASYNC_INDEX_WRITE] = pending [ASYNC_INDEX_POLL] = NULL;
+    pending[ASYNC_INDEX_READ] = pending[ASYNC_INDEX_WRITE]  = NULL;
+    pending [ASYNC_INDEX_POLL] = pending [ASYNC_INDEX_BUSY] = NULL;
 
     this->lpReadHandler       = lpReadHandler;
@@ -165 +166 @@
     LPOVERLAPPED     lpOverlapped;
     HANDLE hEvents[2];
+    HANDLE hEventsWait[2];
+    HANDLE hHandle;
     DWORD  ret, dwTimeOut, dwResult;
     int    index;
@@ -196 +199 @@
             break;
         }
-        if(ret == WAIT_FAILED) {
-            dprintf(("!WARNING!: WaitForMultipleObjects -> WAIT_FAILED!"));
-            break;
-        }
         //if hEventExit has been signalled, then we are told to exit
         if(ret == (WAIT_OBJECT_0+1)) {
@@ -215 +214 @@
         lpRequest       = pending[index];
         pending[index]  = lpRequest->next;
-        lpRequest->next = NULL;
+
+        //add to in process list
+        lpRequest->next = pending[ASYNC_INDEX_BUSY];
+        pending[ASYNC_INDEX_BUSY] = lpRequest;
         ::LeaveCriticalSection(&critsect);
 
         lpOverlapped = lpRequest->lpOverlapped;;
+        hHandle      = lpRequest->hHandle;
 
         switch(dwOperation) {
         case ASYNCIO_READ:
         case ASYNCIO_READWRITE:
-            lpReadHandler(lpRequest, &dwResult, NULL);
+            lpRequest->dwLastError = lpReadHandler(lpRequest, &dwResult, NULL);
             lpOverlapped->Internal     = lpRequest->dwLastError;
             lpOverlapped->InternalHigh = dwResult;
@@ -229 +232 @@
                 *lpRequest->lpdwResult = dwResult;
             }
+            if(lpRequest->dwAsyncType == ASYNCIO_READ) {
+                 dprintf(("ASYNCIO_READ %x finished; result %x, last error %d", lpOverlapped, dwResult, lpRequest->dwLastError));
+            }
+            else dprintf(("ASYNCIO_WRITE %x finished; result %x, last error %d", lpOverlapped, dwResult, lpRequest->dwLastError));
             //wake up user thread
             ::SetEvent(lpOverlapped->hEvent);
-            delete lpRequest;
             break;
 
         case ASYNCIO_WRITE:
-            lpWriteHandler(lpRequest, &dwResult, NULL);
+            lpRequest->dwLastError = lpWriteHandler(lpRequest, &dwResult, NULL);
             lpOverlapped->Internal     = lpRequest->dwLastError;
             lpOverlapped->InternalHigh = dwResult;
@@ -241 +247 @@
                 *lpRequest->lpdwResult = dwResult;
             }
+            dprintf(("ASYNCIO_WRITE %x finished; result %x, last error %d", lpOverlapped, dwResult, lpRequest->dwLastError));
             //wake up user thread
             ::SetEvent(lpOverlapped->hEvent);
-            delete lpRequest;
             break;
 
         case ASYNCIO_POLL:
+            hEventsWait[0] = lpRequest->hEventCancel;
+            hEventsWait[1] = hEventExit;
+            ret = WAIT_TIMEOUT;
             while(TRUE)
             {
                 dwTimeOut = 0;
-                if(lpPollHandler(lpRequest, &dwResult, &dwTimeOut) == TRUE) {
+                lpRequest->dwLastError = lpPollHandler(lpRequest, &dwResult, &dwTimeOut);
+                if(lpRequest->dwLastError != ERROR_IO_PENDING) {
                     break;
                 }
@@ -258 +268 @@
                     break;
                 }
-                Sleep(dwTimeOut);
-            }
-            lpOverlapped->Internal     = lpRequest->dwLastError;
-            lpOverlapped->InternalHigh = dwResult;
-            if(lpRequest->lpdwResult) {
-                *lpRequest->lpdwResult = dwResult;
-            }
-            //wake up user thread
-            ::SetEvent(lpOverlapped->hEvent);
-            delete lpRequest;
+                //sleep a while to avoid wasting too many cpu cycles; we are woken up when a timeout occurs,
+                //when the operation is cancelled or when the process exits
+                ret = WaitForMultipleObjects(2, hEventsWait, FALSE, dwTimeOut);
+                if(ret != WAIT_TIMEOUT) {
+                    dprintf(("ASYNCIO_POLL: WaitForSingleObject didn't time out, abort (ret = %x)", ret));
+                    break;
+                }
+            }
+            //Don't access the overlapped & result memory when CancelIo was used to cancel the operation
+            if(ret == WAIT_TIMEOUT)
+            {
+                dprintf(("ASYNCIO_POLL %x: result %x, last error %d", lpOverlapped, dwResult, lpRequest->dwLastError));
+                lpOverlapped->Internal     = lpRequest->dwLastError;
+                lpOverlapped->InternalHigh = dwResult;
+                if(lpRequest->lpdwResult) {
+                    *lpRequest->lpdwResult = dwResult;
+                }
+                //wake up user thread
+                ::SetEvent(lpOverlapped->hEvent);
+            }
             break;
         }
+        //remove from in-process list and delete async request object
+        findAndRemoveRequest(ASYNC_INDEX_BUSY, hHandle);
+        delete lpRequest;
     }
     return 0;
@@ -397 +420 @@
 //******************************************************************************
 BOOL OverlappedIOHandler::WaitForEvent(HANDLE        hHandle,
+                                       DWORD         dwEventMask,
                                        LPDWORD       lpfdwEvtMask,
                                        LPOVERLAPPED  lpOverlapped,
@@ -424 +448 @@
     lpRequest->dwUserData          = dwUserData;
     lpRequest->dwTimeOut           = dwTimeOut;
+    lpRequest->dwEventMask         = dwEventMask;
     lpRequest->next                = NULL;
 
@@ -459 +484 @@
         while(TRUE) {
             lpRequest = findAndRemoveRequest(i, hHandle);
+
             if(lpRequest) {
-                 delete lpRequest;
+                 ::SetEvent(lpRequest->hEventCancel);   //cancel pending operation
+                 if(i != ASYNC_INDEX_BUSY) {//thread that handles the request will delete it
+                    delete lpRequest;
+                 }
             }
             else break;
@@ -518 +547 @@
 //******************************************************************************
 //******************************************************************************
+