Patch: 001-file_overlapped.diff

Martin Wilck Martin.Wilck at fujitsu-siemens.com
Mon Jan 7 09:32:25 CST 2002


This patch is a repost of my patch of 2002-01-03, now against the
current CVS version including Mike McCormack's latest patches
(01-cancelio.diff, 01-write_file_update.diff, 01-comm16_update.diff
as of 2002-01-06).

It is the first in a series of patches that constitute intermediate steps
towards async socket IO. I consider them pretty clean and have done basic
testing. My testing possibilities are limited, though - I'd be grateful to
anybody who could run tests especially with 16-bit network-oriented
windows applications. Bugs in my code should show up immediately as
regressions.

Patch file:	001-file_overlapped.diff
Purpose:	This patch fixes overlapped I/O on regular files.
Created: 	2002-01-07
Applies:	CVS 2002-01-07
                with Mike McCorkack's patches of 2002-01-06 applied
                (01-cancelio.diff, 01-write_file_update.diff, 01-comm16_update.diff)

Add server side support for async IO on files.

FILE_Async[Read|Write]Service and WriteFile()
use pread() / pwrite() rather than read() / write () for fd's on
which lseek()ing is possible to honour the fact that
lpOverlapped->Offset and lpOverlapped->OffsetHigh
contain the offset from which the file is to be read.

files/file.c:
        OVERLAPPED_OFFSET: Macro to calculate file offset from OVERLAPPED struct.
	FILE_AsyncReadService():
		Use pread() on fd's that allow lseek().
	FILE_AsyncWriteService():
		Use pwrite() on fd's that allow lseek().
        WriteFile(): dito.

server/file.c:
	struct file:
		Add two struct async_queue fields (for async read/write).
	file_ops:
		file specific poll_event() method accounts for overlapped IO.
		define queue_async() method.
	create_file_for_fd():
		call init_async_queue() on overlapped files.
	file_poll_event():
		call default_poll_event() only after checking for queued
			async requests.
	file_get_info():
		return FD_TYPE_OVERLAPPED if FILE_FLAG_OVERLAPPED is set.
	file_queue_async():
		implement queue_async() method for files.
	file_destroy():
		destroy async queues on overlapped files.

Martin Wilck <Martin.Wilck at Fujitsu-Siemens.com>

diff -ruX diffignore CVS/wine/files/file.c MW/wine/files/file.c
--- CVS/wine/files/file.c	Mon Jan  7 15:54:59 2002
+++ MW/wine/files/file.c	Mon Jan  7 15:55:36 2002
@@ -9,6 +9,9 @@
  *    Right now, they simply call the CopyFile method.
  */

+/* This is needed to avoid compile-time warnings about pread / pwrite */
+#define _GNU_SOURCE
+#define _XOPEN_SOURCE 500
 #include "config.h"
 #include "wine/port.h"

@@ -55,6 +58,9 @@
 /* Size of per-process table of DOS handles */
 #define DOS_TABLE_SIZE 256

+/* Macro to derive file offset from OVERLAPPED struct */
+#define OVERLAPPED_OFFSET(overlapped) ((off_t) (overlapped)->Offset + ((off_t) (overlapped)->OffsetHigh << 32))
+
 static HANDLE dos_handles[DOS_TABLE_SIZE];


@@ -1304,12 +1310,21 @@
 {
     LPOVERLAPPED lpOverlapped = ovp->lpOverlapped;
     int result, r;
+    int already = lpOverlapped->InternalHigh;

     TRACE("%p %p\n", lpOverlapped, ovp->buffer );

     /* check to see if the data is ready (non-blocking) */
-    result = read(ovp->fd, &ovp->buffer[lpOverlapped->InternalHigh],
-                  ovp->count - lpOverlapped->InternalHigh);
+
+    /* Check if this file object can lseek() */
+    /* FIXME: test this only once for each file object ?? */
+    if (lseek (ovp->fd, 0, SEEK_CUR) != (off_t) -1)
+	result = pread (ovp->fd,
+			&ovp->buffer[already],
+			ovp->count - already,
+			OVERLAPPED_OFFSET (lpOverlapped) + already);
+    else
+	result = read (ovp->fd, &ovp->buffer[already], ovp->count - already);

     if ( (result<0) && ((errno == EAGAIN) || (errno == EINTR)))
     {
@@ -1543,12 +1558,21 @@
 {
     LPOVERLAPPED lpOverlapped = ovp->lpOverlapped;
     int result, r;
+    int already = lpOverlapped->InternalHigh;

     TRACE("(%p %p)\n",lpOverlapped,ovp->buffer);

     /* write some data (non-blocking) */
-    result = write(ovp->fd, &ovp->buffer[lpOverlapped->InternalHigh],
-                  ovp->count-lpOverlapped->InternalHigh);
+
+    /* Check if this file object can lseek() */
+    /* FIXME: test this only once for each file object ?? */
+    if (lseek (ovp->fd, 0, SEEK_CUR) != (off_t) -1)
+	result = pwrite (ovp->fd,
+			 &ovp->buffer[already],
+			 ovp->count - already,
+			 OVERLAPPED_OFFSET (lpOverlapped) + already);
+    else
+	result = write (ovp->fd, &ovp->buffer[already], ovp->count - already);

     if ( (result<0) && ((errno == EAGAIN) || (errno == EINTR)))
     {
@@ -1678,7 +1702,13 @@
         }

         /* see if we can write some data already (this shouldn't block) */
-        result = write( unix_handle, buffer, bytesToWrite );
+
+        if ( lseek(unix_handle, 0, SEEK_CUR) != (off_t) -1 )
+            result = pwrite( unix_handle, buffer, bytesToWrite,
+                             OVERLAPPED_OFFSET (overlapped) );
+        else
+            result = write( unix_handle, buffer, bytesToWrite );
+
         close(unix_handle);

         if(result<0)
@@ -1693,7 +1723,7 @@
                 result = 0;
         }

-        /* if we read enough to keep the app happy, then return now */
+        /* if we wrote enough to keep the app happy, then return now */
         if(result>=bytesToWrite)
         {
             *bytesWritten = result;
diff -ruX diffignore CVS/wine/server/file.c MW/wine/server/file.c
--- CVS/wine/server/file.c	Mon Jan  7 15:54:59 2002
+++ MW/wine/server/file.c	Mon Jan  7 15:55:28 2002
@@ -29,6 +29,7 @@
 #include "handle.h"
 #include "thread.h"
 #include "request.h"
+#include "async.h"

 struct file
 {
@@ -39,6 +40,9 @@
     unsigned int        flags;      /* flags (FILE_FLAG_*) */
     unsigned int        sharing;    /* file sharing mode */
     int                 drive_type; /* type of drive the file is on */
+
+    struct async_queue  read_q;
+    struct async_queue  write_q;
 };

 #define NAME_HASH_SIZE 37
@@ -47,10 +51,12 @@

 static void file_dump( struct object *obj, int verbose );
 static int file_get_poll_events( struct object *obj );
+static void file_poll_event( struct object *obj, int event );
 static int file_get_fd( struct object *obj );
 static int file_flush( struct object *obj );
 static int file_get_info( struct object *obj, struct get_file_info_reply *reply );
 static void file_destroy( struct object *obj );
+static struct async_queue * file_queue_async(struct object *obj, struct async* async, int type, int count);

 static const struct object_ops file_ops =
 {
@@ -61,11 +67,11 @@
     default_poll_signaled,        /* signaled */
     no_satisfied,                 /* satisfied */
     file_get_poll_events,         /* get_poll_events */
-    default_poll_event,           /* poll_event */
+    file_poll_event,              /* poll_event */
     file_get_fd,                  /* get_fd */
     file_flush,                   /* flush */
     file_get_info,                /* get_file_info */
-    NULL,                         /* queue_async */
+    file_queue_async,             /* queue_async */
     file_destroy                  /* destroy */
 };

@@ -116,6 +122,11 @@
         file->flags      = attrs;
         file->sharing    = sharing;
         file->drive_type = drive_type;
+	if (file->flags & FILE_FLAG_OVERLAPPED)
+	{
+	    init_async_queue (&file->read_q);
+	    init_async_queue (&file->write_q);
+	}
     }
     return file;
 }
@@ -253,6 +264,27 @@
     return events;
 }

+static void file_poll_event( struct object *obj, int event )
+{
+    struct file *file = (struct file *)obj;
+    assert( obj->ops == &file_ops );
+    if ( file->flags & FILE_FLAG_OVERLAPPED )
+    {
+	if( IS_READY(file->read_q) && (POLLIN & event) )
+	{
+	    async_notify(file->read_q.head, STATUS_ALERTED);
+	    return;
+	}
+	if( IS_READY(file->write_q) && (POLLIN & event) )
+	{
+	    async_notify(file->write_q.head, STATUS_ALERTED);
+	    return;
+	}
+    }
+    default_poll_event( obj, event );
+}
+
+
 static int file_get_fd( struct object *obj )
 {
     struct file *file = (struct file *)obj;
@@ -308,9 +340,45 @@
         reply->index_low   = st.st_ino;
         reply->serial      = 0; /* FIXME */
     }
+
+    if (file->flags & FILE_FLAG_OVERLAPPED)
+	return FD_TYPE_OVERLAPPED;
+
     return FD_TYPE_DEFAULT;
 }

+static struct async_queue *file_queue_async(struct object *obj, struct async *async, int type, int count)
+{
+    struct file *file = (struct file *)obj;
+    struct async_queue *q;
+
+    assert( obj->ops == &file_ops );
+
+    if ( !(file->flags & FILE_FLAG_OVERLAPPED) )
+    {
+	set_error ( STATUS_INVALID_HANDLE );
+	return NULL;
+    }
+
+    switch(type)
+    {
+    case ASYNC_TYPE_READ:
+        q = &file->read_q;
+        break;
+    case ASYNC_TYPE_WRITE:
+        q = &file->write_q;
+        break;
+    default:
+        set_error( STATUS_INVALID_PARAMETER );
+        return NULL;
+    }
+
+    if(async && !async->q)
+	async_insert(q, async);
+
+    return q;
+}
+
 static void file_destroy( struct object *obj )
 {
     struct file *file = (struct file *)obj;
@@ -325,6 +393,11 @@
         *pptr = (*pptr)->next;
         if (file->flags & FILE_FLAG_DELETE_ON_CLOSE) unlink( file->name );
         free( file->name );
+    }
+    if (file->flags & FILE_FLAG_OVERLAPPED)
+    {
+	destroy_async_queue (&file->read_q);
+	destroy_async_queue (&file->write_q);
     }
 }








More information about the wine-patches mailing list