void ADIOI_NTFS_WriteContig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int *error_code)
{
//int rank;
DWORD dwTemp;
DWORD dwNumWritten = 0;
int err=-1, datatype_size, len;
#ifndef PRINT_ERR_MSG
static char myname[] = "ADIOI_NTFS_WRITECONTIG";
#endif
MPI_Type_size(datatype, &datatype_size);
len = datatype_size * count;
if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
if (fd->fp_sys_posn != offset)
{
dwTemp = DWORDHIGH(offset);
SetFilePointer(fd->fd_sys, DWORDLOW(offset), &dwTemp, FILE_BEGIN);
}
err = WriteFile(fd->fd_sys, buf, len, &dwNumWritten, NULL);
//MPI_Comm_rank(MPI_COMM_WORLD, &rank);
//printf("[%d]W(%d,%d)\n", rank, DWORDLOW(offset), dwNumWritten);
fd->fp_sys_posn = offset + dwNumWritten;
/* individual file pointer not updated */
}
else { /* write from curr. location of ind. file pointer */
if (fd->fp_sys_posn != fd->fp_ind)
{
dwTemp = DWORDHIGH(fd->fp_ind);
SetFilePointer(fd->fd_sys, DWORDLOW(fd->fp_ind), &dwTemp, FILE_BEGIN);
}
err = WriteFile(fd->fd_sys, buf, len, &dwNumWritten, NULL);
//MPI_Comm_rank(MPI_COMM_WORLD, &rank);
//printf("[%d]w(%d,%d)\n", rank, DWORDLOW(offset), dwNumWritten);
fd->fp_ind = fd->fp_ind + dwNumWritten;
fd->fp_sys_posn = fd->fp_ind;
}
#ifdef HAVE_STATUS_SET_BYTES
if (err != FALSE) MPIR_Status_set_bytes(status, datatype, dwNumWritten);
#endif
#ifdef PRINT_ERR_MSG
*error_code = (err == FALSE) ? MPI_ERR_UNKNOWN : MPI_SUCCESS;
#else
if (err == FALSE) {
*error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
myname, "I/O Error", "%s", strerror(errno));
ADIOI_Error(fd, *error_code, myname);
}
else *error_code = MPI_SUCCESS;
#endif
}
void ADIOI_NTFS_ReadContig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status,
int *error_code)
{
DWORD dwTemp;
DWORD dwNumRead = 0;
int err=-1, datatype_size, len;
static char myname[] = "ADIOI_NTFS_READCONTIG";
MPI_Type_size(datatype, &datatype_size);
len = datatype_size * count;
if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
if (fd->fp_sys_posn != offset)
{
dwTemp = DWORDHIGH(offset);
SetFilePointer(fd->fd_sys, DWORDLOW(offset), &dwTemp, FILE_BEGIN);
}
err = ReadFile(fd->fd_sys, buf, len, &dwNumRead, NULL);
fd->fp_sys_posn = offset + (ADIO_Offset)dwNumRead;
/* individual file pointer not updated */
}
else { /* read from curr. location of ind. file pointer */
if (fd->fp_sys_posn != fd->fp_ind)
{
dwTemp = DWORDHIGH(fd->fp_ind);
SetFilePointer(fd->fd_sys, DWORDLOW(fd->fp_ind), &dwTemp,
FILE_BEGIN);
}
err = ReadFile(fd->fd_sys, buf, len, &dwNumRead, NULL);
fd->fp_ind = fd->fp_ind + (ADIO_Offset)dwNumRead;
fd->fp_sys_posn = fd->fp_ind;
}
#ifdef HAVE_STATUS_SET_BYTES
if (err != FALSE) MPIR_Status_set_bytes(status, datatype, dwNumRead);
#endif
if (err == FALSE) {
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", strerror(errno));
return;
}
else *error_code = MPI_SUCCESS;
}
int ADIOI_NTFS_aio(ADIO_File fd, void *buf, int len, ADIO_Offset offset,
int wr, void *handle)
{
DWORD dwNumWritten=0, dwNumRead=0;
BOOL ret_val = FALSE;
FDTYPE fd_sys;
OVERLAPPED *pOvl;
fd_sys = fd->fd_sys;
pOvl = (OVERLAPPED *) ADIOI_Calloc(sizeof(OVERLAPPED), 1);
pOvl->hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
pOvl->Offset = DWORDLOW(offset);
pOvl->OffsetHigh = DWORDHIGH(offset);
if (wr)
{
ret_val = WriteFile(fd_sys, buf, len, &dwNumWritten, pOvl);
//ret_val = WriteFile(fd_sys, buf, len, &dwNumWritten, NULL);
//if (ret_val && dwNumWritten) printf("written immediately: %d\n", dwNumWritten);
}
else
{
ret_val = ReadFile(fd_sys, buf, len, &dwNumRead, pOvl);
//ret_val = ReadFile(fd_sys, buf, len, &dwNumRead, NULL);
}
if (ret_val == FALSE)
{
errno = GetLastError();
if (errno != ERROR_IO_PENDING)
{
if (wr)
FPRINTF(stderr, "WriteFile error: len %d, dwNumWritten %d\n", len, dwNumWritten);
else
FPRINTF(stderr, "ReadFile error: len %d, dwNumRead %d\n", len, dwNumRead);
FPRINTF(stderr, "Unknown errno %d in ADIOI_NTFS_aio\n", errno);
MPI_Abort(MPI_COMM_WORLD, 1);
}
ret_val = TRUE;
}
*((OVERLAPPED **) handle) = pOvl;
return ret_val;
}
void ADIOI_NTFS_Resize(ADIO_File fd, ADIO_Offset size, int *error_code)
{
LONG dwTemp;
DWORD err;
BOOL result;
static char myname[] = "ADIOI_NTFS_Resize";
dwTemp = DWORDHIGH(size);
err = SetFilePointer(fd->fd_sys, DWORDLOW(size), &dwTemp, FILE_BEGIN);
/* --BEGIN ERROR HANDLING-- */
if (err == INVALID_SET_FILE_POINTER)
{
err = GetLastError();
if (err != NO_ERROR)
{
char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", errMsg);
return;
}
}
/*printf("setting file length to %d\n", size);fflush(stdout);*/
/* --END ERROR HANDLING-- */
result = SetEndOfFile(fd->fd_sys);
/* --BEGIN ERROR HANDLING-- */
if (result == FALSE)
{
char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
err = GetLastError();
ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", errMsg);
return;
}
/* --END ERROR HANDLING-- */
*error_code = MPI_SUCCESS;
}
void ADIOI_NTFS_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct, int *error_code)
{
DWORD err;
LONG dwTemp;
static char myname[] = "ADIOI_NTFS_FCNTL";
switch(flag)
{
case ADIO_FCNTL_GET_FSIZE:
fcntl_struct->fsize = SetFilePointer(fd->fd_sys, 0, 0, FILE_END);
if (fd->fp_sys_posn != -1)
{
dwTemp = DWORDHIGH(fd->fp_sys_posn);
if (SetFilePointer(fd->fd_sys, DWORDLOW(fd->fp_sys_posn), &dwTemp, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
err = GetLastError();
ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
if (err != NO_ERROR)
{
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s", errMsg);
return;
}
}
}
/* --BEGIN ERROR HANDLING-- */
if (fcntl_struct->fsize == INVALID_SET_FILE_POINTER)
{
char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
dwTemp = GetLastError();
ADIOI_NTFS_Strerror(dwTemp, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myname,
__LINE__, MPI_ERR_IO, "**io",
"**io %s", errMsg);
return;
}
/* --END ERROR HANDLING-- */
*error_code = MPI_SUCCESS;
break;
case ADIO_FCNTL_SET_DISKSPACE:
ADIOI_GEN_Prealloc(fd, fcntl_struct->diskspace, error_code);
break;
case ADIO_FCNTL_SET_ATOMICITY:
fd->atomicity = (fcntl_struct->atomicity == 0) ? 0 : 1;
*error_code = MPI_SUCCESS;
/*
fd->atomicity = 0;
*error_code = MPI_ERR_UNSUPPORTED_OPERATION;
*/
break;
default:
/* --BEGIN ERROR HANDLING-- */
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__,
MPI_ERR_ARG,
"**flag", "**flag %d", flag);
return;
/* --END ERROR HANDLING-- */
}
}
/* This function is for implementation convenience. It is not user-visible.
* If wr==1 write, wr==0 read.
*
* Returns MPI_SUCCESS on success, mpi_errno on failure.
*/
int ADIOI_NTFS_aio(ADIO_File fd, void *buf, int len, ADIO_Offset offset,
int wr, MPI_Request *request)
{
static char myname[] = "ADIOI_NTFS_aio";
ADIOI_AIO_Request *aio_req;
static DWORD dwNumWritten, dwNumRead;
BOOL ret_val = FALSE;
FDTYPE fd_sys;
int mpi_errno = MPI_SUCCESS;
DWORD err;
fd_sys = fd->fd_sys;
aio_req = (ADIOI_AIO_Request *)ADIOI_Calloc(sizeof(ADIOI_AIO_Request), 1);
if (aio_req == NULL)
{
mpi_errno = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**nomem", "**nomem %s", "AIO_REQ");
return mpi_errno;
}
aio_req->lpOvl = (LPOVERLAPPED ) ADIOI_Calloc(sizeof(OVERLAPPED), 1);
if (aio_req->lpOvl == NULL)
{
mpi_errno = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**nomem", "**nomem %s", "OVERLAPPED");
ADIOI_Free(aio_req);
return mpi_errno;
}
aio_req->lpOvl->hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (aio_req->lpOvl->hEvent == NULL)
{
char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
err = GetLastError();
ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
mpi_errno = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s", errMsg);
ADIOI_Free(aio_req->lpOvl);
ADIOI_Free(aio_req);
return mpi_errno;
}
aio_req->lpOvl->Offset = DWORDLOW(offset);
aio_req->lpOvl->OffsetHigh = DWORDHIGH(offset);
aio_req->fd = fd_sys;
/* XXX: initiate async I/O */
if (wr)
{
ret_val = WriteFile(fd_sys, buf, len, &dwNumWritten, aio_req->lpOvl);
}
else
{
ret_val = ReadFile(fd_sys, buf, len, &dwNumRead, aio_req->lpOvl);
}
/* --BEGIN ERROR HANDLING-- */
if (ret_val == FALSE)
{
mpi_errno = GetLastError();
if (mpi_errno != ERROR_IO_PENDING)
{
char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
ADIOI_NTFS_Strerror(mpi_errno, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
mpi_errno = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", errMsg);
return mpi_errno;
}
mpi_errno = MPI_SUCCESS;
}
/* --END ERROR HANDLING-- */
/* XXX: set up generalized request class and request */
if (ADIOI_NTFS_greq_class == 0) {
mpi_errno = MPIX_Grequest_class_create(ADIOI_NTFS_aio_query_fn,
ADIOI_NTFS_aio_free_fn, MPIU_Greq_cancel_fn,
ADIOI_NTFS_aio_poll_fn, ADIOI_NTFS_aio_wait_fn,
&ADIOI_NTFS_greq_class);
if(mpi_errno != MPI_SUCCESS){
/* FIXME: Pass appropriate error code to user */
}
}
mpi_errno = MPIX_Grequest_class_allocate(ADIOI_NTFS_greq_class, aio_req, request);
if(mpi_errno != MPI_SUCCESS){
/* FIXME: Pass appropriate error code to user */
}
memcpy(&(aio_req->req), request, sizeof(MPI_Request));
return mpi_errno;
}
void ADIOI_NTFS_WriteContig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status,
int *error_code)
{
static char myname[] = "ADIOI_NTFS_WriteContig";
LONG dwTemp;
DWORD dwNumWritten = 0;
int err=-1, datatype_size, len;
OVERLAPPED *pOvl;
MPI_Type_size(datatype, &datatype_size);
len = datatype_size * count;
pOvl = (OVERLAPPED *) ADIOI_Calloc(sizeof(OVERLAPPED), 1);
if (pOvl == NULL)
{
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**nomem", "**nomem %s", "OVERLAPPED");
return;
}
pOvl->hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
if (pOvl->hEvent == NULL)
{
err = GetLastError();
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s", ADIOI_NTFS_Strerror(err));
ADIOI_Free(pOvl);
return;
}
pOvl->Offset = DWORDLOW(offset);
pOvl->OffsetHigh = DWORDHIGH(offset);
if (file_ptr_type == ADIO_EXPLICIT_OFFSET)
{
if (fd->fp_sys_posn != offset)
{
dwTemp = DWORDHIGH(offset);
if (SetFilePointer(fd->fd_sys, DWORDLOW(offset), &dwTemp, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
err = GetLastError();
if (err != NO_ERROR)
{
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
}
}
/*printf("WriteFile(%d bytes)\n", len);fflush(stdout);*/
err = WriteFile(fd->fd_sys, buf, len, &dwNumWritten, pOvl);
/* --BEGIN ERROR HANDLING-- */
if (err == FALSE)
{
err = GetLastError();
if (err != ERROR_IO_PENDING)
{
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
}
/* --END ERROR HANDLING-- */
err = GetOverlappedResult(fd->fd_sys, pOvl, &dwNumWritten, TRUE);
/* --BEGIN ERROR HANDLING-- */
if (err == FALSE)
{
err = GetLastError();
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myname,
__LINE__, MPI_ERR_IO, "**io",
"**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
/* --END ERROR HANDLING-- */
if (!CloseHandle(pOvl->hEvent))
{
err = GetLastError();
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
ADIOI_Free(pOvl);
fd->fp_sys_posn = offset + dwNumWritten;
/* individual file pointer not updated */
}
else
{
/* write from curr. location of ind. file pointer */
if (fd->fp_sys_posn != fd->fp_ind)
{
dwTemp = DWORDHIGH(fd->fp_ind);
if (SetFilePointer(fd->fd_sys, DWORDLOW(fd->fp_ind), &dwTemp, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
err = GetLastError();
if (err != NO_ERROR)
{
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
}
}
/*printf("WriteFile(%d bytes)\n", len);fflush(stdout);*/
err = WriteFile(fd->fd_sys, buf, len, &dwNumWritten, pOvl);
/* --BEGIN ERROR HANDLING-- */
if (err == FALSE)
{
err = GetLastError();
if (err != ERROR_IO_PENDING)
{
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
}
/* --END ERROR HANDLING-- */
err = GetOverlappedResult(fd->fd_sys, pOvl, &dwNumWritten, TRUE);
/* --BEGIN ERROR HANDLING-- */
if (err == FALSE)
{
err = GetLastError();
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myname,
__LINE__, MPI_ERR_IO, "**io",
"**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
/* --END ERROR HANDLING-- */
if (!CloseHandle(pOvl->hEvent))
{
err = GetLastError();
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s", ADIOI_NTFS_Strerror(err));
ADIOI_Free(pOvl);
return;
}
ADIOI_Free(pOvl);
fd->fp_ind = fd->fp_ind + dwNumWritten;
fd->fp_sys_posn = fd->fp_ind;
}
#ifdef HAVE_STATUS_SET_BYTES
if (err != FALSE)
{
MPIR_Status_set_bytes(status, datatype, dwNumWritten);
}
#endif
/* --BEGIN ERROR HANDLING-- */
if (err == FALSE)
{
err = GetLastError();
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", ADIOI_NTFS_Strerror(err));
return;
}
/* --END ERROR HANDLING-- */
*error_code = MPI_SUCCESS;
}
void ADIOI_NTFS_ReadContig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status,
int *error_code)
{
LONG dwTemp;
DWORD dwNumRead = 0;
int err=-1, datatype_size, len;
static char myname[] = "ADIOI_NTFS_ReadContig";
OVERLAPPED *pOvl;
MPI_Type_size(datatype, &datatype_size);
len = datatype_size * count;
pOvl = (OVERLAPPED *) ADIOI_Calloc(sizeof(OVERLAPPED), 1);
if (pOvl == NULL)
{
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**nomem", "**nomem %s", "OVERLAPPED");
return;
}
pOvl->hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
if (pOvl->hEvent == NULL)
{
err = GetLastError();
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s", ADIOI_NTFS_Strerror(err));
ADIOI_Free(pOvl);
return;
}
pOvl->Offset = DWORDLOW(offset);
pOvl->OffsetHigh = DWORDHIGH(offset);
if (file_ptr_type == ADIO_EXPLICIT_OFFSET)
{
if (fd->fp_sys_posn != offset)
{
dwTemp = DWORDHIGH(offset);
if (SetFilePointer(fd->fd_sys, DWORDLOW(offset), &dwTemp, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
err = GetLastError();
if (err != NO_ERROR)
{
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
}
}
/*
{
ADIO_Fcntl_t fcntl_struct;
int error_code;
ADIO_Fcntl(fd, ADIO_FCNTL_GET_FSIZE, &fcntl_struct, &error_code);
printf("File size b: %d\n", fcntl_struct.fsize);
}
printf("ReadFile(%d bytes)\n", len);fflush(stdout);
*/
err = ReadFile(fd->fd_sys, buf, len, &dwNumRead, pOvl);
/* --BEGIN ERROR HANDLING-- */
if (err == FALSE)
{
err = GetLastError();
switch (err)
{
case ERROR_IO_PENDING:
break;
case ERROR_HANDLE_EOF:
/*printf("EOF error\n");fflush(stdout);*/
SetEvent(pOvl->hEvent);
break;
default:
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
}
/* --END ERROR HANDLING-- */
err = GetOverlappedResult(fd->fd_sys, pOvl, &dwNumRead, TRUE);
/* --BEGIN ERROR HANDLING-- */
if (err == FALSE)
{
err = GetLastError();
if (err != ERROR_HANDLE_EOF) /* Ignore EOF errors */
{
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myname,
__LINE__, MPI_ERR_IO, "**io",
"**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
}
/* --END ERROR HANDLING-- */
if (!CloseHandle(pOvl->hEvent))
{
err = GetLastError();
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
ADIOI_Free(pOvl);
fd->fp_sys_posn = offset + (ADIO_Offset)dwNumRead;
/* individual file pointer not updated */
}
else
{
/* read from curr. location of ind. file pointer */
if (fd->fp_sys_posn != fd->fp_ind)
{
dwTemp = DWORDHIGH(fd->fp_ind);
if (SetFilePointer(fd->fd_sys, DWORDLOW(fd->fp_ind), &dwTemp, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
err = GetLastError();
if (err != NO_ERROR)
{
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
}
}
/*
{
ADIO_Fcntl_t fcntl_struct;
int error_code;
ADIO_Fcntl(fd, ADIO_FCNTL_GET_FSIZE, &fcntl_struct, &error_code);
printf("File size c: %d\n", fcntl_struct.fsize);
}
printf("ReadFile(%d bytes)\n", len);fflush(stdout);
*/
err = ReadFile(fd->fd_sys, buf, len, &dwNumRead, pOvl);
/* --BEGIN ERROR HANDLING-- */
if (err == FALSE)
{
err = GetLastError();
switch (err)
{
case ERROR_IO_PENDING:
break;
case ERROR_HANDLE_EOF:
/*printf("EOF error\n");fflush(stdout);*/
SetEvent(pOvl->hEvent);
break;
default:
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
}
/* --END ERROR HANDLING-- */
err = GetOverlappedResult(fd->fd_sys, pOvl, &dwNumRead, TRUE);
/* --BEGIN ERROR HANDLING-- */
if (err == FALSE)
{
err = GetLastError();
if (err != ERROR_HANDLE_EOF) /* Ignore EOF errors */
{
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myname,
__LINE__, MPI_ERR_IO, "**io",
"**io %s", ADIOI_NTFS_Strerror(err));
CloseHandle(pOvl->hEvent);
ADIOI_Free(pOvl);
return;
}
}
/* --END ERROR HANDLING-- */
if (!CloseHandle(pOvl->hEvent))
{
err = GetLastError();
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s", ADIOI_NTFS_Strerror(err));
ADIOI_Free(pOvl);
return;
}
ADIOI_Free(pOvl);
fd->fp_ind = fd->fp_ind + (ADIO_Offset)dwNumRead;
fd->fp_sys_posn = fd->fp_ind;
}
#ifdef HAVE_STATUS_SET_BYTES
if (err != FALSE)
{
MPIR_Status_set_bytes(status, datatype, dwNumRead);
}
#endif
/* --BEGIN ERROR HANDLING-- */
if (err == FALSE)
{
err = GetLastError();
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", ADIOI_NTFS_Strerror(err));
return;
}
/* --END ERROR HANDLING-- */
*error_code = MPI_SUCCESS;
}
