root/ompi/mca/io/romio321/romio/adio/ad_ntfs/ad_ntfs_read.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. ADIOI_NTFS_ReadContig
   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /* 
   3  *   Copyright (C) 1997 University of Chicago. 
   4  *   See COPYRIGHT notice in top-level directory.
   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     /* If file pointer is of type ADIO_INDIVIDUAL ignore the offset
  22        and use the current location of file pointer */
  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             ADIO_Fcntl_t fcntl_struct;
  77             int error_code;
  78             ADIO_Fcntl(fd, ADIO_FCNTL_GET_FSIZE, &fcntl_struct, &error_code);
  79             printf("File size b: %d\n", fcntl_struct.fsize);
  80         }
  81         printf("ReadFile(%d bytes)\n", len);fflush(stdout);
  82         */
  83         err = ReadFile(fd->fd_sys, buf, len, &dwNumRead, pOvl);
  84         /* --BEGIN ERROR HANDLING-- */
  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                 /*printf("EOF error\n");fflush(stdout);*/
  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         /* --END ERROR HANDLING-- */
 109         err = GetOverlappedResult(fd->fd_sys, pOvl, &dwNumRead, TRUE);
 110         /* --BEGIN ERROR HANDLING-- */
 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) /* Ignore EOF errors */
 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         /* --END ERROR HANDLING-- */
 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         /* individual file pointer not updated */        
 144     }
 145     else
 146     {
 147         /* read from curr. location of ind. file pointer */
 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             ADIO_Fcntl_t fcntl_struct;
 170             int error_code;
 171             ADIO_Fcntl(fd, ADIO_FCNTL_GET_FSIZE, &fcntl_struct, &error_code);
 172             printf("File size c: %d\n", fcntl_struct.fsize);
 173         }
 174         printf("ReadFile(%d bytes)\n", len);fflush(stdout);
 175         */
 176         err = ReadFile(fd->fd_sys, buf, len, &dwNumRead, pOvl);
 177         /* --BEGIN ERROR HANDLING-- */
 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                 /*printf("EOF error\n");fflush(stdout);*/
 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         /* --END ERROR HANDLING-- */
 202         err = GetOverlappedResult(fd->fd_sys, pOvl, &dwNumRead, TRUE);
 203         /* --BEGIN ERROR HANDLING-- */
 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) /* Ignore EOF errors */
 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         /* --END ERROR HANDLING-- */
 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     /* --BEGIN ERROR HANDLING-- */
 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     /* --END ERROR HANDLING-- */
 258     *error_code = MPI_SUCCESS;
 259 }
/* [<][>][^][v][top][bottom][index][help] */