src/libs/ck-libs/ampi/romio/adio/ad_ntfs/ad_ntfs_write.c

   1 /* -*- Mode: C; c-basic-offset:4 ; -*- */
   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_WriteContig(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     static char myname[] = "ADIOI_NTFS_WriteContig";
  15     LONG dwTemp;
  16     DWORD dwNumWritten = 0;
  17     int err=-1, datatype_size, len;
  18     OVERLAPPED *pOvl;
  19
  20     /* If file pointer type in ADIO_INDIVIDUAL then offset should be
  21         ignored and the current location of file pointer should be used */
  22     if(file_ptr_type == ADIO_INDIVIDUAL){
  23         offset = fd->fp_ind;
  24     }
  25
  26     MPI_Type_size(datatype, &datatype_size);
  27     len = datatype_size * count;
  28
  29     pOvl = (OVERLAPPED *) ADIOI_Calloc(sizeof(OVERLAPPED), 1);
  30     if (pOvl == NULL)
  31     {
  32         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  33             myname, __LINE__, MPI_ERR_IO,
  34             "**nomem", "**nomem %s", "OVERLAPPED");
  35         return;
  36     }
  37     pOvl->hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
  38     if (pOvl->hEvent == NULL)
  39     {
  40     char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
  41         err = GetLastError();
  42     ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
  43         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  44             myname, __LINE__, MPI_ERR_IO,
  45             "**io", "**io %s", errMsg);
  46         ADIOI_Free(pOvl);
  47         return;
  48     }
  49     pOvl->Offset = DWORDLOW(offset);
  50     pOvl->OffsetHigh = DWORDHIGH(offset);
  51
  52     if (file_ptr_type == ADIO_EXPLICIT_OFFSET)
  53     {
  54         if (fd->fp_sys_posn != offset)
  55         {
  56             dwTemp = DWORDHIGH(offset);
  57             if (SetFilePointer(fd->fd_sys, DWORDLOW(offset), &dwTemp, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
  58             {
  59                 err = GetLastError();
  60                 if (err != NO_ERROR)
  61                 {
  62             char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
  63             ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
  64                     *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  65                         myname, __LINE__, MPI_ERR_IO,
  66                         "**io", "**io %s", errMsg);
  67                     CloseHandle(pOvl->hEvent);
  68                     ADIOI_Free(pOvl);
  69                     return;
  70                 }
  71             }
  72         }
  73         /*printf("WriteFile(%d bytes)\n", len);fflush(stdout);*/
  74         err = WriteFile(fd->fd_sys, buf, len, &dwNumWritten, pOvl);
  75         /* --BEGIN ERROR HANDLING-- */
  76         if (err == FALSE)
  77         {
  78             err = GetLastError();
  79             if (err != ERROR_IO_PENDING)
  80             {
  81         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
  82         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
  83                 *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  84                     myname, __LINE__, MPI_ERR_IO,
  85                     "**io",
  86                     "**io %s", errMsg);
  87                 CloseHandle(pOvl->hEvent);
  88                 ADIOI_Free(pOvl);
  89                 return;
  90             }
  91         }
  92         /* --END ERROR HANDLING-- */
  93         err = GetOverlappedResult(fd->fd_sys, pOvl, &dwNumWritten, TRUE);
  94         /* --BEGIN ERROR HANDLING-- */
  95         if (err == FALSE)
  96         {
  97         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
  98             err = GetLastError();
  99         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 100             *error_code = MPIO_Err_create_code(MPI_SUCCESS,
 101                 MPIR_ERR_RECOVERABLE, myname,
 102                 __LINE__, MPI_ERR_IO, "**io",
 103                 "**io %s", errMsg);
 104             CloseHandle(pOvl->hEvent);
 105             ADIOI_Free(pOvl);
 106             return;
 107         }
 108         /* --END ERROR HANDLING-- */
 109         if (!CloseHandle(pOvl->hEvent))
 110         {
 111         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 112             err = GetLastError();
 113         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 114             *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 115                 myname, __LINE__, MPI_ERR_IO,
 116                 "**io", "**io %s", errMsg);
 117             CloseHandle(pOvl->hEvent);
 118             ADIOI_Free(pOvl);
 119             return;
 120         }
 121         ADIOI_Free(pOvl);
 122
 123         fd->fp_sys_posn = offset + dwNumWritten;
 124         /* individual file pointer not updated */
 125     }
 126     else
 127     {
 128         /* write from curr. location of ind. file pointer */
 129         if (fd->fp_sys_posn != fd->fp_ind)
 130         {
 131             dwTemp = DWORDHIGH(fd->fp_ind);
 132             if (SetFilePointer(fd->fd_sys, DWORDLOW(fd->fp_ind), &dwTemp, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
 133             {
 134                 err = GetLastError();
 135                 if (err != NO_ERROR)
 136                 {
 137             char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 138             ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 139                     *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 140                         myname, __LINE__, MPI_ERR_IO,
 141                         "**io", "**io %s", errMsg);
 142                     CloseHandle(pOvl->hEvent);
 143                     ADIOI_Free(pOvl);
 144                     return;
 145                 }
 146             }
 147         }
 148         /*printf("WriteFile(%d bytes)\n", len);fflush(stdout);*/
 149         err = WriteFile(fd->fd_sys, buf, len, &dwNumWritten, pOvl);
 150         /* --BEGIN ERROR HANDLING-- */
 151         if (err == FALSE)
 152         {
 153             err = GetLastError();
 154             if (err != ERROR_IO_PENDING)
 155             {
 156         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 157         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 158                 *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 159                     myname, __LINE__, MPI_ERR_IO,
 160                     "**io",
 161                     "**io %s", errMsg);
 162                 CloseHandle(pOvl->hEvent);
 163                 ADIOI_Free(pOvl);
 164                 return;
 165             }
 166         }
 167         /* --END ERROR HANDLING-- */
 168         err = GetOverlappedResult(fd->fd_sys, pOvl, &dwNumWritten, TRUE);
 169         /* --BEGIN ERROR HANDLING-- */
 170         if (err == FALSE)
 171         {
 172         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 173             err = GetLastError();
 174         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 175             *error_code = MPIO_Err_create_code(MPI_SUCCESS,
 176                 MPIR_ERR_RECOVERABLE, myname,
 177                 __LINE__, MPI_ERR_IO, "**io",
 178                 "**io %s", errMsg);
 179             CloseHandle(pOvl->hEvent);
 180             ADIOI_Free(pOvl);
 181             return;
 182         }
 183         /* --END ERROR HANDLING-- */
 184         if (!CloseHandle(pOvl->hEvent))
 185         {
 186         char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 187             err = GetLastError();
 188         ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 189             *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 190                 myname, __LINE__, MPI_ERR_IO,
 191                 "**io", "**io %s", errMsg);
 192             ADIOI_Free(pOvl);
 193             return;
 194         }
 195         ADIOI_Free(pOvl);
 196
 197         fd->fp_ind = fd->fp_ind + dwNumWritten;
 198         fd->fp_sys_posn = fd->fp_ind;
 199     }
 200
 201 #ifdef HAVE_STATUS_SET_BYTES
 202     if (err != FALSE)
 203     {
 204         MPIR_Status_set_bytes(status, datatype, dwNumWritten);
 205     }
 206 #endif
 207
 208     /* --BEGIN ERROR HANDLING-- */
 209     if (err == FALSE)
 210     {
 211     char errMsg[ADIOI_NTFS_ERR_MSG_MAX];
 212         err = GetLastError();
 213     ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);
 214         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 215                                            myname, __LINE__, MPI_ERR_IO,
 216                                            "**io",
 217                                            "**io %s", errMsg);
 218         return;
 219     }
 220     /* --END ERROR HANDLING-- */
 221     *error_code = MPI_SUCCESS;
 222 }