VOID IoCompletionRoutine(DWORD dwErrorCode, 
        DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped) 
{ 
    // If an I/O error occurs, display the error and exit. 
 
    if (dwErrorCode) 
    { 
        printf("FATAL I/O Error %ld I/O Context %lx.%lx\n", 
            dwErrorCode, lpOverlapped, lpOverlapped->hEvent); 
        ExitProcess(dwErrorCode); 
    } 
    LocalFree(lpOverlapped); 
} 
Main Thread: 

VOID IoWorkerThread(VOID) 
{ 
    HANDLE HandleVector[2]; 
    DWORD CompletionStatus; 
    PIOREQUEST IoRequestPacket; 
    LPOVERLAPPED Overlapped; 
    BOOL IoOperationStatus; 
 
    HandleVector[0] = IoWorkerListLock; 
    HandleVector[1] = IoWorkerListSemaphore; 
 
    for(;;) 
    { 
 
        // Do an alertable wait on the handle vector. Both objects 
        // being signaled at the same time means that there is an 
        // I/O request in the queue and the caller has exclusive 
        // access to the queue. 
 
        CompletionStatus = WaitForMultipleObjectsEx(2, HandleVector, 
                TRUE, INFINITE, TRUE); 
 
        // If the wait failed, error out. 
 
        if (CompletionStatus == -1) 
        { 
            printf("FATAL WAIT ERROR %ld\n", GetLastError()); 
            ExitProcess(1); 
        } 
        // If an I/O completion occurred, wait for another 
        // I/O request or I/O completion. 
 
        if (CompletionStatus != WAIT_IO_COMPLETION) 
        { 
 
            // The wait was satisfied. Ownership of the I/O 
            // request queue is exclusive, and there is something in 
            // the queue. To insert something in the queue, the 
            // inserter gets the list lock (mutex), inserts an entry, 
            // signals the list semaphore, and finally releases the 
            // list lock. 
 
            IoRequestPacket = RemoveHeadList(&IoRequestList); 
 
            ReleaseMutex(IoWorkerListLock); 
 
            // Allocate an overlapped structure.
 
            Overlapped = LocalAlloc(LMEM_ZEROINIT, 
                    sizeof(OVERLAPPED)); 
 
            if (!Overlapped) 
            { 
                printf("FATAL allocation error\n"); 
                ExitProcess(1); 
            } 
 
            Overlapped->Offset = IoRequestPacket->Offset; 
            Overlapped->OffsetHigh = IoRequestPacket->OffsetHigh; 
            Overlapped->hEvent = 
                    IoRequestPacket->dwAdditionalIoContext; 
 
            if (IoRequestPacket->bRead) 
            { 
                IoOperationStatus = 
                            ReadFileEx(IoRequestPacket->hFile, 
                    IoRequestPacket->lpBuffer, 
                    IoRequestPacket->dwTransferCount, 
                    Overlapped, IoCompletionRoutine); 
            } 
            else 
            { 
                IoOperationStatus = 
                    WriteFileEx(IoRequestPacket->hFile, 
                        IoRequestPacket->lpBuffer, 
                        IoRequestPacket->dwTransferCount, 
                        Overlapped, 
                        IoCompletionRoutine); 
            } 
 
            // Test to see if the I/O was queued successfully.
 
            if (!IoOperationStatus) 
            { 
                printf("FATAL I/O Error %ld I/O Context %lx.%lx\n", 
                    GetLastError(), Overlapped, Overlapped->hEvent); 
                ExitProcess(1); 
            } 
 
            // The I/O queued successfully. Go back into the 
            // alertable wait for I/O completion or for 
            // more I/O requests. 
 
        } 
    } 
}