Changeset 42056d


Ignore:
Timestamp:
05/06/14 14:13:31 (2 months ago)
Author:
Rob Latham <robl@…>
Branches:
master
Children:
5948c2
Parents:
e0154e
git-author:
Rob Latham <robl@…> (05/05/14 16:26:55)
git-committer:
Rob Latham <robl@…> (05/06/14 14:13:31)
Message:

ROMIO: Consolidate errno processing

not every file system lives in a posix-like environment, but many do.
for those file systems, open and delete will return -1 and set errno.
The translation from unix erno to MPI error class was haphazard. Get
all aplicable file systems using ADIOI_Err_create_code so we have one
place to update error code conversion.

Closes: #2075

Signed-off-by: Wei-keng Liao <wkliao@…>

Location:
src/mpi/romio/adio
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • src/mpi/romio/adio/ad_gpfs/ad_gpfs_open.c

    r3dba49 r42056d  
    105105 
    106106  if (fd->fd_sys == -1)  { 
    107     if (errno == ENAMETOOLONG) 
    108       *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    109                                          MPIR_ERR_RECOVERABLE, myname, 
    110                                          __LINE__, MPI_ERR_BAD_FILE, 
    111                                          "**filenamelong", 
    112                                          "**filenamelong %s %d", 
    113                                          fd->filename, 
    114                                          strlen(fd->filename)); 
    115     else if (errno == ENOENT) 
    116       *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    117                                          MPIR_ERR_RECOVERABLE, myname, 
    118                                          __LINE__, MPI_ERR_NO_SUCH_FILE, 
    119                                          "**filenoexist", 
    120                                          "**filenoexist %s", 
    121                                          fd->filename); 
    122     else if (errno == ENOTDIR || errno == ELOOP) 
    123       *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    124                                          MPIR_ERR_RECOVERABLE, 
    125                                          myname, __LINE__, 
    126                                          MPI_ERR_BAD_FILE, 
    127                                          "**filenamedir", 
    128                                          "**filenamedir %s", 
    129                                          fd->filename); 
    130     else if (errno == EACCES)    { 
    131       *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    132                                          MPIR_ERR_RECOVERABLE, myname, 
    133                                          __LINE__, MPI_ERR_ACCESS, 
    134                                          "**fileaccess", 
    135                                          "**fileaccess %s",  
    136                                          fd->filename ); 
    137     } 
    138     else if (errno == EROFS)    { 
    139       /* Read only file or file system and write access requested */ 
    140       *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    141                                          MPIR_ERR_RECOVERABLE, myname, 
    142                                          __LINE__, MPI_ERR_READ_ONLY, 
    143                                          "**ioneedrd", 0 ); 
    144     } 
    145     else    { 
    146       *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    147                                          MPIR_ERR_RECOVERABLE, myname, 
    148                                          __LINE__, MPI_ERR_IO, "**io", 
    149                                          "**io %s", strerror(errno)); 
    150     } 
     107      *error_code = ADIOI_Err_create_code(myname, fd->filename, errno); 
    151108  } 
    152109  else *error_code = MPI_SUCCESS; 
  • src/mpi/romio/adio/ad_lustre/ad_lustre_open.c

    rec89df r42056d  
    106106    if (fd->fd_sys == -1 || ((fd->fd_direct == -1) &&  
    107107                (fd->direct_write || fd->direct_read))) { 
    108         if (errno == ENAMETOOLONG) 
    109             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    110                                                MPIR_ERR_RECOVERABLE, myname, 
    111                                                __LINE__, MPI_ERR_BAD_FILE, 
    112                                                "**filenamelong", 
    113                                                "**filenamelong %s %d", 
    114                                                fd->filename, 
    115                                                strlen(fd->filename)); 
    116         else if (errno == ENOENT) 
    117             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    118                                                MPIR_ERR_RECOVERABLE, myname, 
    119                                                __LINE__, MPI_ERR_NO_SUCH_FILE, 
    120                                                "**filenoexist", 
    121                                                "**filenoexist %s", 
    122                                                fd->filename); 
    123         else if (errno == ENOTDIR || errno == ELOOP) 
    124             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    125                                                MPIR_ERR_RECOVERABLE, 
    126                                                myname, __LINE__, 
    127                                                MPI_ERR_BAD_FILE, 
    128                                                "**filenamedir", 
    129                                                "**filenamedir %s", 
    130                                                fd->filename); 
    131         else if (errno == EACCES) { 
    132             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    133                                                MPIR_ERR_RECOVERABLE, myname, 
    134                                                __LINE__, MPI_ERR_ACCESS, 
    135                                                "**fileaccess", 
    136                                                "**fileaccess %s",  
    137                                                fd->filename ); 
    138         } 
    139         else if (errno == EROFS) { 
    140             /* Read only file or file system and write access requested */ 
    141             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    142                                                MPIR_ERR_RECOVERABLE, myname, 
    143                                                __LINE__, MPI_ERR_READ_ONLY, 
    144                                                "**ioneedrd", 0 ); 
    145         } 
    146         else { 
    147             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    148                                                MPIR_ERR_RECOVERABLE, myname, 
    149                                                __LINE__, MPI_ERR_IO, "**io", 
    150                                                "**io %s", strerror(errno)); 
    151         } 
     108        *error_code = ADIOI_Err_create_code(myname, fd->filename, errno); 
    152109    } 
    153110    /* --END ERROR HANDLING-- */ 
  • src/mpi/romio/adio/ad_nfs/ad_nfs_open.c

    r1afe02 r42056d  
    5353 
    5454    if (fd->fd_sys == -1) { 
    55         /* Check for special error codes for those MPI error  
    56            classes that relate to particular problems */ 
    57         if (errno == ENAMETOOLONG) 
    58             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    59                                                MPIR_ERR_RECOVERABLE, myname, 
    60                                                __LINE__, MPI_ERR_BAD_FILE, 
    61                                                "**filenamelong", 
    62                                                "**filenamelong %s %d", 
    63                                                fd->filename, 
    64                                                strlen(fd->filename)); 
    65         else if (errno == ENOENT) 
    66             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    67                                                MPIR_ERR_RECOVERABLE, myname, 
    68                                                __LINE__, MPI_ERR_NO_SUCH_FILE, 
    69                                                "**filenoexist", 
    70                                                "**filenoexist %s", 
    71                                                fd->filename); 
    72         else if (errno == ENOTDIR || errno == ELOOP) 
    73             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    74                                                MPIR_ERR_RECOVERABLE, myname, 
    75                                                __LINE__, MPI_ERR_BAD_FILE, 
    76                                                "**filenamedir", 
    77                                                "**filenamedir %s", 
    78                                                fd->filename); 
    79         else if (errno == EACCES) { 
    80             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    81                                                MPIR_ERR_RECOVERABLE, myname, 
    82                                                __LINE__, MPI_ERR_ACCESS, 
    83                                                "**fileaccess", 
    84                                                "**fileaccess %s",  
    85                                                fd->filename); 
    86         } 
    87         else if (errno == EROFS) { 
    88             /* Read only file or file system and write access requested */ 
    89             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    90                                                MPIR_ERR_RECOVERABLE, myname, 
    91                                                __LINE__, MPI_ERR_READ_ONLY, 
    92                                                "**ioneedrd", 0); 
    93         } 
    94     else if(errno == EISDIR) { 
    95         *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    96                            MPIR_ERR_RECOVERABLE, myname, 
    97                            __LINE__, MPI_ERR_BAD_FILE, 
    98                            "**filename", 0); 
    99     } 
    100     else if(errno == EEXIST) { 
    101         *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    102                            MPIR_ERR_RECOVERABLE, myname, 
    103                            __LINE__, MPI_ERR_FILE_EXISTS, 
    104                            "**fileexist", 0); 
    105  
    106     } 
    107         else { 
    108             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    109                                                MPIR_ERR_RECOVERABLE, myname, 
    110                                                __LINE__, MPI_ERR_IO, "**io", 
    111                                                "**io %s", strerror(errno)); 
    112         } 
     55        *error_code = ADIOI_Err_create_code(myname, fd->filename, errno); 
    11356    } 
    11457    else *error_code = MPI_SUCCESS; 
  • src/mpi/romio/adio/ad_panfs/ad_panfs_open.c

    rfa20c7 r42056d  
    343343 
    344344    if (fd->fd_sys == -1) { 
    345         if (errno == ENAMETOOLONG) 
    346             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    347                                                MPIR_ERR_RECOVERABLE, myname, 
    348                                                __LINE__, MPI_ERR_BAD_FILE, 
    349                                                "**filenamelong", 
    350                                                "**filenamelong %s %d", 
    351                                                fd->filename, 
    352                                                strlen(fd->filename)); 
    353         else if (errno == ENOENT) 
    354             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    355                                                MPIR_ERR_RECOVERABLE, myname, 
    356                                                __LINE__, MPI_ERR_NO_SUCH_FILE, 
    357                                                "**filenoexist", 
    358                                                "**filenoexist %s", 
    359                                                fd->filename); 
    360         else if (errno == ENOTDIR || errno == ELOOP) 
    361             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    362                                                MPIR_ERR_RECOVERABLE, 
    363                                                myname, __LINE__, 
    364                                                MPI_ERR_BAD_FILE, 
    365                                                "**filenamedir", 
    366                                                "**filenamedir %s", 
    367                                                fd->filename); 
    368         else if (errno == EACCES) { 
    369             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    370                                                MPIR_ERR_RECOVERABLE, myname, 
    371                                                __LINE__, MPI_ERR_ACCESS, 
    372                                                "**fileaccess", 
    373                                                "**fileaccess %s",  
    374                                                fd->filename ); 
    375         } 
    376         else if (errno == EROFS) { 
    377             /* Read only file or file system and write access requested */ 
    378             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    379                                                MPIR_ERR_RECOVERABLE, myname, 
    380                                                __LINE__, MPI_ERR_READ_ONLY, 
    381                                                "**ioneedrd", 0 ); 
    382         } 
    383         else { 
    384             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    385                                                MPIR_ERR_RECOVERABLE, myname, 
    386                                                __LINE__, MPI_ERR_IO, "**io", 
    387                                                "**io %s", strerror(errno)); 
    388         } 
     345        *error_code = ADIOI_Err_create_code(myname, fd->filename, errno); 
    389346    } 
    390347    else *error_code = MPI_SUCCESS; 
  • src/mpi/romio/adio/ad_ufs/ad_ufs_open.c

    r15dddc r42056d  
    5252    } 
    5353 
    54     /* --BEGIN ERROR HANDLING-- */ 
    5554    if (fd->fd_sys == -1) { 
    56         if (errno == ENAMETOOLONG) 
    57             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    58                                                MPIR_ERR_RECOVERABLE, myname, 
    59                                                __LINE__, MPI_ERR_BAD_FILE, 
    60                                                "**filenamelong", 
    61                                                "**filenamelong %s %d", 
    62                                                fd->filename, 
    63                                                strlen(fd->filename)); 
    64         else if (errno == ENOENT) 
    65             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    66                                                MPIR_ERR_RECOVERABLE, myname, 
    67                                                __LINE__, MPI_ERR_NO_SUCH_FILE, 
    68                                                "**filenoexist", 
    69                                                "**filenoexist %s", 
    70                                                fd->filename); 
    71         else if (errno == ENOTDIR || errno == ELOOP) 
    72             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    73                                                MPIR_ERR_RECOVERABLE, 
    74                                                myname, __LINE__, 
    75                                                MPI_ERR_BAD_FILE, 
    76                                                "**filenamedir", 
    77                                                "**filenamedir %s", 
    78                                                fd->filename); 
    79         else if (errno == EACCES) { 
    80             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    81                                                MPIR_ERR_RECOVERABLE, myname, 
    82                                                __LINE__, MPI_ERR_ACCESS, 
    83                                                "**fileaccess", 
    84                                                "**fileaccess %s",  
    85                                                fd->filename ); 
    86         } 
    87         else if (errno == EROFS) { 
    88             /* Read only file or file system and write access requested */ 
    89             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    90                                                MPIR_ERR_RECOVERABLE, myname, 
    91                                                __LINE__, MPI_ERR_READ_ONLY, 
    92                                                "**ioneedrd", 0 ); 
    93         } 
    94         else if(errno == EISDIR) { 
    95             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    96                                                MPIR_ERR_RECOVERABLE, myname, 
    97                                                __LINE__, MPI_ERR_BAD_FILE, 
    98                                                "**filename", 0); 
    99         } 
    100         else if(errno == EEXIST) { 
    101             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    102                                                MPIR_ERR_RECOVERABLE, myname, 
    103                                                __LINE__, MPI_ERR_FILE_EXISTS, 
    104                                                "**fileexist", 0); 
    105  
    106         } 
    107         else { 
    108             *error_code = MPIO_Err_create_code(MPI_SUCCESS, 
    109                                                MPIR_ERR_RECOVERABLE, myname, 
    110                                                __LINE__, MPI_ERR_IO, "**io", 
    111                                                "**io %s", strerror(errno)); 
    112         } 
     55        *error_code = ADIOI_Err_create_code(myname, fd->filename, errno); 
    11356    } 
    114     /* --END ERROR HANDLING-- */ 
    11557    else *error_code = MPI_SUCCESS; 
    11658} 
  • src/mpi/romio/adio/ad_xfs/ad_xfs_open.c

    r412198f r42056d  
    106106 
    107107    if ((fd->fd_sys == -1) || (fd->fd_direct == -1)) { 
    108         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, 
    109                                            myname, __LINE__, MPI_ERR_IO, "**io", 
    110                                            "**io %s", strerror(errno)); 
     108        *error_code = ADIOI_Err_create_code(mymame, fd->filename, errno); 
    111109    } 
    112110    else *error_code = MPI_SUCCESS; 
  • src/mpi/romio/adio/common/ad_delete.c

    rbfe951b r42056d  
    1919    err = unlink(filename); 
    2020    if (err == -1) { 
    21         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, 
    22                                            myname, __LINE__, MPI_ERR_IO, "**io", 
    23                                            "**io %s", strerror(errno)); 
    24         return; 
     21        *error_code = ADIOI_Err_create_code(myname, filename, errno); 
    2522    } 
    2623    else *error_code = MPI_SUCCESS; 
Note: See TracChangeset for help on using the changeset viewer.