I/O Completion Ports (1 of 2)

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

 



This is the server / NTDLL code of my implementation of I/O completion ports.
I have tried to make it patch against current CVS where possible, but I have a week old snapshot on my development machine at the moment :(
There is one thing not implemented by this patch (the NumberOfConcurrentThreads parameter) which is pretty much optional anyway and is only a performance affecting thing. I will probably submit a patch to implement this if these two patches are accepted.

ChangeLog:
- Add server support for I/O completion ports
License:
- LGPL

Rob

diff -r -u -x *.o wine/dlls/ntdll/Makefile.in newwine/dlls/ntdll/Makefile.in
--- wine/dlls/ntdll/Makefile.in	Fri Mar 21 15:37:41 2003
+++ newwine/dlls/ntdll/Makefile.in	Fri Mar 21 15:39:46 2003
@@ -79,6 +79,7 @@
 	error.c \
 	file.c \
 	heap.c \
+	iocompletion.c \
 	large_int.c \
 	loader.c \
 	misc.c \
diff -r -u -x *.o wine/dlls/ntdll/error.c newwine/dlls/ntdll/error.c
--- wine/dlls/ntdll/error.c	Fri Mar 21 15:37:41 2003
+++ newwine/dlls/ntdll/error.c	Sat Mar 22 22:32:50 2003
@@ -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 },
diff -r -u -x *.o wine/dlls/ntdll/ntdll.spec newwine/dlls/ntdll/ntdll.spec
--- wine/dlls/ntdll/ntdll.spec	Fri Mar 21 15:37:41 2003
+++ newwine/dlls/ntdll/ntdll.spec	Sat Mar 22 20:03:00 2003
@@ -77,7 +77,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
@@ -189,7 +189,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)
@@ -217,7 +217,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
diff -r -u -x *.o wine/server/Makefile.in newwine/server/Makefile.in
--- wine/server/Makefile.in	Wed Feb 19 20:10:11 2003
+++ newwine/server/Makefile.in	Fri Mar 21 14:10:26 2003
@@ -20,6 +20,7 @@
 	file.c \
 	handle.c \
 	hook.c \
+	iocompletion.c \
 	main.c \
 	mapping.c \
 	mutex.c \
diff -r -u -x *.o wine/server/protocol.def newwine/server/protocol.def
--- wine/server/protocol.def	Fri Mar 21 14:40:52 2003
+++ newwine/server/protocol.def	Fri Mar 21 16:00:56 2003
@@ -144,6 +144,17 @@
     int   signaled;  /* wait result */
 };

+/* structure sent by the server to send the
+ * io completion data to a waiting thread */
+struct io_completion_send_data_reply
+{
+    void *cookie;    /* magic cookie that was passed in select_request */
+    int signaled;    /* wait result */
+    unsigned int bytes_transferred;
+    void * completion_key;
+    void * overlapped;
+};
+
 /* structure for process startup info */
 typedef struct
 {
diff -r -u -x *.o wine/server/thread.c newwine/server/thread.c
--- wine/server/thread.c	Fri Mar 21 14:09:22 2003
+++ newwine/server/thread.c	Fri Mar 21 16:05:46 2003
@@ -41,6 +41,7 @@
 #include "thread.h"
 #include "request.h"
 #include "user.h"
+#include "iocompletion.h"


 /* thread queues */
@@ -1013,3 +1014,53 @@
         release_object( thread );
     }
 }
+
+/* adds a timeout for a thread waiting for data to be
+ * sent to an io completion port */
+void io_completion_sleep(void * cookie, int sec, int usec)
+{
+    select_on(0, cookie, NULL, SELECT_TIMEOUT, sec, usec);
+}
+
+
+/* send the wakeup signal and io completion data to a thread */
+static int io_completion_send_data( struct thread *thread, void *cookie, struct io_completion_data * data )
+{
+    struct io_completion_send_data_reply reply;
+    int ret;
+
+    reply.cookie   = cookie;
+    reply.signaled = STATUS_SUCCESS;
+    reply.bytes_transferred = data->bytes_transferred;
+    reply.completion_key = data->completion_key;
+    reply.overlapped = data->overlapped;
+    if ((ret = write( get_unix_fd( thread->wait_fd ), &reply, sizeof(reply) )) == sizeof(reply))
+        return 0;
+    if (ret >= 0)
+        fatal_protocol_error( thread, "partial wakeup write %d\n", ret );
+    else if (errno == EPIPE)
+        kill_thread( thread, 0 );  /* normal death */
+    else
+        fatal_protocol_perror( thread, "write" );
+    return -1;
+}
+
+/* attempt to wake up a thread */
+/* return >0 if OK, 0 if the wait condition is still not satisfied */
+int io_completion_send_data_wakeup( struct thread *thread, struct io_completion_data *data )
+{
+    int count;
+    void *cookie;
+
+    for (count = 0; thread->wait; count++)
+    {
+        cookie = thread->wait->cookie;
+        if (debug_level) fprintf( stderr, "%04x: *i/o completion wakeup* cookie=%p\n",
+                                  thread->id, cookie );
+        end_wait( thread );
+        if (io_completion_send_data( thread, cookie, data ) == -1) /* error */
+            break;
+    }
+    return count;
+}
+
--- /dev/null	Mon Jun 24 01:53:01 2002
+++ wine/dlls/ntdll/iocompletion.c	Sat Mar 22 21:24:27 2003
@@ -0,0 +1,297 @@
+/*
+ * 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 <assert.h>
+#include <errno.h>
+#include <signal.h>
+#ifdef HAVE_SYS_TIME_H
+# include <sys/time.h>
+#endif
+#ifdef HAVE_SYS_POLL_H
+# include <sys/poll.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#include "wine/server.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
+
+/**************************************************************************
+ * 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);
+
+    WARN("NumberOfConcurrentThreads ignored - performance issue only\n");
+
+    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;
+}
+
+inline static void reliable_write(void * data, size_t size)
+{
+    int ret;
+    if (size <= 0)
+        return;
+    for (;;)
+    {
+        ret = write( NtCurrentTeb()->wait_fd[1], data, size );
+        if (ret == size) break;
+        if (ret >= 0) server_protocol_error( "partial wakeup write %d\n", ret );
+        if (errno == EINTR) continue;
+        server_protocol_perror("wakeup write");
+    }
+}
+
+/***********************************************************************
+ *              wait_data_or_wakeup_reply
+ *
+ * Wait for a reply on the waiting pipe of the current thread.
+ */
+static int wait_data_or_wakeup_reply( void *cookie, struct io_completion_send_data_reply * data_reply )
+{
+    struct io_completion_send_data_reply reply;
+    for (;;)
+    {
+        int ret;
+        int retval;
+        ret = read( NtCurrentTeb()->wait_fd[0], &reply, sizeof(reply) );
+        if ((ret == sizeof(struct wake_up_reply)) ||
+            (ret == sizeof(reply)) )
+        {
+            if (!reply.cookie) break;  /* thread got killed */
+            if (reply.cookie == cookie)
+            {
+                if ((reply.signaled == STATUS_SUCCESS) && (ret == sizeof(reply)))
+                {
+                    RtlCopyMemory(data_reply, &reply, sizeof(reply));
+                    return reply.signaled;
+                }
+                else
+                {
+                    /* have to put the extra bit of data back in */
+                    reliable_write(((char *)&reply)+sizeof(struct wake_up_reply),
+                                   ret - sizeof(struct wake_up_reply));
+                    return reply.signaled;
+                }
+            }
+            /* we stole another reply, wait for the real one */
+            retval = wait_data_or_wakeup_reply( cookie, data_reply );
+            /* and now put the wrong one back in the pipe */
+            reliable_write(&reply, sizeof(reply));
+            return retval;
+        }
+        if (ret >= 0) server_protocol_error( "partial wakeup read %d\n", ret );
+        if (errno == EINTR) continue;
+        server_protocol_perror("wakeup read");
+    }
+    /* the server closed the connection; time to die... */
+    SYSDEPS_AbortThread(0);
+}
+
+/***********************************************************************
+ *              get_timeout
+ */
+inline static void get_timeout( struct timeval *when, int timeout )
+{
+    gettimeofday( when, 0 );
+    if (timeout)
+    {
+        long sec = timeout / 1000;
+        if ((when->tv_usec += (timeout - 1000*sec) * 1000) >= 1000000)
+        {
+            when->tv_usec -= 1000000;
+            when->tv_sec++;
+        }
+        when->tv_sec += sec;
+    }
+}
+
+/**************************************************************************
+ * 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;
+    struct timeval tv;
+    int cookie;
+
+    TRACE("(%p, %p, %p, %p, %p)\n",
+        CompletionPort,
+        CompletionKey,
+        lplpOverlapped,
+        CompletionStatus,
+        WaitTime);
+
+    if (WaitTime == NULL) tv.tv_sec = tv.tv_usec = 0; /* INFINITE */
+    else get_timeout( &tv, - WaitTime->QuadPart / 10000 );
+
+    SERVER_START_REQ( remove_io_completion )
+    {
+        req->handle             = CompletionPort;
+        req->sec = tv.tv_sec;
+        req->usec = tv.tv_usec;
+        req->cookie = &cookie;
+        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)
+    {
+        struct io_completion_send_data_reply data;
+        ret = wait_data_or_wakeup_reply(&cookie, &data);
+        if (ret == STATUS_SUCCESS)
+        {
+            *CompletionKey = (ULONG_PTR)data.completion_key;
+            *lplpOverlapped = data.overlapped;
+            CompletionStatus = STATUS_SUCCESS;
+            CompletionStatus->Information = data.bytes_transferred;
+        }
+    }
+
+    TRACE("returning %lx\n", ret);
+    return ret;
+}
--- /dev/null	Mon Jun 24 01:53:01 2002
+++ wine/server/iocompletion.c	Sat Mar 22 20:23:11 2003
@@ -0,0 +1,192 @@
+/*
+ * 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 "iocompletion.h"
+
+static void io_completion_dump( struct object *obj, int verbose );
+extern void io_completion_sleep(void * cookie, int sec, int usec);
+extern int io_completion_send_data_wakeup( struct thread *thread, struct io_completion_data *data );
+
+struct io_completion_wait_queue
+{
+    struct list entry;
+    struct thread * thread;
+};
+
+struct io_completion_port
+{
+    struct object obj;
+    unsigned int concurrent_threads;
+    unsigned int max_concurrent_threads; /* should we honour this? */
+    struct io_completion_data * data_head; /* fifo queue for data */
+    struct io_completion_data * data_tail;
+
+    /* lifo queue for threads to 'minimize context switches'*/
+    struct io_completion_wait_queue * wait_head;
+};
+
+static const struct object_ops io_completion_ops =
+{
+    sizeof(struct io_completion_port), /* size */
+    io_completion_dump,                /* dump */
+    no_add_queue,                      /* add_queue */
+    NULL,                              /* remove_queue */
+    NULL,                              /* signaled */
+    no_satisfied,                      /* satisfied */
+    no_get_fd,                         /* get_fd */
+    no_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 wait_head=%p\n",
+             port->max_concurrent_threads, port->data_head, port->data_tail, port->wait_head );
+}
+
+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->wait_head = NULL;
+    port->concurrent_threads = 0;
+    port->max_concurrent_threads = concurrent_threads;
+
+    return &port->obj;
+}
+
+DECL_HANDLER(create_io_completion)
+{
+    struct object * obj;
+    fprintf(stderr, "Point 1\n");
+
+    reply->handle = 0;
+    if ((obj = create_io_completion(req->concurrent_threads)) != NULL)
+    {
+        fprintf(stderr, "Point 2\n");
+        reply->handle = alloc_handle(current->process, obj, req->access, FALSE /*inherit flag*/);
+        fprintf(stderr, "Point 3\n");
+        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 );
+        if (port->data_tail == data) /* i.e. we removed the last one */
+            port->data_tail = port->data_head; /* port->data_head should be NULL */
+        free( data );
+    }
+    else /* there is no waiting data */
+    {
+        struct io_completion_wait_queue * waiting_thread;
+        if ( (waiting_thread = mem_alloc( sizeof(*waiting_thread) )) != NULL )
+        {
+            list_init(&waiting_thread->entry);
+            waiting_thread->thread = current;
+            io_completion_sleep(req->cookie, req->sec, req->usec);
+            reply->bytes_transferred = 0;
+            reply->completion_key = NULL;
+            reply->overlapped = NULL;
+            set_error( STATUS_PENDING );
+        }
+    }
+    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->wait_head == NULL) /* there is no waiting thread */
+        {
+            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;
+        }
+        else /* there is a waiting thread */
+        {
+            struct io_completion_wait_queue * head = port->wait_head;
+            struct thread * waiting_thread = head->thread;
+            port->wait_head = (struct io_completion_wait_queue *)
+                                  list_next( &head->entry, &head->entry );
+            io_completion_send_data_wakeup( waiting_thread, data );
+            free( data );
+            free( head );
+        }
+    }
+    release_object( &port->obj );
+}
--- /dev/null	Mon Jun 24 01:53:01 2002
+++ wine/server/iocompletion.h	Fri Mar 21 14:51:05 2003
@@ -0,0 +1,29 @@
+/*
+ * 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 "list.h"
+
+struct io_completion_data
+{
+    struct list entry;
+    unsigned int bytes_transferred;
+    void * completion_key;
+    void * overlapped;
+};
--- wine/include/wine/server_protocol.h	Sun Mar 23 22:15:31 2003
+++ newwine/include/wine/server_protocol.h	Sun Mar 23 22:14:45 2003
@@ -128,6 +128,17 @@
     int   signaled;
 };

+/* structure sent by the server to send the
+ * io completion data to a waiting thread */
+struct io_completion_send_data_reply
+{
+    void *cookie;
+    int signaled;
+    unsigned int bytes_transferred;
+    void * completion_key;
+    void * overlapped;
+};
+

 typedef struct
 {
@@ -3012,6 +3023,47 @@
     /* VARARG(module,unicode_str); */
 };

+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;
+    int            sec;
+    int            usec;
+};
+struct remove_io_completion_reply
+{
+    struct reply_header __header;
+    unsigned int   bytes_transferred;
+    void*          completion_key;
+    void*          overlapped;
+};
+

 enum request
 {
@@ -3189,6 +3241,9 @@
     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_NB_REQUESTS
 };

@@ -3370,6 +3425,9 @@
     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;
 };
 union generic_reply
 {
@@ -3549,8 +3607,11 @@
     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;
 };

-#define SERVER_PROTOCOL_VERSION 102
+#define SERVER_PROTOCOL_VERSION 103

 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */
--- wine/include/winternl.h	Sun Mar 23 22:46:44 2003
+++ newwine/include/winternl.h	Sun Mar 23 22:46:28 2003
@@ -1234,6 +1234,22 @@
 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" */
 #endif /* defined(__cplusplus) */

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

  Powered by Linux