src/OSspecific/Unix/signals/sigFpe.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include "error.H"
  28 #include "sigFpe.H"
  29
  30 #include "JobInfo.H"
  31 #include "OSspecific.H"
  32 #include "IOstreams.H"
  33
  34 #ifdef LINUX_GNUC
  35
  36 #   ifndef __USE_GNU
  37 #       define __USE_GNU
  38 #   endif
  39
  40 #   include <fenv.h>
  41 #   include <malloc.h>
  42
  43 #elif defined(sgiN32) || defined(sgiN32Gcc)
  44
  45 #   include <sigfpe.h>
  46
  47 #endif
  48
  49
  50 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  51
  52 struct sigaction Foam::sigFpe::oldAction_;
  53
  54
  55 #if defined(LINUX)
  56
  57 void *(*Foam::sigFpe::old_malloc_hook)(size_t, const void *) = NULL;
  58
  59 void* Foam::sigFpe::my_malloc_hook(size_t size, const void *caller)
  60 {
  61     void *result;
  62
  63     // Restore all old hooks
  64     __malloc_hook = old_malloc_hook;
  65
  66     // Call recursively
  67     result = malloc (size);
  68
  69     // initialize to signalling nan
  70 #   ifdef SP
  71
  72     const uint32_t sNAN = 0x7ff7fffflu;
  73
  74     int nScalars = size / sizeof(scalar);
  75
  76     uint32_t* dPtr = reinterpret_cast<uint32_t*>(result);
  77
  78     for (int i = 0; i < nScalars; i++)
  79     {
  80         *dPtr++ = sNAN;
  81     }
  82
  83 #   else
  84
  85     const uint64_t sNAN = 0x7ff7ffffffffffffllu;
  86
  87     int nScalars = size/sizeof(scalar);
  88
  89     uint64_t* dPtr = reinterpret_cast<uint64_t*>(result);
  90
  91     for (int i = 0; i < nScalars; i++)
  92     {
  93         *dPtr++ = sNAN;
  94     }
  95
  96 #   endif
  97
  98     // Restore our own hooks
  99     __malloc_hook = my_malloc_hook;
 100
 101     return result;
 102 }
 103
 104 #endif
 105
 106
 107 #ifdef LINUX_GNUC
 108
 109 void Foam::sigFpe::sigFpeHandler(int)
 110 {
 111     // Reset old handling
 112     if (sigaction(SIGFPE, &oldAction_, NULL) < 0)
 113     {
 114         FatalErrorIn
 115         (
 116             "Foam::sigSegv::sigFpeHandler()"
 117         )   << "Cannot reset SIGFPE trapping"
 118             << abort(FatalError);
 119     }
 120
 121     // Update jobInfo file
 122     jobInfo.signalEnd();
 123
 124     error::printStack(Perr);
 125
 126     // Throw signal (to old handler)
 127     raise(SIGFPE);
 128 }
 129
 130 #endif
 131
 132
 133 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 134
 135 Foam::sigFpe::sigFpe()
 136 {
 137     oldAction_.sa_handler = NULL;
 138 }
 139
 140
 141 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 142
 143 Foam::sigFpe::~sigFpe()
 144 {
 145     if (env("FOAM_SIGFPE"))
 146     {
 147 #       ifdef LINUX_GNUC
 148
 149         // Reset signal
 150         if (oldAction_.sa_handler && sigaction(SIGFPE, &oldAction_, NULL) < 0)
 151         {
 152             FatalErrorIn
 153             (
 154                 "Foam::sigFpe::~sigFpe()"
 155             )   << "Cannot reset SIGFPE trapping"
 156                 << abort(FatalError);
 157         }
 158
 159 #       endif
 160     }
 161
 162     if (env("FOAM_SETNAN"))
 163     {
 164 #       ifdef LINUX_GNUC
 165
 166         // Reset to standard malloc
 167         if (oldAction_.sa_handler)
 168         {
 169             __malloc_hook = old_malloc_hook;
 170         }
 171
 172 #       endif
 173     }
 174 }
 175
 176
 177 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 178
 179 void Foam::sigFpe::set()
 180 {
 181     if (oldAction_.sa_handler)
 182     {
 183         FatalErrorIn
 184         (
 185             "Foam::sigFpe::set()"
 186         )   << "Cannot call sigFpe::set() more than once"
 187             << abort(FatalError);
 188     }
 189
 190     if (env("FOAM_SIGFPE"))
 191     {
 192 #       ifdef LINUX_GNUC
 193
 194         feenableexcept
 195         (
 196             FE_DIVBYZERO
 197           | FE_INVALID
 198           | FE_OVERFLOW
 199         );
 200
 201         struct sigaction newAction;
 202         newAction.sa_handler = sigFpeHandler;
 203         newAction.sa_flags = SA_NODEFER;
 204         sigemptyset(&newAction.sa_mask);
 205         if (sigaction(SIGFPE, &newAction, &oldAction_) < 0)
 206         {
 207             FatalErrorIn
 208             (
 209                 "Foam::sigFpe::set()"
 210             )   << "Cannot set SIGFPE trapping"
 211                 << abort(FatalError);
 212         }
 213
 214
 215 #       elif defined(sgiN32) || defined(sgiN32Gcc)
 216
 217         sigfpe_[_DIVZERO].abort=1;
 218         sigfpe_[_OVERFL].abort=1;
 219         sigfpe_[_INVALID].abort=1;
 220
 221         sigfpe_[_DIVZERO].trace=1;
 222         sigfpe_[_OVERFL].trace=1;
 223         sigfpe_[_INVALID].trace=1;
 224
 225         handle_sigfpes
 226         (
 227             _ON,
 228             _EN_DIVZERO
 229           | _EN_INVALID
 230           | _EN_OVERFL,
 231             0,
 232             _ABORT_ON_ERROR,
 233             NULL
 234         );
 235
 236 #       endif
 237     }
 238
 239
 240     if (env("FOAM_SETNAN"))
 241     {
 242 #       ifdef LINUX_GNUC
 243
 244         // Set our malloc
 245         __malloc_hook = Foam::sigFpe::my_malloc_hook;
 246
 247 #       endif
 248     }
 249 }
 250
 251
 252 // ************************************************************************* //