CoreDumpSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENASERVICES_COREDUMPSVC_H
#define ATHENASERVICES_COREDUMPSVC_H 1
 
// System includes
#include <signal.h>
#include <string>
#include <atomic>
#include <tbb/concurrent_unordered_map.h>
 
// Package includes
#include "AthenaKernel/ICoreDumpSvc.h"
 
// FrameWork includes
#include "AthenaBaseComps/AthService.h"
#include "CxxUtils/checker_macros.h"
#include "GaudiKernel/IIncidentListener.h"
#include "EventInfo/EventID.h"
 
 
namespace CoreDumpSvcHandler {
  void action ATLAS_NOT_THREAD_SAFE ( int sig, siginfo_t *info, void* extra );
}

 
class CoreDumpSvc : public extends<AthService, 
                                   ICoreDumpSvc,
                                   IIncidentListener> {
 
protected:
  friend void CoreDumpSvcHandler::action( int sig, siginfo_t *info, void* extra );
  
  CoreDumpSvc();
  
public: 

  CoreDumpSvc( const std::string& name, ISvcLocator* pSvcLocator ) ATLAS_CTORDTOR_NOT_THREAD_SAFE;
  
  virtual ~CoreDumpSvc() ATLAS_CTORDTOR_NOT_THREAD_SAFE;
  


  virtual void setCoreDumpInfo( const std::string& name, const std::string& value ) override;

  virtual void setCoreDumpInfo( const EventContext& ctx, const std::string& name, const std::string& value ) override;

  virtual std::string dump() const override;
 


  virtual StatusCode initialize ATLAS_NOT_THREAD_SAFE () override;
  virtual StatusCode start() override;
  virtual StatusCode finalize ATLAS_NOT_THREAD_SAFE () override;
  
  virtual void handle( const Incident& incident ) override;
 
    
private:
  struct sysDumpRec{
    std::string LastInc;
    std::string EvId;
  };
  typedef tbb::concurrent_unordered_map<std::string,std::string > UserCore_t;
  std::vector<UserCore_t>  m_usrCoreDumps;               
  std::vector<sysDumpRec> m_sysCoreDumps;                
  siginfo_t* m_siginfo{nullptr};                         
  std::atomic<EventID::event_number_t> m_eventCounter{0};   
 
  thread_local static std::vector<uint8_t> s_stack;      
  
 
  Gaudi::Property<std::vector<int>> m_signals{this, "Signals", {SIGSEGV,SIGBUS,SIGILL,SIGABRT,SIGFPE,SIGALRM},
      "List of signals to catch"};
 
  Gaudi::Property<bool> m_callOldHandler{this, "CallOldHandler", true,
      "Call previous signal handler"};
 
  Gaudi::Property<bool> m_dumpCoreFile{this, "DumpCoreFile", false,
      "Produce a core dump file if resource limits (ulimit -c) allow"};
 
  Gaudi::Property<bool> m_stackTrace{this, "StackTrace", false,
      "Produce (gdb) stack trace on crash. Useful if no other signal handler is used"};
 
  Gaudi::Property<bool> m_fastStackTrace{this, "FastStackTrace", false,
      "Produce fast stack trace of current thread"};
 
  Gaudi::Property<std::string> m_coreDumpStream{this, "CoreDumpStream", "stdout",
      "Stream to use for core dump [stdout,stderr]"};
 
  Gaudi::Property<int> m_fatalHandlerFlags{this, "FatalHandler", 0, 
      "Flags given to the fatal handler this service installs\n"
      "if the flag is zero, no additional fatal handler is installed."};
 
  Gaudi::Property<double> m_timeout{this, "TimeOut", 30.0*60*1e9,
      "Terminate job after it this reaches the time out in Wallclock time, "
      "usually due to hanging during stack unwinding. Timeout given in nanoseconds despite seconds precision"};
 
  Gaudi::Property<bool> m_killOnSigInt{this, "KillOnSigInt",true, "Terminate job on SIGINT (aka Ctrl-C)"};
 
       

  void propertyHandler ATLAS_NOT_THREAD_SAFE (Gaudi::Details::PropertyBase& p);

  void print ATLAS_NOT_THREAD_SAFE ();
  
  void setSigInfo(siginfo_t* info) { m_siginfo = info; }  
  
  StatusCode installSignalHandler ATLAS_NOT_THREAD_SAFE ();
  
  StatusCode uninstallSignalHandler ATLAS_NOT_THREAD_SAFE ();

  void setAltStack();
}; 
 
 
#endif