Changeset 9654

Timestamp:

Jun 1, 2008, 11:40:58 PM (16 years ago)

Author:

Gary Byers

Message:

Fail in attempts to use overlapped I/O.
Use an OVERLAPPED structure in windows_read() and note its use in
the TCR, so that blocking reads (at least those that happen here)
can be canceled.

File:

• branches/win64/lisp-kernel/windows-calls.c (modified) (5 diffs)

branches/win64/lisp-kernel/windows-calls.c

@@ -32 +32 @@
 */
 
+#include "lisp.h"
+#include "x86-exceptions.h"
 #include <io.h>
 #include <unistd.h>
@@ -40 +42 @@
 #include <psapi.h>
 #include <dirent.h>
+#include <stdio.h>
+
+
+
+#define _dosmaperr mingw_dosmaperr
+
 
 #define WSYSCALL_RETURN(form) \
@@ -52 +60 @@
 
 
-#if 1
+
 __int64
 windows_open(wchar_t *path, int flag, int mode)
 {
-  WSYSCALL_RETURN(_wopen(path, flag, mode));
-}
-#else
-__int64
-windows_open(char *path, int flag, int mode)
-{
-  WSYSCALL_RETURN(_open(path, flag, mode));
-}
+  int fd;
+  HANDLE hfile;
+  DWORD dwDesiredAccess = 0;
+  DWORD dwShareMode = 0;
+  DWORD dwCreationDistribution = 0;
+  DWORD dwFlagsAndAttributes = 0;
+  SECURITY_ATTRIBUTES sa = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
+
+  if ((flag & S_IREAD) == S_IREAD) {
+    dwShareMode = FILE_SHARE_READ;
+  } else {
+    if ((flag & S_IWRITE) == S_IWRITE) {
+      dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
+    }
+  }
+
+  if ((flag & _O_WRONLY) == _O_WRONLY) {
+    dwDesiredAccess |= GENERIC_WRITE | FILE_WRITE_DATA |
+      FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES;
+  } else if ((flag & _O_RDWR) == _O_RDWR) {
+    dwDesiredAccess |= GENERIC_WRITE|GENERIC_READ | FILE_READ_DATA |
+      FILE_WRITE_DATA | FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES;
+  } else {
+    dwDesiredAccess |= GENERIC_READ | FILE_READ_DATA | FILE_READ_ATTRIBUTES |
+      FILE_WRITE_ATTRIBUTES;
+  }
+    
+  if ((flag & S_IREAD) == S_IREAD) {
+    dwShareMode |= FILE_SHARE_READ;
+  }
+  if ((flag & S_IWRITE) == S_IWRITE) {
+    dwShareMode |= FILE_SHARE_WRITE;
+  }
+
+  if ((flag & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL)) {
+    dwCreationDistribution |= CREATE_NEW;
+  } else if ((flag &  O_TRUNC) == O_TRUNC) {
+    if ((flag &  O_CREAT) ==  O_CREAT) {
+      dwCreationDistribution |= CREATE_ALWAYS;
+    } else if ((flag & O_RDONLY) != O_RDONLY) {
+      dwCreationDistribution |= TRUNCATE_EXISTING;
+    }
+  } else if ((flag & _O_APPEND) == _O_APPEND) {
+    dwCreationDistribution |= OPEN_EXISTING;
+  } else if ((flag &  _O_CREAT) == _O_CREAT) {
+    dwCreationDistribution |= OPEN_ALWAYS;
+  } else {
+    dwCreationDistribution |= OPEN_EXISTING;
+  }
+  if ((flag &  _O_RANDOM) == _O_RANDOM) {
+    dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS;
+  }
+  if ((flag &  _O_SEQUENTIAL) == _O_SEQUENTIAL) {
+    dwFlagsAndAttributes |= FILE_FLAG_SEQUENTIAL_SCAN;
+  }
+
+  if ((flag &  _O_TEMPORARY) == _O_TEMPORARY) {
+    dwFlagsAndAttributes |= FILE_FLAG_DELETE_ON_CLOSE;
+  }
+
+  if ((flag &  _O_SHORT_LIVED) == _O_SHORT_LIVED) {
+    dwFlagsAndAttributes |= FILE_FLAG_DELETE_ON_CLOSE;
+  }
+
+  if (flag & _O_NOINHERIT) {
+    sa.bInheritHandle = FALSE;
+  }
+
+#if 0
+  dwFlagsAndAttributes |= FILE_FLAG_OVERLAPPED;
 #endif
+    
+
+  hfile = CreateFileW(path,
+                      dwDesiredAccess,
+                      dwShareMode,
+                      &sa,
+                      dwCreationDistribution,
+                      dwFlagsAndAttributes,
+                      NULL);
+  if (hfile == ((HANDLE)-1)) {
+    _dosmaperr(GetLastError());
+    return -errno;
+  }
+  fd = _open_osfhandle((intptr_t)hfile, flag);
+
+  if (fd < 0) {
+    CloseHandle(hfile);
+    return -fd;
+  }
+  return fd;
+}
+
 __int64
 windows_close(int fd)
 {
-  WSYSCALL_RETURN(_close(fd));
+  WSYSCALL_RETURN(close(fd));
 }
 
@@ -74 +166 @@
 windows_read(int fd, void *buf, unsigned int count)
 {
-  WSYSCALL_RETURN(_read(fd, buf, count));
+  HANDLE hfile;
+  OVERLAPPED overlapped;
+  DWORD err, nread;
+  pending_io pending;
+  TCR *tcr;
+  extern TCR *get_tcr(int);
+
+  hfile = (HANDLE) _get_osfhandle(fd);
+
+  if (hfile == ((HANDLE)-1)) {
+    return -EBADF;
+  }
+  
+  memset(&overlapped,0,sizeof(overlapped));
+
+  if (GetFileType(hfile) == FILE_TYPE_DISK) {
+    overlapped.Offset = SetFilePointer(hfile, 0, &(overlapped.OffsetHigh), FILE_CURRENT);
+  }
+
+  tcr = (TCR *)get_tcr(1);
+  pending.h = hfile;
+  pending.o = &overlapped;
+  tcr->foreign_exception_status = (signed_natural)&pending;
+
+  if (ReadFile(hfile, buf, count, &nread, &overlapped)) {
+    tcr->foreign_exception_status = 0;
+    return nread;
+  }
+  err = GetLastError();
+
+  if (err == ERROR_HANDLE_EOF) {
+    tcr->foreign_exception_status = 0;
+    return 0;
+  }
+
+  if (err != ERROR_IO_PENDING) {
+    _dosmaperr(err);
+    tcr->foreign_exception_status = 0;
+    return -errno;
+  }
+  
+  /* We block here */
+  if (GetOverlappedResult(hfile, &overlapped, &nread, TRUE)) {
+    tcr->foreign_exception_status = 0;
+    return nread;
+  }
+  err = GetLastError();
+  tcr->foreign_exception_status = 0;
+
+  switch (err) {
+  case ERROR_HANDLE_EOF: 
+    return 0;
+  case ERROR_OPERATION_ABORTED: 
+    return -EINTR;
+  default:
+    _dosmaperr(err);
+    return -errno;
+  }
 }
 
@@ -211 +360 @@
 
 void
+init_windows_io()
+{
+#if 0
+  int fd;
+  HANDLE hfile0, hfile1;
+
+  hfile0 = (HANDLE) _get_osfhandle(0);
+  hfile1 = ReOpenFile(hfile0,GENERIC_READ,FILE_SHARE_READ,FILE_FLAG_OVERLAPPED);
+  if (hfile1 != ((HANDLE)-1)) {
+    fd = _open_osfhandle(hfile1,O_RDONLY);
+    dup2(fd,0);
+    _close(fd);
+    SetStdHandle(STD_INPUT_HANDLE,hfile1);
+    CloseHandle(hfile0);
+  } else {
+    wperror("ReOpenFile");
+  }
+
+  hfile0 = (HANDLE) _get_osfhandle(1);
+  hfile1 = ReOpenFile(hfile0,GENERIC_WRITE,FILE_SHARE_WRITE,FILE_FLAG_OVERLAPPED);
+  if (hfile1 != ((HANDLE)-1)) {
+    fd = _open_osfhandle(hfile1,O_WRONLY);
+    dup2(fd,1);
+    _close(fd);
+    SetStdHandle(STD_OUTPUT_HANDLE,hfile1);
+    CloseHandle(hfile0);
+  }
+
+  hfile0 = (HANDLE) _get_osfhandle(2);
+  hfile1 = ReOpenFile(hfile0,GENERIC_WRITE,FILE_SHARE_WRITE,FILE_FLAG_OVERLAPPED);
+  if (hfile1 != ((HANDLE)-1)) {
+    fd = _open_osfhandle(hfile1,O_WRONLY);
+    dup2(fd,2);
+    _close(fd);
+    SetStdHandle(STD_ERROR_HANDLE,hfile1);
+    CloseHandle(hfile0);
+  }
+#endif  
+}
+
+void
 init_winsock()
 {