This source file includes following definitions.
- ADIOI_NTFS_ReadContig
   1 
   2 
   3 
   4 
   5 
   6 
   7 #include "ad_ntfs.h"
   8 
   9 void ADIOI_NTFS_ReadContig(ADIO_File fd, void *buf, int count, 
  10                            MPI_Datatype datatype, int file_ptr_type,
  11                            ADIO_Offset offset, ADIO_Status *status,
  12                            int *error_code)
  13 {
  14     LONG dwTemp;
  15     DWORD dwNumRead = 0;
  16     int err=-1;
  17     MPI_Count datatype_size, len;
  18     static char myname[] = "ADIOI_NTFS_ReadContig";
  19     OVERLAPPED *pOvl;
  20 
  21     
  22 
  23     if(file_ptr_type == ADIO_INDIVIDUAL){
  24         offset = fd->fp_ind;
  25     }
  26 
  27     MPI_Type_size_x(datatype, &datatype_size);
  28     len = datatype_size * count;
  29 
  30     pOvl = (OVERLAPPED *) ADIOI_Calloc(sizeof(OVERLAPPED), 1);
  31     if (pOvl == NULL)
  32     {
  33         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  34             myname, __LINE__, MPI_ERR_IO,
  35             "**nomem", "**nomem %s", "OVERLAPPED");
  36         return;
  37     }
  38     pOvl->hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
  39     if (pOvl->hEvent == NULL)
  40     {
  41     char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
  42         err = GetLastError();
  43     ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
  44         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  45             myname, __LINE__, MPI_ERR_IO,
  46             "**io", "**io %s", errMsg);
  47         ADIOI_Free(pOvl);
  48         return;
  49     }
  50     pOvl->Offset = DWORDLOW(offset);
  51     pOvl->OffsetHigh = DWORDHIGH(offset);
  52 
  53     if (file_ptr_type == ADIO_EXPLICIT_OFFSET)
  54     {
  55         if (fd->fp_sys_posn != offset)
  56         {
  57             dwTemp = DWORDHIGH(offset);
  58             if (SetFilePointer(fd->fd_sys, DWORDLOW(offset), &dwTemp, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
  59             {
  60         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
  61                 err = GetLastError();
  62         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
  63                 if (err != NO_ERROR)
  64                 {
  65                     *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  66                         myname, __LINE__, MPI_ERR_IO,
  67                         "**io", "**io %s", errMsg);
  68                     CloseHandle(pOvl->hEvent);
  69                     ADIOI_Free(pOvl);
  70                     return;
  71                 }
  72             }
  73         }
  74         
  75 
  76 
  77 
  78 
  79 
  80 
  81 
  82 
  83         err = ReadFile(fd->fd_sys, buf, len, &dwNumRead, pOvl);
  84         
  85         if (err == FALSE)
  86         {
  87         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
  88             err = GetLastError();
  89         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
  90             switch (err)
  91             {
  92             case ERROR_IO_PENDING:
  93                 break;
  94             case ERROR_HANDLE_EOF:
  95                 
  96                 SetEvent(pOvl->hEvent);
  97                 break;
  98             default:
  99                 *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 100                     myname, __LINE__, MPI_ERR_IO,
 101                     "**io",
 102                     "**io %s", errMsg);
 103                 CloseHandle(pOvl->hEvent);
 104                 ADIOI_Free(pOvl);
 105                 return;
 106             }
 107         }
 108         
 109         err = GetOverlappedResult(fd->fd_sys, pOvl, &dwNumRead, TRUE);
 110         
 111         if (err == FALSE)
 112         {
 113         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 114             err = GetLastError();
 115         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 116             if (err != ERROR_HANDLE_EOF) 
 117             {
 118                 *error_code = MPIO_Err_create_code(MPI_SUCCESS,
 119                     MPIR_ERR_RECOVERABLE, myname,
 120                     __LINE__, MPI_ERR_IO, "**io",
 121                     "**io %s", errMsg);
 122                 CloseHandle(pOvl->hEvent);
 123                 ADIOI_Free(pOvl);
 124                 return;
 125             }
 126         }
 127         
 128         if (!CloseHandle(pOvl->hEvent))
 129         {
 130         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 131             err = GetLastError();
 132         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 133             *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 134                 myname, __LINE__, MPI_ERR_IO,
 135                 "**io", "**io %s", errMsg);
 136             CloseHandle(pOvl->hEvent);
 137             ADIOI_Free(pOvl);
 138             return;
 139         }
 140         ADIOI_Free(pOvl);
 141 
 142         fd->fp_sys_posn = offset + (ADIO_Offset)dwNumRead;
 143                 
 144     }
 145     else
 146     {
 147         
 148         if (fd->fp_sys_posn != fd->fp_ind)
 149         {
 150             dwTemp = DWORDHIGH(fd->fp_ind);
 151             if (SetFilePointer(fd->fd_sys, DWORDLOW(fd->fp_ind), &dwTemp, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
 152             {
 153         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 154                 err = GetLastError();
 155         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 156                 if (err != NO_ERROR)
 157                 {
 158                     *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 159                         myname, __LINE__, MPI_ERR_IO,
 160                         "**io", "**io %s", errMsg);
 161                     CloseHandle(pOvl->hEvent);
 162                     ADIOI_Free(pOvl);
 163                     return;
 164                 }
 165             }
 166         }
 167         
 168 
 169 
 170 
 171 
 172 
 173 
 174 
 175 
 176         err = ReadFile(fd->fd_sys, buf, len, &dwNumRead, pOvl);
 177         
 178         if (err == FALSE)
 179         {
 180         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 181             err = GetLastError();
 182         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 183             switch (err)
 184             {
 185             case ERROR_IO_PENDING:
 186                 break;
 187             case ERROR_HANDLE_EOF:
 188                 
 189                 SetEvent(pOvl->hEvent);
 190                 break;
 191             default:
 192                 *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 193                     myname, __LINE__, MPI_ERR_IO,
 194                     "**io",
 195                     "**io %s", errMsg);
 196                 CloseHandle(pOvl->hEvent);
 197                 ADIOI_Free(pOvl);
 198                 return;
 199             }
 200         }
 201         
 202         err = GetOverlappedResult(fd->fd_sys, pOvl, &dwNumRead, TRUE);
 203         
 204         if (err == FALSE)
 205         {
 206         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 207             err = GetLastError();
 208         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 209             if (err != ERROR_HANDLE_EOF) 
 210             {
 211                 *error_code = MPIO_Err_create_code(MPI_SUCCESS,
 212                     MPIR_ERR_RECOVERABLE, myname,
 213                     __LINE__, MPI_ERR_IO, "**io",
 214                     "**io %s", errMsg);
 215                 CloseHandle(pOvl->hEvent);
 216                 ADIOI_Free(pOvl);
 217                 return;
 218             }
 219         }
 220         
 221         if (!CloseHandle(pOvl->hEvent))
 222         {
 223         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 224             err = GetLastError();
 225         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 226             *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 227                 myname, __LINE__, MPI_ERR_IO,
 228                 "**io", "**io %s", errMsg);
 229             ADIOI_Free(pOvl);
 230             return;
 231         }
 232         ADIOI_Free(pOvl);
 233 
 234         fd->fp_ind = fd->fp_ind + (ADIO_Offset)dwNumRead; 
 235         fd->fp_sys_posn = fd->fp_ind;
 236     }         
 237 
 238 #ifdef HAVE_STATUS_SET_BYTES
 239     if (err != FALSE)
 240     {
 241         MPIR_Status_set_bytes(status, datatype, dwNumRead);
 242     }
 243 #endif
 244 
 245     
 246     if (err == FALSE)
 247     {
 248     char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 249         err = GetLastError();
 250     ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 251         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 252                                            myname, __LINE__, MPI_ERR_IO,
 253                                            "**io",
 254                                            "**io %s", errMsg);
 255         return;
 256     }
 257     
 258     *error_code = MPI_SUCCESS;
 259 }