void MPIR_Get_file_error_routine( MPI_Errhandler e, void (**c)(MPI_File *, int *, ...), int *kind ) { MPID_Errhandler *e_ptr = 0; int mpi_errno = MPI_SUCCESS; /* Convert the MPI_Errhandler into an MPID_Errhandler */ if (!e) { *c = 0; *kind = 1; /* Use errors return as the default */ } else { MPIR_ERRTEST_ERRHANDLER(e,mpi_errno); if (mpi_errno != MPI_SUCCESS) { /* FIXME: We need an error return */ *c = 0; *kind = 1; return; } MPID_Errhandler_get_ptr(e,e_ptr); if (!e_ptr) { /* FIXME: We need an error return */ *c = 0; *kind = 1; return; } if (e_ptr->handle == MPI_ERRORS_RETURN) { *c = 0; *kind = 1; } else if (e_ptr->handle == MPI_ERRORS_ARE_FATAL) { *c = 0; *kind = 0; } else { *c = e_ptr->errfn.C_File_Handler_function; *kind = 2; /* If the language is C++, we need to use a special call interface. This is MPIR_File_call_cxx_errhandler. See file_call_errhandler.c */ #ifdef HAVE_CXX_BINDING if (e_ptr->language == MPID_LANG_CXX) *kind = 3; #endif } } fn_fail: return; }
/*@ MPI_File_call_errhandler - Call the error handler installed on a file Input Parameters: + fh - MPI file with error handler (handle) - errorcode - error code (integer) .N ThreadSafeNoUpdate .N Fortran .N Errors .N MPI_SUCCESS .N MPI_ERR_FILE @*/ int MPI_File_call_errhandler(MPI_File fh, int errorcode) { int mpi_errno = MPI_SUCCESS; #ifdef MPI_MODE_RDONLY MPID_Errhandler *e; MPI_Errhandler eh; #endif MPIU_THREADPRIV_DECL; MPID_MPI_STATE_DECL(MPID_STATE_MPI_FILE_CALL_ERRHANDLER); MPIR_ERRTEST_INITIALIZED_ORDIE(); MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_FILE_CALL_ERRHANDLER); MPIU_THREADPRIV_GET; #ifdef MPI_MODE_RDONLY /* Validate parameters, especially handles needing to be converted */ /* FIXME: check for a valid file handle (fh) before converting to a pointer */ /* ... body of routine ... */ MPIR_ROMIO_Get_file_errhand( fh, &eh ); /* Check for the special case of errors-throw-exception. In this case return the error code; the C++ wrapper will cause an exception to be thrown. */ #ifdef HAVE_CXX_BINDING if (eh == MPIR_ERRORS_THROW_EXCEPTIONS) { mpi_errno = errorcode; goto fn_exit; } #endif if (!eh) { MPID_Errhandler_get_ptr( MPI_ERRORS_RETURN, e ); } else { MPID_Errhandler_get_ptr( eh, e ); } /* Note that, unlike the rest of MPICH, MPI_File objects are pointers, not integers. */ if (e->handle == MPI_ERRORS_RETURN) { mpi_errno = errorcode; goto fn_exit; } switch (e->language) { case MPID_LANG_C: (*e->errfn.C_File_Handler_function)( &fh, &errorcode ); break; #ifdef HAVE_CXX_BINDING case MPID_LANG_CXX: /* See HAVE_LANGUAGE_FORTRAN below for an explanation */ { void *fh1 = (void *)&fh; (*MPIR_Process.cxx_call_errfn)( 1, fh1, &errorcode, (void (*)(void))*e->errfn.C_File_Handler_function ); } break; #endif #ifdef HAVE_FORTRAN_BINDING case MPID_LANG_FORTRAN90: case MPID_LANG_FORTRAN: /* The assignemt to a local variable prevents the compiler from generating a warning about a type-punned pointer. Since the value is really const (but MPI didn't define error handlers with const), this preserves the intent */ { void *fh1 = (void *)&fh; MPI_Fint ferr = errorcode; /* Needed if MPI_Fint and int aren't the same size */ (*e->errfn.F77_Handler_function)( fh1, &ferr ); } break; #endif } #else /* Dummy in case ROMIO is not defined */ mpi_errno = MPI_ERR_INTERN; #endif /* ... end of body of routine ... */ #if defined(HAVE_CXX_BINDING) && defined(MPI_MODE_RDONLY) fn_exit: #else fn_exit: #endif MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_FILE_CALL_ERRHANDLER); return mpi_errno; }
/*@ MPI_Win_set_errhandler - Set window error handler Input Parameters: + win - window (handle) - errhandler - new error handler for window (handle) .N ThreadSafeNoUpdate .N Fortran .N Errors .N MPI_SUCCESS .N MPI_ERR_WIN @*/ int MPI_Win_set_errhandler(MPI_Win win, MPI_Errhandler errhandler) { #ifdef HAVE_ERROR_CHECKING static const char FCNAME[] = "MPI_Win_set_errhandler"; #endif int mpi_errno = MPI_SUCCESS; MPID_Win *win_ptr = NULL; int in_use; MPID_Errhandler *errhan_ptr = NULL; MPID_MPI_STATE_DECL(MPID_STATE_MPI_WIN_SET_ERRHANDLER); MPIR_ERRTEST_INITIALIZED_ORDIE(); MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_WIN_SET_ERRHANDLER); /* Validate parameters, especially handles needing to be converted */ # ifdef HAVE_ERROR_CHECKING { MPID_BEGIN_ERROR_CHECKS; { MPIR_ERRTEST_WIN(win, mpi_errno); MPIR_ERRTEST_ERRHANDLER(errhandler, mpi_errno); } MPID_END_ERROR_CHECKS; } # endif /* Convert MPI object handles to object pointers */ MPID_Win_get_ptr( win, win_ptr ); MPID_Errhandler_get_ptr( errhandler, errhan_ptr ); /* Validate parameters and objects (post conversion) */ # ifdef HAVE_ERROR_CHECKING { MPID_BEGIN_ERROR_CHECKS; { /* Validate win_ptr */ MPID_Win_valid_ptr( win_ptr, mpi_errno ); /* If win_ptr is not value, it will be reset to null */ if (HANDLE_GET_KIND(errhandler) != HANDLE_KIND_BUILTIN) { MPID_Errhandler_valid_ptr( errhan_ptr,mpi_errno ); /* Also check for a valid errhandler kind */ if (!mpi_errno) { if (errhan_ptr->kind != MPID_WIN) { mpi_errno = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_ARG, "**errhandnotwin", NULL ); } } } if (mpi_errno) goto fn_fail; } MPID_END_ERROR_CHECKS; } # endif /* HAVE_ERROR_CHECKING */ /* ... body of routine ... */ MPID_THREAD_CS_ENTER(POBJ, MPIR_THREAD_POBJ_WIN_MUTEX(win_ptr)); if (win_ptr->errhandler != NULL) { MPIR_Errhandler_release_ref(win_ptr->errhandler,&in_use); if (!in_use) { MPID_Errhandler_free( win_ptr->errhandler ); } } MPIR_Errhandler_add_ref(errhan_ptr); win_ptr->errhandler = errhan_ptr; MPID_THREAD_CS_EXIT(POBJ, MPIR_THREAD_POBJ_WIN_MUTEX(win_ptr)); /* ... end of body of routine ... */ #ifdef HAVE_ERROR_CHECKING fn_exit: #endif MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_WIN_SET_ERRHANDLER); return mpi_errno; /* --BEGIN ERROR HANDLING-- */ # ifdef HAVE_ERROR_CHECKING fn_fail: { mpi_errno = MPIR_Err_create_code( mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**mpi_win_set_errhandler", "**mpi_win_set_errhandler %W %E", win, errhandler); } mpi_errno = MPIR_Err_return_win(win_ptr, FCNAME, mpi_errno); goto fn_exit; # endif /* --END ERROR HANDLING-- */ }
/*@ MPI_File_set_errhandler - Set the error handler for an MPI file Input Parameters: + file - MPI file (handle) - errhandler - new error handler for file (handle) .N ThreadSafeNoUpdate .N Fortran .N Errors .N MPI_SUCCESS @*/ int MPI_File_set_errhandler(MPI_File file, MPI_Errhandler errhandler) { #ifdef HAVE_ERROR_CHECKING static const char FCNAME[] = "MPI_File_set_errhandler"; #endif int mpi_errno = MPI_SUCCESS; #ifdef MPI_MODE_RDONLY int in_use; MPID_Errhandler *errhan_ptr = NULL, *old_errhandler_ptr; MPI_Errhandler old_errhandler; #endif MPID_MPI_STATE_DECL(MPID_STATE_MPI_FILE_SET_ERRHANDLER); MPIR_ERRTEST_INITIALIZED_ORDIE(); MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_FILE_SET_ERRHANDLER); #ifdef MPI_MODE_RDONLY /* Validate parameters, especially handles needing to be converted */ # ifdef HAVE_ERROR_CHECKING { MPID_BEGIN_ERROR_CHECKS; { /* FIXME: check for a valid file handle (fh) before converting to a pointer */ MPIR_ERRTEST_ERRHANDLER(errhandler, mpi_errno); } MPID_END_ERROR_CHECKS; } # endif /* HAVE_ERROR_CHECKING */ MPID_Errhandler_get_ptr( errhandler, errhan_ptr ); /* Validate parameters and objects (post conversion) */ # ifdef HAVE_ERROR_CHECKING { MPID_BEGIN_ERROR_CHECKS; { if (HANDLE_GET_KIND(errhandler) != HANDLE_KIND_BUILTIN) { MPID_Errhandler_valid_ptr( errhan_ptr,mpi_errno ); /* Also check for a valid errhandler kind */ if (!mpi_errno) { if (errhan_ptr->kind != MPID_FILE) { mpi_errno = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_ARG, "**errhandnotfile", NULL ); } } } if (mpi_errno) goto fn_fail; } MPID_END_ERROR_CHECKS; } # endif /* HAVE_ERROR_CHECKING */ /* ... body of routine ... */ MPIR_ROMIO_Get_file_errhand( file, &old_errhandler ); if (!old_errhandler) { /* MPI_File objects default to the errhandler set on MPI_FILE_NULL * at file open time, or MPI_ERRORS_RETURN if no errhandler is set * on MPI_FILE_NULL. (MPI-2.2, sec 13.7) */ MPID_Errhandler_get_ptr( MPI_ERRORS_RETURN, old_errhandler_ptr ); } else { MPID_Errhandler_get_ptr( old_errhandler, old_errhandler_ptr ); } if (old_errhandler_ptr) { MPIR_Errhandler_release_ref(old_errhandler_ptr,&in_use); if (!in_use) { MPID_Errhandler_free( old_errhandler_ptr ); } } MPIR_Errhandler_add_ref(errhan_ptr); MPIR_ROMIO_Set_file_errhand( file, errhandler ); #else /* Dummy in case ROMIO is not defined */ mpi_errno = MPI_ERR_INTERN; #ifdef HAVE_ERROR_CHECKING if (0) goto fn_fail; /* quiet compiler warning about unused label */ #endif #endif /* ... end of body of routine ... */ #ifdef HAVE_ERROR_CHECKING fn_exit: #endif MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_FILE_SET_ERRHANDLER); return mpi_errno; /* --BEGIN ERROR HANDLING-- */ # ifdef HAVE_ERROR_CHECKING fn_fail: { mpi_errno = MPIR_Err_create_code( mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**mpi_file_set_errhandler", "**mpi_file_set_errhandler %F %E", file, errhandler); } /* FIXME: Is this obsolete now? */ #ifdef MPI_MODE_RDONLY mpi_errno = MPIO_Err_return_file( file, mpi_errno ); #endif goto fn_exit; # endif /* --END ERROR HANDLING-- */ }
/*@ MPI_File_get_errhandler - Get the error handler attached to a file Input Parameters: . file - MPI file (handle) Output Parameters: . errhandler - handler currently associated with file (handle) .N ThreadSafeNoUpdate .N Fortran .N Errors .N MPI_SUCCESS @*/ int MPI_File_get_errhandler(MPI_File file, MPI_Errhandler *errhandler) { #ifdef HAVE_ERROR_CHECKING static const char FCNAME[] = "MPI_File_get_errhandler"; #endif int mpi_errno = MPI_SUCCESS; #ifdef MPI_MODE_RDONLY MPI_Errhandler eh; MPID_Errhandler *e; #endif MPID_MPI_STATE_DECL(MPID_STATE_MPI_FILE_GET_ERRHANDLER); MPIR_ERRTEST_INITIALIZED_ORDIE(); MPIU_THREAD_CS_ENTER(ALLFUNC,); MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_FILE_GET_ERRHANDLER); #ifdef MPI_MODE_RDONLY /* Validate parameters, especially handles needing to be converted */ /* FIXME: check for a valid file handle (fh) before converting to a pointer */ /* Validate parameters and objects (post conversion) */ # ifdef HAVE_ERROR_CHECKING { MPID_BEGIN_ERROR_CHECKS; { MPIR_ERRTEST_ARGNULL(errhandler,"errhandler",mpi_errno); } MPID_END_ERROR_CHECKS; } # endif /* HAVE_ERROR_CHECKING */ /* ... body of routine ... */ MPIR_ROMIO_Get_file_errhand( file, &eh ); if (!eh) { MPID_Errhandler_get_ptr( MPI_ERRORS_RETURN, e ); } else { MPID_Errhandler_get_ptr( eh, e ); } MPIR_Errhandler_add_ref( e ); *errhandler = e->handle; #else /* Dummy in case ROMIO is not defined */ mpi_errno = MPI_ERR_INTERN; #ifdef HAVE_ERROR_CHECKING if (0) goto fn_fail; /* quiet compiler warning about unused label */ #endif #endif /* ... end of body of routine ... */ #ifdef HAVE_ERROR_CHECKING fn_exit: #endif MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_FILE_GET_ERRHANDLER); MPIU_THREAD_CS_EXIT(ALLFUNC,); return mpi_errno; /* --BEGIN ERROR HANDLING-- */ # ifdef HAVE_ERROR_CHECKING fn_fail: { mpi_errno = MPIR_Err_create_code( mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**mpi_file_get_errhandler", "**mpi_file_get_errhandler %F %p", file, errhandler); } /* FIXME: Is this obsolete now? */ #ifdef MPI_MODE_RDONLY mpi_errno = MPIO_Err_return_file( file, mpi_errno ); #endif goto fn_exit; # endif /* --END ERROR HANDLING-- */ }