src/gromacs/utility/fatalerror.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
   5  * Copyright (c) 2001-2004, The GROMACS development team.
   6  * Copyright (c) 2013,2014, by the GROMACS development team, led by
   7  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   8  * and including many others, as listed in the AUTHORS file in the
   9  * top-level source directory and at http://www.gromacs.org.
  10  *
  11  * GROMACS is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public License
  13  * as published by the Free Software Foundation; either version 2.1
  14  * of the License, or (at your option) any later version.
  15  *
  16  * GROMACS is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with GROMACS; if not, see
  23  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  25  *
  26  * If you want to redistribute modifications to GROMACS, please
  27  * consider that scientific software is very special. Version
  28  * control is crucial - bugs must be traceable. We will be happy to
  29  * consider code for inclusion in the official distribution, but
  30  * derived work must not be called official GROMACS. Details are found
  31  * in the README & COPYING files - if they are missing, get the
  32  * official version at http://www.gromacs.org.
  33  *
  34  * To help us fund GROMACS development, we humbly ask that you cite
  35  * the research papers on the package. Check out http://www.gromacs.org.
  36  */
  37 #include "gmxpre.h"
  38
  39 #include "fatalerror.h"
  40
  41 #include "config.h"
  42
  43 #include <cerrno>
  44 #include <cstdarg>
  45 #include <cstdlib>
  46 #include <cstring>
  47
  48 #include <exception>
  49
  50 #include "thread_mpi/threads.h"
  51
  52 #include "gromacs/utility/basenetwork.h"
  53 #include "gromacs/utility/baseversion.h"
  54 #include "gromacs/utility/common.h"
  55 #include "gromacs/utility/cstringutil.h"
  56 #include "gromacs/utility/futil.h"
  57 #include "gromacs/utility/gmxmpi.h"
  58 #include "gromacs/utility/programcontext.h"
  59 #include "gromacs/utility/smalloc.h"
  60
  61 static bool                bDebug         = false;
  62 static tMPI_Thread_mutex_t where_mutex    = TMPI_THREAD_MUTEX_INITIALIZER;
  63
  64 FILE                      *debug          = NULL;
  65 gmx_bool                   gmx_debug_at   = FALSE;
  66
  67 static FILE               *log_file       = NULL;
  68 static tMPI_Thread_mutex_t error_mutex    = TMPI_THREAD_MUTEX_INITIALIZER;
  69 static const char *const   gmxuser
  70     = "Please report this to the mailing list (gmx-users@gromacs.org)";
  71
  72 void gmx_init_debug(const int dbglevel, const char *dbgfile)
  73 {
  74     if (!bDebug)
  75     {
  76         gmx_disable_file_buffering();
  77         debug  = gmx_ffopen(dbgfile, "w+");
  78         bDebug = true;
  79         if (dbglevel >= 2)
  80         {
  81             gmx_debug_at = TRUE;
  82         }
  83     }
  84 }
  85
  86 gmx_bool bDebugMode(void)
  87 {
  88     return bDebug;
  89 }
  90
  91 void _where(const char *file, int line)
  92 {
  93     static gmx_bool bFirst = TRUE;
  94     static int      nskip  = -1;
  95     static int      nwhere =  0;
  96     FILE           *fp;
  97     char           *temp;
  98
  99     if (bFirst)
 100     {
 101         tMPI_Thread_mutex_lock(&where_mutex);
 102         if (bFirst) /* we repeat the check in the locked section because things
 103                        might have changed */
 104         {
 105             if ((temp = getenv("GMX_PRINT_DEBUG_LINES")) != NULL)
 106             {
 107                 nskip = strtol(temp, NULL, 10);
 108             }
 109             bFirst = FALSE;
 110         }
 111         tMPI_Thread_mutex_unlock(&where_mutex);
 112     }
 113
 114     if (nskip >= 0)
 115     {
 116         /* Skip the first n occasions, this allows to see where it goes wrong */
 117         if (nwhere >= nskip)
 118         {
 119             if (log_file)
 120             {
 121                 fp = log_file;
 122             }
 123             else
 124             {
 125                 fp = stderr;
 126             }
 127             fprintf(fp, "WHERE %d, file %s - line %d\n", nwhere, file, line);
 128         }
 129         nwhere++;
 130     }
 131 }
 132
 133 void gmx_fatal_set_log_file(FILE *fp)
 134 {
 135     log_file = fp;
 136 }
 137
 138 static int fatal_errno = 0;
 139
 140 static void default_error_handler(const char *msg)
 141 {
 142     tMPI_Thread_mutex_lock(&error_mutex);
 143     if (fatal_errno == 0)
 144     {
 145         if (log_file)
 146         {
 147             fprintf(log_file, "%s\n", msg);
 148         }
 149         fprintf(stderr, "%s\n", msg);
 150         /* we set it to no-zero because if this function is called, something
 151            has gone wrong */
 152         fatal_errno = 255;
 153     }
 154     else
 155     {
 156         if (fatal_errno != -1)
 157         {
 158             errno = fatal_errno;
 159         }
 160         perror(msg);
 161     }
 162     tMPI_Thread_mutex_unlock(&error_mutex);
 163 }
 164
 165 static void (*gmx_error_handler)(const char *msg) = default_error_handler;
 166
 167 void set_gmx_error_handler(void (*func)(const char *msg))
 168 {
 169     // TODO: Either this is unnecessary, or also reads to the handler should be
 170     // protected by a mutex.
 171     tMPI_Thread_mutex_lock(&error_mutex);
 172     gmx_error_handler = func;
 173     tMPI_Thread_mutex_unlock(&error_mutex);
 174 }
 175
 176 static void call_error_handler(const char *key, const char *file, int line, const char *msg)
 177 {
 178     char        buf[10240], errerrbuf[1024];
 179     const char *llines = "-------------------------------------------------------";
 180     char       *strerr;
 181
 182     if (msg == NULL)
 183     {
 184         sprintf(errerrbuf, "Empty fatal_error message. %s", gmxuser);
 185     }
 186     // In case ProgramInfo is not initialized and there is an issue with the
 187     // initialization, fall back to "GROMACS".
 188     const char *programName = "GROMACS";
 189     try
 190     {
 191         programName = gmx::getProgramContext().displayName();
 192     }
 193     catch (const std::exception &)
 194     {
 195     }
 196
 197     strerr = gmx_strerror(key);
 198     sprintf(buf, "\n%s\nProgram %s, %s\n"
 199             "Source code file: %s, line: %d\n\n"
 200             "%s:\n%s\nFor more information and tips for troubleshooting, please check the GROMACS\n"
 201             "website at http://www.gromacs.org/Documentation/Errors\n%s\n",
 202             llines, programName, gmx_version(), file, line,
 203             strerr, msg ? msg : errerrbuf, llines);
 204     free(strerr);
 205
 206     gmx_error_handler(buf);
 207 }
 208
 209 GMX_ATTRIBUTE_NORETURN static void do_exit(bool bMaster, bool bFinalize)
 210 {
 211     if (debug)
 212     {
 213         fflush(debug);
 214     }
 215
 216 #ifdef GMX_MPI
 217     if (gmx_mpi_initialized())
 218     {
 219         if (bFinalize)
 220         {
 221             /* Broadcast the fatal error number possibly modified
 222              * on the master process, in case the user would like
 223              * to use the return status on a non-master process.
 224              * The master process in cr and dd always has global rank 0.
 225              */
 226             MPI_Bcast(&fatal_errno, sizeof(fatal_errno), MPI_BYTE,
 227                       0, MPI_COMM_WORLD);
 228
 229             /* Finalize nicely instead of aborting */
 230             MPI_Finalize();
 231         }
 232         else if (bMaster)
 233         {
 234 #ifdef GMX_LIB_MPI
 235             gmx_abort(1);
 236 #endif
 237         }
 238         else
 239         {
 240             /* Let all other processes wait till the master has printed
 241              * the error message and issued MPI_Abort.
 242              */
 243             MPI_Barrier(MPI_COMM_WORLD);
 244         }
 245     }
 246 #else
 247     GMX_UNUSED_VALUE(bMaster);
 248     GMX_UNUSED_VALUE(bFinalize);
 249 #endif
 250
 251     if (bDebugMode())
 252     {
 253         std::abort();
 254     }
 255     std::exit(1);
 256 }
 257
 258 void gmx_fatal_mpi_va(int f_errno, const char *file, int line,
 259                       gmx_bool bMaster, gmx_bool bFinalize,
 260                       const char *fmt, va_list ap)
 261 {
 262     if (bMaster)
 263     {
 264         char msg[STRLEN];
 265         vsprintf(msg, fmt, ap);
 266
 267         tMPI_Thread_mutex_lock(&error_mutex);
 268         fatal_errno = f_errno;
 269         tMPI_Thread_mutex_unlock(&error_mutex);
 270
 271         call_error_handler("fatal", file, line, msg);
 272     }
 273
 274     do_exit(bMaster, bFinalize);
 275 }
 276
 277 void gmx_fatal(int f_errno, const char *file, int line, const char *fmt, ...)
 278 {
 279     va_list ap;
 280     va_start(ap, fmt);
 281     gmx_fatal_mpi_va(f_errno, file, line, TRUE, FALSE, fmt, ap);
 282     va_end(ap);
 283 }
 284
 285 char *gmx_strerror(const char *key)
 286 {
 287     typedef struct {
 288         const char *key, *msg;
 289     } error_msg_t;
 290     error_msg_t msg[] = {
 291         { "bug",    "Possible bug" },
 292         { "call",   "Routine should not have been called" },
 293         { "comm",   "Communication (parallel processing) problem" },
 294         { "fatal",  "Fatal error" },
 295         { "cmd",    "Invalid command line argument" },
 296         { "file",   "File input/output error" },
 297         { "impl",   "Implementation restriction" },
 298         { "incons", "Software inconsistency error" },
 299         { "input",  "Input error or input inconsistency" },
 300         { "mem",    "Memory allocation/freeing error" },
 301         { "open",   "Can not open file" },
 302         { "range",  "Range checking error" },
 303         { NULL,     NULL}
 304     };
 305
 306     if (key == NULL)
 307     {
 308         return strdup("Empty message");
 309     }
 310     else
 311     {
 312         for (size_t i = 0; msg[i].key != NULL; ++i)
 313         {
 314             if (strcmp(key, msg[i].key) == 0)
 315             {
 316                 return strdup(msg[i].msg);
 317             }
 318         }
 319         char buf[1024];
 320         sprintf(buf, "No error message associated with key %s\n%s", key, gmxuser);
 321         return strdup(buf);
 322     }
 323 }
 324
 325
 326 void _gmx_error(const char *key, const char *msg, const char *file, int line)
 327 {
 328     call_error_handler(key, file, line, msg);
 329     do_exit(true, false);
 330 }
 331
 332 void _range_check(int n, int n_min, int n_max, const char *warn_str,
 333                   const char *var, const char *file, int line)
 334 {
 335     char buf[1024];
 336
 337     if ((n < n_min) || (n >= n_max))
 338     {
 339         if (warn_str != NULL)
 340         {
 341             strcpy(buf, warn_str);
 342             strcat(buf, "\n");
 343         }
 344         else
 345         {
 346             buf[0] = '\0';
 347         }
 348
 349         sprintf(buf+strlen(buf), "Variable %s has value %d. It should have been "
 350                 "within [ %d .. %d ]\n", var, n, n_min, n_max);
 351
 352         _gmx_error("range", buf, file, line);
 353     }
 354 }
 355
 356 void gmx_warning(const char *fmt, ...)
 357 {
 358     va_list ap;
 359     char    msg[STRLEN];
 360
 361     va_start(ap, fmt);
 362     vsprintf(msg, fmt, ap);
 363     va_end(ap);
 364
 365     fprintf(stderr, "\nWARNING: %s\n\n", msg);
 366 }