Signal.cpp

#include <iostream>

#include <signal.h>

#include <stk_util/diag/Env.hpp>
#include <stk_util/diag/Signal.hpp>
#include <stk_util/util/Callback.hpp>
#include <stk_util/util/FeatureTest.hpp>
#include <stk_util/diag/SignalHandler.hpp>

namespace sierra {
namespace Env {

namespace {

class EnvSignal
{
public:
  static EnvSignal &instance() {
    static EnvSignal env_signal;

    return env_signal;
  }

private:
  EnvSignal()
    : m_enabled(false),
      m_hupReceived(false),
      hupCallback(*this, &EnvSignal::hupHandler),
      segvCallback(*this, &EnvSignal::segvHandler),
      illCallback(*this, &EnvSignal::illHandler),
      busCallback(*this, &EnvSignal::busHandler),
      termCallback(*this, &EnvSignal::termHandler)
  {}

public:
  inline sigjmp_buf *getSigJmpBuf() {
    m_enabled = true;

    return &m_sigJmpBuf;
  }

  void disableSigLongJmp() {
    m_enabled = false;
  }

  const std::string &message() const {
    return m_message;
  }

  bool getHUPReceived() {
    return m_hupReceived;
  }

  void activateSignals();

  void deactivateSignals();

private:
  void doSignal(const char *message, int signal);
  void hupHandler();
  void segvHandler();
  void illHandler();
  void busHandler();
  void termHandler();
  void intHandler();

private:
  sigjmp_buf    m_sigJmpBuf;      
  bool      m_enabled;      
  bool      m_hupReceived;      
  std::string   m_message;      

  Callback<EnvSignal> hupCallback;
  Callback<EnvSignal> segvCallback;
  Callback<EnvSignal> illCallback;
  Callback<EnvSignal> busCallback;
  Callback<EnvSignal> termCallback;
//  Callback<EnvSignal> intCallback;

};


  void
EnvSignal::activateSignals()
{
  SignalHandler::instance().add_handler(SIGSEGV, EnvSignal::segvCallback);
  SignalHandler::instance().add_handler(SIGILL, EnvSignal::illCallback);
  SignalHandler::instance().add_handler(SIGBUS, EnvSignal::busCallback);
//   SignalHandler::instance().add_handler(SIGINT, EnvSignal::intCallback);

#if defined(SIERRA_USER_SHUTDOWN_SIGNAL)
  SignalHandler::instance().add_handler(SIERRA_USER_SHUTDOWN_SIGNAL, EnvSignal::hupCallback);
#endif
#if defined(SIERRA_SHUTDOWN_SIGNAL)
  SignalHandler::instance().add_handler(SIERRA_SHUTDOWN_SIGNAL, EnvSignal::hupCallback);
#endif
#if defined(SIERRA_MPI_ABORT_SIGNAL)
  SignalHandler::instance().add_handler(SIERRA_MPI_ABORT_SIGNAL, EnvSignal::termCallback);
#endif
}


void
EnvSignal::deactivateSignals()
{
  SignalHandler::instance().remove_handler(SIGSEGV, EnvSignal::segvCallback);
  SignalHandler::instance().remove_handler(SIGILL, EnvSignal::illCallback);
  SignalHandler::instance().remove_handler(SIGBUS, EnvSignal::busCallback);
//   SignalHandler::instance().add_handler(SIGINT, EnvSignal::intCallback);

#if defined(SIERRA_USER_SHUTDOWN_SIGNAL)
  SignalHandler::instance().remove_handler(SIERRA_USER_SHUTDOWN_SIGNAL, EnvSignal::hupCallback);
#endif
#if defined(SIERRA_SHUTDOWN_SIGNAL)
  SignalHandler::instance().remove_handler(SIERRA_SHUTDOWN_SIGNAL, EnvSignal::hupCallback);
#endif
#if defined(SIERRA_MPI_ABORT_SIGNAL)
  SignalHandler::instance().remove_handler(SIERRA_MPI_ABORT_SIGNAL, EnvSignal::termCallback);
#endif
}


void
EnvSignal::doSignal(
  const char *  message,
  int   signal)
{
  if (!m_enabled) {
//    std::cout << message << std::endl << "Signal exception handling not enabled" << std::endl;
    ::raise(signal);
    return;
  }
  else {
    m_enabled = false;
    m_message = message;
    ::siglongjmp(m_sigJmpBuf, signal);
  }
}


void
EnvSignal::hupHandler()
{
  m_hupReceived = true;
}


void
EnvSignal::intHandler()
{
  m_hupReceived = true;
}


void
EnvSignal::segvHandler()
{
  SignalHandler::instance().remove_handler(SIGSEGV, EnvSignal::segvCallback);
  doSignal("Segmentation violation error", SIGSEGV);
}

void
EnvSignal::busHandler()
{
  SignalHandler::instance().remove_handler(SIGBUS, EnvSignal::busCallback);
  doSignal("Bus error", SIGBUS);
}


void
EnvSignal::illHandler()
{
  SignalHandler::instance().remove_handler(SIGILL, EnvSignal::illCallback);
  doSignal("Illegal instruction error", SIGILL);
}


void
EnvSignal::termHandler()
{
  SignalHandler::instance().remove_handler(SIGTERM, EnvSignal::termCallback);
  doSignal("Terminate signal received, likely due to an abort on another processor\n"
     "Refer to standard output log for more information", SIGTERM);
}

} // namespace <unnamed>


void
activate_signals()
{
  EnvSignal::instance().activateSignals();
}


void
deactivate_signals()
{
  EnvSignal::instance().deactivateSignals();
}


sigjmp_buf *
get_sigjmpbuf()
{
  return EnvSignal::instance().getSigJmpBuf();
}


void
disable_siglongjmp()
{
  return EnvSignal::instance().disableSigLongJmp();
}


const std::string &
get_signal_message()
{
  return EnvSignal::instance().message();
}


bool
HUP_received()
{
  return EnvSignal::instance().getHUPReceived();
}

} // namespace Env
} // namespace sierra