I/O Completion Ports (1 of 2) - reworked

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



I can't believe how long it was since I posted the first version of this.
However, I have finally put the time into this to rework it.
Differences from previous version:
- Don't use variable sized messages
- Use existing code in ntdll
- Use existing code for thread wait queue in server

ChangeLog:
- Add server (and minimal client) support for I/O completion ports
License:
- LGPL

Rob
Index: dlls/ntdll/Makefile.in
===================================================================
RCS file: /home/wine/wine/dlls/ntdll/Makefile.in,v
retrieving revision 1.55
diff -u -r1.55 Makefile.in
--- dlls/ntdll/Makefile.in	12 Apr 2003 00:10:13 -0000	1.55
+++ dlls/ntdll/Makefile.in	21 Apr 2003 14:44:19 -0000
@@ -78,6 +78,7 @@
 	error.c \
 	file.c \
 	heap.c \
+	iocompletion.c \
 	large_int.c \
 	loader.c \
 	misc.c \
Index: dlls/ntdll/error.c
===================================================================
RCS file: /home/wine/wine/dlls/ntdll/error.c,v
retrieving revision 1.8
diff -u -r1.8 error.c
--- dlls/ntdll/error.c	2 Jan 2003 17:50:48 -0000	1.8
+++ dlls/ntdll/error.c	21 Apr 2003 14:44:25 -0000
@@ -69,8 +69,9 @@

 /* conversion tables */

-static const DWORD table_00000103[31] =
+static const DWORD table_00000102[32] =
 {
+   ERROR_TIMEOUT,                          /* 00000102 (STATUS_TIMEOUT) */
    ERROR_IO_PENDING,                       /* 00000103 (STATUS_PENDING) */
    ERROR_MR_MID_NOT_FOUND,                 /* 00000104 */
    ERROR_MORE_DATA,                        /* 00000105 (STATUS_MORE_ENTRIES) */
@@ -1333,7 +1334,7 @@

 static const struct error_table error_table[] =
 {
-    { 0x00000103, 0x00000122, table_00000103 },
+    { 0x00000102, 0x00000122, table_00000102 },
     { 0x40000002, 0x4000000e, table_40000002 },
     { 0x40000370, 0x40000371, table_40000370 },
     { 0x40020056, 0x40020057, table_40020056 },
Index: dlls/ntdll/ntdll.spec
===================================================================
RCS file: /home/wine/wine/dlls/ntdll/ntdll.spec,v
retrieving revision 1.105
diff -u -r1.105 ntdll.spec
--- dlls/ntdll/ntdll.spec	12 Apr 2003 00:10:13 -0000	1.105
+++ dlls/ntdll/ntdll.spec	21 Apr 2003 14:44:30 -0000
@@ -79,7 +79,7 @@
 @ stdcall NtCreateEvent(long long long long long)
 @ stub NtCreateEventPair
 @ stdcall NtCreateFile(ptr long ptr ptr long long long ptr long long ptr)
-@ stub NtCreateIoCompletion
+@ stdcall NtCreateIoCompletion(ptr long long long)
 @ stdcall NtCreateKey(long long long long long long long)
 @ stdcall NtCreateMailslotFile(long long long long long long long long)
 @ stub NtCreateMutant
@@ -192,7 +192,7 @@
 @ stub NtReleaseMutant
 @ stub NtReleaseProcessMutant
 @ stdcall NtReleaseSemaphore(long long ptr)
-@ stub NtRemoveIoCompletion
+@ stdcall NtRemoveIoCompletion(ptr ptr ptr ptr ptr)
 @ stdcall NtReplaceKey(ptr long ptr)
 @ stub NtReplyPort
 @ stdcall NtReplyWaitReceivePort(ptr ptr ptr ptr)
@@ -220,7 +220,7 @@
 @ stdcall NtSetInformationThread(long long long long)
 @ stub NtSetInformationToken
 @ stdcall NtSetIntervalProfile(long long)
-@ stub NtSetIoCompletion
+@ stdcall NtSetIoCompletion(ptr long ptr long long)
 @ stub NtSetLdtEntries
 @ stub NtSetLowEventPair
 @ stub NtSetLowWaitHighEventPair
Index: dlls/ntdll/sync.c
===================================================================
RCS file: /home/wine/wine/dlls/ntdll/sync.c,v
retrieving revision 1.27
diff -u -r1.27 sync.c
--- dlls/ntdll/sync.c	4 Apr 2003 22:26:34 -0000	1.27
+++ dlls/ntdll/sync.c	21 Apr 2003 14:44:33 -0000
@@ -312,11 +312,11 @@


 /***********************************************************************
- *              wait_reply
+ *              NTDLL_wait_reply
  *
  * Wait for a reply on the waiting pipe of the current thread.
  */
-static int wait_reply( void *cookie )
+int NTDLL_wait_reply( void *cookie )
 {
     int signaled;
     struct wake_up_reply reply;
@@ -329,7 +329,7 @@
             if (!reply.cookie) break;  /* thread got killed */
             if (reply.cookie == cookie) return reply.signaled;
             /* we stole another reply, wait for the real one */
-            signaled = wait_reply( cookie );
+            signaled = NTDLL_wait_reply( cookie );
             /* and now put the wrong one back in the pipe */
             for (;;)
             {
@@ -430,7 +430,7 @@
             ret = wine_server_call( req );
         }
         SERVER_END_REQ;
-        if (ret == STATUS_PENDING) ret = wait_reply( &cookie );
+        if (ret == STATUS_PENDING) ret = NTDLL_wait_reply( &cookie );
         if (ret != STATUS_USER_APC) break;
         call_apcs( alertable );
         if (alertable) break;
Index: include/winternl.h
===================================================================
RCS file: /home/wine/wine/include/winternl.h,v
retrieving revision 1.25
diff -u -r1.25 winternl.h
--- include/winternl.h	12 Apr 2003 00:10:13 -0000	1.25
+++ include/winternl.h	21 Apr 2003 14:46:45 -0000
@@ -1272,6 +1274,22 @@
 NTSTATUS WINAPI LdrShutdownThread(void);
 NTSTATUS WINAPI LdrUnloadDll(HMODULE);
 NTSTATUS WINAPI LdrUnlockLoaderLock(ULONG,ULONG);
+
+/*************************************************************************
+ * I/O completion functions and structures.
+ *
+ * Those are not part of standard Winternl.h
+ */
+typedef struct _FILE_COMPLETION_INFORMATION {
+    HANDLE CompletionPort;
+    ULONG_PTR CompletionKey;
+} FILE_COMPLETION_INFORMATION;
+typedef FILE_COMPLETION_INFORMATION *PFILE_COMPLETION_INFORMATION;
+
+NTSTATUS WINAPI NtCreateIoCompletion(PHANDLE,ACCESS_MASK,ULONG_PTR,ULONG);
+NTSTATUS WINAPI NtSetIoCompletion(HANDLE,ULONG_PTR,LPOVERLAPPED,ULONG,ULONG);
+NTSTATUS WINAPI NtRemoveIoCompletion(HANDLE,PULONG_PTR,LPOVERLAPPED*,PIO_STATUS_BLOCK,PLARGE_INTEGER);
+NTSTATUS WINAPI NtSetInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FILE_INFORMATION_CLASS);

 #ifdef __cplusplus
 } /* extern "C" */
Index: include/wine/server_protocol.h
===================================================================
RCS file: /home/wine/wine/include/wine/server_protocol.h,v
retrieving revision 1.65
diff -u -r1.65 server_protocol.h
--- include/wine/server_protocol.h	4 Apr 2003 22:26:34 -0000	1.65
+++ include/wine/server_protocol.h	21 Apr 2003 14:47:04 -0000
@@ -3040,6 +3040,63 @@
 };


+struct create_io_completion_request
+{
+    struct request_header __header;
+    unsigned int   access;
+    unsigned int   concurrent_threads;
+};
+struct create_io_completion_reply
+{
+    struct reply_header __header;
+    user_handle_t  handle;
+};
+
+
+struct set_io_completion_request
+{
+    struct request_header __header;
+    user_handle_t  handle;
+    unsigned int   bytes_transferred;
+    void*          completion_key;
+    void*          overlapped;
+};
+struct set_io_completion_reply
+{
+    struct reply_header __header;
+};
+
+
+struct remove_io_completion_request
+{
+    struct request_header __header;
+    user_handle_t  handle;
+    void*          cookie;
+    abs_time_t     timeout;
+};
+struct remove_io_completion_reply
+{
+    struct reply_header __header;
+    unsigned int   bytes_transferred;
+    void*          completion_key;
+    void*          overlapped;
+};
+
+
+struct remove_io_completion_assigned_request
+{
+    struct request_header __header;
+    user_handle_t  handle;
+};
+struct remove_io_completion_assigned_reply
+{
+    struct reply_header __header;
+    unsigned int   bytes_transferred;
+    void*          completion_key;
+    void*          overlapped;
+};
+
+
 enum request
 {
     REQ_new_process,
@@ -3217,6 +3274,10 @@
     REQ_start_hook_chain,
     REQ_finish_hook_chain,
     REQ_get_next_hook,
+    REQ_create_io_completion,
+    REQ_set_io_completion,
+    REQ_remove_io_completion,
+    REQ_remove_io_completion_assigned,
     REQ_NB_REQUESTS
 };

@@ -3399,6 +3460,10 @@
     struct start_hook_chain_request start_hook_chain_request;
     struct finish_hook_chain_request finish_hook_chain_request;
     struct get_next_hook_request get_next_hook_request;
+    struct create_io_completion_request create_io_completion_request;
+    struct set_io_completion_request set_io_completion_request;
+    struct remove_io_completion_request remove_io_completion_request;
+    struct remove_io_completion_assigned_request remove_io_completion_assigned_request;
 };
 union generic_reply
 {
@@ -3579,8 +3644,12 @@
     struct start_hook_chain_reply start_hook_chain_reply;
     struct finish_hook_chain_reply finish_hook_chain_reply;
     struct get_next_hook_reply get_next_hook_reply;
+    struct create_io_completion_reply create_io_completion_reply;
+    struct set_io_completion_reply set_io_completion_reply;
+    struct remove_io_completion_reply remove_io_completion_reply;
+    struct remove_io_completion_assigned_reply remove_io_completion_assigned_reply;
 };

-#define SERVER_PROTOCOL_VERSION 105
+#define SERVER_PROTOCOL_VERSION 106

 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */
Index: server/Makefile.in
===================================================================
RCS file: /home/wine/wine/server/Makefile.in,v
retrieving revision 1.43
diff -u -r1.43 Makefile.in
--- server/Makefile.in	26 Mar 2003 01:32:18 -0000	1.43
+++ server/Makefile.in	21 Apr 2003 14:47:18 -0000
@@ -20,6 +20,7 @@
 	file.c \
 	handle.c \
 	hook.c \
+	iocompletion.c \
 	main.c \
 	mapping.c \
 	mutex.c \
Index: server/protocol.def
===================================================================
RCS file: /home/wine/wine/server/protocol.def,v
retrieving revision 1.65
diff -u -r1.65 protocol.def
--- server/protocol.def	4 Apr 2003 22:26:34 -0000	1.65
+++ server/protocol.def	21 Apr 2003 14:47:23 -0000
@@ -2119,3 +2119,39 @@
     int            next_unicode;   /* is the next a unicode hook? */
     VARARG(module,unicode_str);    /* module name */
 @END
+
+/* Create an I/O completion port */
+@REQ(create_io_completion)
+    unsigned int   access;             /* access desired by client */
+    unsigned int   concurrent_threads; /* the number of concurrent threads processing a request */
+@REPLY
+    user_handle_t  handle;             /* handle to the i/o completion port */
+@END
+
+/* Post data to an I/O completion port */
+@REQ(set_io_completion)
+    user_handle_t  handle;            /* handle to the i/o completion port */
+    unsigned int   bytes_transferred; /* number of bytes transferred */
+    void*          completion_key;    /* user data to send to waiting client */
+    void*          overlapped;        /* overlapped structure to send to client */
+@END
+
+/* Get or wait for data posted to an I/O completion port */
+@REQ(remove_io_completion)
+    user_handle_t  handle;       /* handle to the i/o completion port */
+    void*          cookie;       /* magic cookie to return to client */
+    abs_time_t     timeout;      /* absolute timeout */
+@REPLY
+    unsigned int   bytes_transferred; /* number of bytes transferred */
+    void*          completion_key;    /* user data to send to waiting client */
+    void*          overlapped;        /* overlapped structure to send to client */
+@END
+
+/* Get data posted to an I/O completion port after waiting for it */
+@REQ(remove_io_completion_assigned)
+    user_handle_t  handle;       /* handle to the i/o completion port */
+@REPLY
+    unsigned int   bytes_transferred; /* number of bytes transferred */
+    void*          completion_key;    /* user data to send to waiting client */
+    void*          overlapped;        /* overlapped structure to send to client */
+@END
Index: server/request.h
===================================================================
RCS file: /home/wine/wine/server/request.h,v
retrieving revision 1.83
diff -u -r1.83 request.h
--- server/request.h	26 Mar 2003 23:41:43 -0000	1.83
+++ server/request.h	21 Apr 2003 14:47:24 -0000
@@ -278,6 +278,10 @@
 DECL_HANDLER(start_hook_chain);
 DECL_HANDLER(finish_hook_chain);
 DECL_HANDLER(get_next_hook);
+DECL_HANDLER(create_io_completion);
+DECL_HANDLER(set_io_completion);
+DECL_HANDLER(remove_io_completion);
+DECL_HANDLER(remove_io_completion_assigned);

 #ifdef WANT_REQUEST_HANDLERS

@@ -459,6 +463,10 @@
     (req_handler)req_start_hook_chain,
     (req_handler)req_finish_hook_chain,
     (req_handler)req_get_next_hook,
+    (req_handler)req_create_io_completion,
+    (req_handler)req_set_io_completion,
+    (req_handler)req_remove_io_completion,
+    (req_handler)req_remove_io_completion_assigned,
 };
 #endif  /* WANT_REQUEST_HANDLERS */

Index: server/thread.c
===================================================================
RCS file: /home/wine/wine/server/thread.c,v
retrieving revision 1.97
diff -u -r1.97 thread.c
--- server/thread.c	4 Apr 2003 22:26:34 -0000	1.97
+++ server/thread.c	21 Apr 2003 14:47:27 -0000
@@ -519,7 +519,7 @@
 }

 /* select on a list of handles */
-static void select_on( int count, void *cookie, const obj_handle_t *handles,
+void select_on( int count, void *cookie, const obj_handle_t *handles,
                        int flags, const abs_time_t *timeout )
 {
     int ret, i;
Index: server/trace.c
===================================================================
RCS file: /home/wine/wine/server/trace.c,v
retrieving revision 1.162
diff -u -r1.162 trace.c
--- server/trace.c	4 Apr 2003 22:26:34 -0000	1.162
+++ server/trace.c	21 Apr 2003 14:47:32 -0000
@@ -2439,6 +2439,52 @@
     dump_varargs_unicode_str( cur_size );
 }

+static void dump_create_io_completion_request( const struct create_io_completion_request *req )
+{
+    fprintf( stderr, " access=%08x,", req->access );
+    fprintf( stderr, " concurrent_threads=%08x", req->concurrent_threads );
+}
+
+static void dump_create_io_completion_reply( const struct create_io_completion_reply *req )
+{
+    fprintf( stderr, " handle=%p", req->handle );
+}
+
+static void dump_set_io_completion_request( const struct set_io_completion_request *req )
+{
+    fprintf( stderr, " handle=%p,", req->handle );
+    fprintf( stderr, " bytes_transferred=%08x,", req->bytes_transferred );
+    fprintf( stderr, " completion_key=%p,", req->completion_key );
+    fprintf( stderr, " overlapped=%p", req->overlapped );
+}
+
+static void dump_remove_io_completion_request( const struct remove_io_completion_request *req )
+{
+    fprintf( stderr, " handle=%p,", req->handle );
+    fprintf( stderr, " cookie=%p,", req->cookie );
+    fprintf( stderr, " timeout=" );
+    dump_abs_time( &req->timeout );
+}
+
+static void dump_remove_io_completion_reply( const struct remove_io_completion_reply *req )
+{
+    fprintf( stderr, " bytes_transferred=%08x,", req->bytes_transferred );
+    fprintf( stderr, " completion_key=%p,", req->completion_key );
+    fprintf( stderr, " overlapped=%p", req->overlapped );
+}
+
+static void dump_remove_io_completion_assigned_request( const struct remove_io_completion_assigned_request *req )
+{
+    fprintf( stderr, " handle=%p", req->handle );
+}
+
+static void dump_remove_io_completion_assigned_reply( const struct remove_io_completion_assigned_reply *req )
+{
+    fprintf( stderr, " bytes_transferred=%08x,", req->bytes_transferred );
+    fprintf( stderr, " completion_key=%p,", req->completion_key );
+    fprintf( stderr, " overlapped=%p", req->overlapped );
+}
+
 static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
     (dump_func)dump_new_process_request,
     (dump_func)dump_get_new_process_info_request,
@@ -2615,6 +2661,10 @@
     (dump_func)dump_start_hook_chain_request,
     (dump_func)dump_finish_hook_chain_request,
     (dump_func)dump_get_next_hook_request,
+    (dump_func)dump_create_io_completion_request,
+    (dump_func)dump_set_io_completion_request,
+    (dump_func)dump_remove_io_completion_request,
+    (dump_func)dump_remove_io_completion_assigned_request,
 };

 static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
@@ -2793,6 +2843,10 @@
     (dump_func)dump_start_hook_chain_reply,
     (dump_func)0,
     (dump_func)dump_get_next_hook_reply,
+    (dump_func)dump_create_io_completion_reply,
+    (dump_func)0,
+    (dump_func)dump_remove_io_completion_reply,
+    (dump_func)dump_remove_io_completion_assigned_reply,
 };

 static const char * const req_names[REQ_NB_REQUESTS] = {
@@ -2971,6 +3025,10 @@
     "start_hook_chain",
     "finish_hook_chain",
     "get_next_hook",
+    "create_io_completion",
+    "set_io_completion",
+    "remove_io_completion",
+    "remove_io_completion_assigned",
 };

 /* ### make_requests end ### */
--- /dev/null	Mon Jun 24 01:53:01 2002
+++ dlls/ntdll/iocompletion.c	Wed Apr 16 20:37:00 2003
@@ -0,0 +1,211 @@
+/*
+ * I/O Completion Ports
+ *
+ * Copyright (C) 2003 Robert Shearman
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "winbase.h"
+#include "winnt.h"
+#include "winternl.h"
+
+#include "config.h"
+
+#include "ntdll_misc.h"
+#include "wine/server.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
+
+extern int NTDLL_wait_reply( void *cookie );
+
+/**************************************************************************
+ * NtCreateIoCompletion (NTDLL.@)
+ *
+ * Params:
+ *   CompletionPort [O]: the handle created
+ *   DesiredAccess [I}:  the access desired (e.g. GENERIC_ALL)
+ *   Reserved [I}:       unknown
+ *   NumberOfConcurrentThreads [I]: the desired number of concurrent
+ *                                  threads
+ * Returns:
+ *   Status
+ * Notes:
+ *   It is effectively a FIFO queue for data and
+ *   a LIFO queue for threads to "minimize context switches".
+ *   The aim is to keep a small number of threads constantly
+ *   active.
+ * See:
+ *   MSDN for CreateIoCompletionPort spec and
+ *   the article "Inside I/O Completion Ports"
+ *   (http://www.sysinternals.com/ntw2k/info/comport.shtml)
+ */
+NTSTATUS WINAPI NtCreateIoCompletion (
+	OUT	PHANDLE			CompletionPort,
+	IN	ACCESS_MASK		DesiredAccess,
+	IN	ULONG_PTR		Reserved,
+	IN	ULONG			NumberOfConcurrentThreads
+	)
+{
+    NTSTATUS ret;
+
+    TRACE("(%p, %lx, %lx, %ld)\n",
+        CompletionPort,
+        DesiredAccess,
+        Reserved,
+        NumberOfConcurrentThreads);
+
+    if (Reserved != 0)
+    {
+        FIXME("Reserved != 0 not supported\n");
+        return STATUS_INVALID_PARAMETER;
+    }
+
+    if (DesiredAccess && GENERIC_ALL)
+        DesiredAccess |= GENERIC_READ | GENERIC_WRITE;
+
+    SERVER_START_REQ( create_io_completion )
+    {
+        req->access             = DesiredAccess;
+        req->concurrent_threads = NumberOfConcurrentThreads;
+        ret = wine_server_call( req );
+        *CompletionPort = reply->handle;
+    }
+    SERVER_END_REQ;
+
+    TRACE("returning %lx\n", ret);
+    return ret;
+}
+
+/**************************************************************************
+ * NtSetIoCompletion (NTDLL.@)
+ *
+ * Params:
+ *   CompletionPort [I]: port to send data to
+ *   CompletionKey [I}: user key to identify this set of data
+ *   lpOverlapped [I}: OVERLAPPED structure to send to port
+ *   NumberOfBytesTransferred [I}: unknown - seems to be set to zero always
+ *   NumberOfBytesToTransfer [I]: Bytes to transfer in this packet of data
+ * Returns:
+ *   Status
+ * See:
+ *   MSDN for PostQueuedCompletionStatus spec and
+ *   the article "Inside I/O Completion Ports"
+ *   (http://www.sysinternals.com/ntw2k/info/comport.shtml)
+ */
+NTSTATUS WINAPI NtSetIoCompletion(
+	IN	HANDLE			CompletionPort,
+	IN	ULONG_PTR		CompletionKey,
+	IN	LPOVERLAPPED	lpOverlapped,
+	IN	ULONG			NumberOfBytesTransferred, /* normally set to 0 */
+	IN	ULONG			NumberOfBytesToTransfer /* will become number of bytes transferred in the io operation */
+	)
+{
+    NTSTATUS ret;
+
+    TRACE("(%p, %lx, %p, %ld, %ld)\n",
+        CompletionPort,
+        CompletionKey,
+        lpOverlapped,
+        NumberOfBytesTransferred,
+        NumberOfBytesToTransfer);
+
+    if (NumberOfBytesTransferred != 0)
+    {
+        FIXME("NumberOfBytesTransferred != 0 not supported\n");
+        return STATUS_INVALID_PARAMETER;
+    }
+
+    SERVER_START_REQ( set_io_completion )
+    {
+        req->handle             = CompletionPort;
+        req->completion_key     = (void *)CompletionKey;
+        req->overlapped         = lpOverlapped;
+        req->bytes_transferred  = NumberOfBytesToTransfer;
+        ret = wine_server_call( req );
+    }
+    SERVER_END_REQ;
+
+    TRACE("returning %lx\n", ret);
+    return ret;
+}
+
+/**************************************************************************
+ * NtRemoveIoCompletion (NTDLL.@)
+ *
+ * See: MSDN for GetQueuedCompletionStatus spec and
+ * the article "Inside I/O Completion Ports"
+ * (http://www.sysinternals.com/ntw2k/info/comport.shtml)
+ */
+NTSTATUS WINAPI NtRemoveIoCompletion (
+	IN	HANDLE				CompletionPort,
+	OUT	PULONG_PTR			CompletionKey,
+	OUT	LPOVERLAPPED *		lplpOverlapped,
+	OUT	PIO_STATUS_BLOCK	CompletionStatus,
+	IN	PLARGE_INTEGER		WaitTime
+	)
+{
+    NTSTATUS ret;
+    int cookie;
+
+    TRACE("(%p, %p, %p, %p, %p)\n",
+        CompletionPort,
+        CompletionKey,
+        lplpOverlapped,
+        CompletionStatus,
+        WaitTime);
+
+    for (;;)
+    {
+        SERVER_START_REQ( remove_io_completion )
+        {
+            req->handle = CompletionPort;
+            req->cookie = &cookie;
+            NTDLL_get_server_timeout( &req->timeout, WaitTime );
+            ret = wine_server_call( req );
+            if (ret == STATUS_SUCCESS)
+            {
+                *CompletionKey = (ULONG_PTR)reply->completion_key;
+                *lplpOverlapped = reply->overlapped;
+                CompletionStatus->u.Status = STATUS_SUCCESS;
+                CompletionStatus->Information = reply->bytes_transferred;
+            }
+        }
+        SERVER_END_REQ;
+        if (ret == STATUS_PENDING)
+            ret = NTDLL_wait_reply( &cookie );
+        if (ret == STATUS_ABANDONED)
+        {
+            SERVER_START_REQ( remove_io_completion_assigned )
+            {
+                req->handle = CompletionPort;
+                ret = wine_server_call( req );
+                if (ret == STATUS_SUCCESS)
+                {
+                    *CompletionKey = (ULONG_PTR)reply->completion_key;
+                    *lplpOverlapped = reply->overlapped;
+                    CompletionStatus->u.Status = STATUS_SUCCESS;
+                    CompletionStatus->Information = reply->bytes_transferred;
+                }
+            }
+            SERVER_END_REQ;
+        }
+        break;
+    }
+
+    TRACE("returning %lx\n", ret);
+    return ret;
+}
--- /dev/null	Mon Jun 24 01:53:01 2002
+++ server/iocompletion.c	Mon Apr 21 16:10:27 2003
@@ -0,0 +1,309 @@
+/*
+ * I/O Completion Ports
+ *
+ * Copyright (C) 2003 Robert Shearman
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "config.h"
+#include "wine/port.h"
+
+#include <stdio.h>
+
+#include "windef.h"
+
+#include "handle.h"
+#include "thread.h"
+#include "request.h"
+#include "list.h"
+
+static void io_completion_dump( struct object *obj, int verbose );
+static void io_completion_destroy( struct object *obj );
+static int io_completion_signaled( struct object * obj, struct thread * thread );
+static int io_completion_satisfied( struct object * obj, struct thread * thread );
+
+extern void select_on( int count, void *cookie, const obj_handle_t *handles,
+                       int flags, const abs_time_t *timeout );
+
+struct io_completion_data
+{
+    struct list entry;
+    unsigned int bytes_transferred;
+    void * completion_key;
+    void * overlapped;
+};
+
+struct io_completion_assigned_data
+{
+    struct list entry;
+    struct thread * thread;
+    struct io_completion_data * data;
+};
+
+struct io_completion_port
+{
+    struct object obj;
+    unsigned int concurrent_threads;
+    unsigned int max_concurrent_threads; /* FIXME: should we honour this? */
+    struct io_completion_data * data_head; /* fifo queue for data */
+    struct io_completion_data * data_tail;
+
+    struct io_completion_assigned_data * assigned_data;
+
+    /* Used to determine whether we have initiated the select() 
+     * through GetQueuedCompletionStatus or whether the client 
+     * has done WaitForSingleObject */
+    int satisfied;
+};
+
+static const struct object_ops io_completion_ops =
+{
+    sizeof(struct io_completion_port), /* size */
+    io_completion_dump,                /* dump */
+    add_queue,                         /* add_queue */
+    remove_queue,                      /* remove_queue */
+    io_completion_signaled,            /* signaled */
+    io_completion_satisfied,           /* satisfied */
+    no_get_fd,                         /* get_fd */
+    io_completion_destroy              /* destroy */
+};
+
+static void io_completion_dump( struct object *obj, int verbose )
+{
+    struct io_completion_port *port = (struct io_completion_port *)obj;
+    assert( obj->ops == &io_completion_ops );
+    fprintf( stderr, "I/O completion port max_threads=%d data_head=%p data_tail=%p\n",
+             port->max_concurrent_threads, port->data_head, port->data_tail );
+}
+
+static void io_completion_destroy( struct object *obj )
+{
+    struct list * current;
+    struct list * next;
+    struct io_completion_port *port = (struct io_completion_port *)obj;
+    assert( obj->ops == &io_completion_ops );
+
+    /* free data queue */
+    if (port->data_head)
+    {
+        for (current = &port->data_head->entry, next = current->next;
+             next != current; current = next)
+        {
+            next = current->next;
+            free( current );
+        }
+    }
+
+    /* free assigned data queue */
+    if (port->assigned_data)
+    {
+        for (current = &port->assigned_data->entry, next = current->next;
+             next != current; current = next)
+        {
+            next = current->next;
+            free( ((struct io_completion_assigned_data *)current)->data );
+            free( current );
+        }
+    }
+}
+
+static int io_completion_signaled( struct object * obj, struct thread * thread )
+{
+    struct io_completion_port * port = (struct io_completion_port *)obj;
+    assert( obj->ops == &io_completion_ops );
+    return (port->data_head != NULL);
+}
+
+static int io_completion_satisfied( struct object * obj, struct thread * thread )
+{
+    struct io_completion_port * port = (struct io_completion_port *)obj;
+    assert( obj->ops == &io_completion_ops );
+    return port->satisfied;
+}
+
+static struct object * create_io_completion(unsigned int concurrent_threads)
+{
+    struct io_completion_port * port;
+    if (!(port = alloc_object( &io_completion_ops )))
+    {
+        return NULL;
+    }
+
+    port->data_head = NULL;
+    port->data_tail = NULL;
+    port->assigned_data = NULL;
+    port->concurrent_threads = 0;
+    port->max_concurrent_threads = concurrent_threads;
+    port->satisfied = 1; /* abandon any waits on the port immediately */
+
+    return &port->obj;
+}
+
+static void assign_data(struct io_completion_port * port, struct thread * thread)
+{
+    struct io_completion_data * data = port->data_head;
+    struct io_completion_assigned_data * assigned_data;
+    if ((assigned_data = mem_alloc(sizeof(*data))) != NULL)
+    {
+        list_init(&assigned_data->entry);
+        assigned_data->data = data;
+        assigned_data->thread = thread;
+
+        if (port->assigned_data)
+            list_add_head( &port->assigned_data->entry, &assigned_data->entry );
+        port->assigned_data = assigned_data;
+
+        port->data_head = (struct io_completion_data *)
+                              list_next( &data->entry, &data->entry );
+        list_remove( &data->entry );
+        if (port->data_tail == data) /* i.e. we removed the last one */
+            port->data_tail = port->data_head = NULL;
+    }
+}
+
+DECL_HANDLER(create_io_completion)
+{
+    struct object * obj;
+
+    reply->handle = 0;
+    if ((obj = create_io_completion(req->concurrent_threads)) != NULL)
+    {
+        reply->handle = alloc_handle(current->process, obj, req->access | SYNCHRONIZE, FALSE /*inherit flag*/);
+        release_object( obj );
+    }
+}
+
+DECL_HANDLER(remove_io_completion)
+{
+    struct io_completion_port * port = (struct io_completion_port *)get_handle_obj(
+        current->process,
+        req->handle,
+        GENERIC_READ,
+        &io_completion_ops);
+
+    if (!port)
+    {
+        reply->bytes_transferred = 0;
+        reply->completion_key = NULL;
+        reply->overlapped = NULL;
+        return;
+    }
+
+    if (port->data_head) /* there is waiting data */
+    {
+        struct io_completion_data * data = port->data_head;
+        reply->bytes_transferred = data->bytes_transferred;
+        reply->completion_key = data->completion_key;
+        reply->overlapped = data->overlapped;
+        port->data_head = (struct io_completion_data *)
+                              list_next( &data->entry, &data->entry );
+        list_remove( &data->entry );
+        if (port->data_tail == data) /* i.e. we removed the last one */
+            port->data_tail = port->data_head = NULL;
+        free( data );
+    }
+    else /* there is no waiting data */
+    {
+        port->satisfied = 0; /* don't abandon wait on the port */
+        select_on(1, req->cookie, &req->handle, SELECT_TIMEOUT, &req->timeout);
+        port->satisfied = 1; /* abandon any waits on the port immediately */
+        reply->bytes_transferred = 0;
+        reply->completion_key = NULL;
+        reply->overlapped = NULL;
+    }
+    release_object( &port->obj );
+}
+
+DECL_HANDLER(set_io_completion)
+{
+    struct io_completion_data * data;
+    struct io_completion_port * port = (struct io_completion_port *)get_handle_obj(
+        current->process,
+        req->handle,
+        GENERIC_WRITE,
+        &io_completion_ops);
+
+    if (!port)
+        return;
+
+    if ((data = mem_alloc(sizeof(*data))) != NULL)
+    {
+        list_init(&data->entry);
+        data->bytes_transferred = req->bytes_transferred;
+        data->completion_key = req->completion_key;
+        data->overlapped = req->overlapped;
+
+        if (port->data_head == NULL) /* need to update head as well */
+            port->data_head = data;
+        else /* need to update existing data to reflect new data added */
+            list_add_tail(&port->data_tail->entry, &data->entry);
+
+        port->data_tail = data;
+
+        if (port->obj.tail != NULL) /* there is a waiting thread */
+        {
+            struct wait_queue_entry * waiting = port->obj.tail;
+            assign_data( port, waiting->thread );
+            wake_thread( waiting->thread );
+        }
+    }
+    release_object( &port->obj );
+}
+
+DECL_HANDLER(remove_io_completion_assigned)
+{
+    struct io_completion_assigned_data * assigned_data;
+    struct io_completion_port * port = (struct io_completion_port *)get_handle_obj(
+        current->process,
+        req->handle,
+        GENERIC_WRITE,
+        &io_completion_ops);
+
+    if (!port)
+    {
+        reply->bytes_transferred = 0;
+        reply->completion_key = NULL;
+        reply->overlapped = NULL;
+        return;
+    }
+
+    if (port->assigned_data)
+    {
+        LIST_FOR_EACH((struct list *)assigned_data, &port->assigned_data->entry)
+        {
+            if (assigned_data->thread == current)
+            {
+                reply->bytes_transferred = assigned_data->data->bytes_transferred;
+                reply->completion_key = assigned_data->data->completion_key;
+                reply->overlapped = assigned_data->data->overlapped;
+                if (port->assigned_data == assigned_data)
+                {
+                    port->assigned_data = (struct io_completion_assigned_data *)
+                        list_next( &port->assigned_data->entry, &port->assigned_data->entry );
+                }
+                list_remove( &assigned_data->entry );
+                free( assigned_data->data );
+                free( assigned_data );
+                return;
+            }
+        }
+    }
+
+    set_error(STATUS_INVALID_PARAMETER);
+    reply->bytes_transferred = 0;
+    reply->completion_key = NULL;
+    reply->overlapped = NULL;
+}

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux