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_Close(ADIO_File fd, int *error_code) { int err; static char myname[] = "ADIOI_NTFS_Close"; err = CloseHandle(fd->fd_sys); /* --BEGIN ERROR HANDLING-- */ if (err == 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_Flush(ADIO_File fd, int *error_code) { int err; static char myname[] = "ADIOI_NTFS_Flush"; err = (fd->access_mode & ADIO_RDONLY) ? TRUE : FlushFileBuffers(fd->fd_sys); /* --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; }
int ADIOI_NTFS_ReadDone(ADIO_Request *request, ADIO_Status *status, int *error_code) { DWORD ret_val; int done = 0; static char myname[] = "ADIOI_NTFS_ReadDone"; if (*request == ADIO_REQUEST_NULL) { *error_code = MPI_SUCCESS; return 1; } if ((*request)->queued) { (*request)->nbytes = 0; ret_val = GetOverlappedResult((*request)->fd, (*request)->handle, &(*request)->nbytes, FALSE); if (!ret_val) { /* --BEGIN ERROR HANDLING-- */ ret_val = GetLastError(); if (ret_val == ERROR_IO_INCOMPLETE) { done = 0; *error_code = MPI_SUCCESS; } else { *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", ADIOI_NTFS_Strerror(ret_val)); } /* --END ERROR HANDLING-- */ } else { done = 1; *error_code = MPI_SUCCESS; } } else { done = 1; *error_code = MPI_SUCCESS; } #ifdef HAVE_STATUS_SET_BYTES if (done && ((*request)->nbytes != -1)) MPIR_Status_set_bytes(status, (*request)->datatype, (*request)->nbytes); #endif if (done) { /* if request is still queued in the system, it is also there on ADIOI_Async_list. Delete it from there. */ if ((*request)->queued) ADIOI_Del_req_from_list(request); (*request)->fd->async_count--; if ((*request)->handle) { if (!CloseHandle(((OVERLAPPED*)((*request)->handle))->hEvent)) { ret_val = GetLastError(); *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", ADIOI_NTFS_Strerror(ret_val)); } ADIOI_Free((*request)->handle); } ADIOI_Free_request((ADIOI_Req_node *) (*request)); *request = ADIO_REQUEST_NULL; } return done; }
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; }