Athena Namespace Reference

Some weak symbol referencing magic... More...

Namespaces
	AlgorithmTimerHandler
	detail
	details
	DsoUtils
	Options
	Units

Classes
class	AlgorithmTimer
	Timer that invokes a user callback once the time is reached. More...
struct	BitTraits
	Describe the bit features of an integral type T. More...
class	Callback1
class	Callback1Rep
class	CallbackImpF11
class	Chrono
	Exception-safe IChronoSvc caller. More...
class	ConditionsCleanerSvc
	Facade class for conditions garbage collection. More...
class	CondObjDeleter
	Deletion object for conditions payloads. More...
class	DataBucketBranch
class	DBLock
	Common database lock. More...
class	DebugAids
	Utilities for debugging support. More...
class	DelayedConditionsCleanerSvc
	Clean conditions containers after a delay. More...
class	DelayedConditionsCleanerSvcProps
class	DvThinningHdlr
	Handle DataProxy holding DataVector. This class defines a (type-safe) protocol to pack and unpack thinned DataVector. More...
struct	get_thinning_handler
	metafunction to automagically dispatch on the type of a container and fetch the right thinning handler More...
class	IConditionsCleanerSvc
	Interface for doing garbage collection of conditions objects. More...
class	IdcThinningHdlr
	Handle DataProxy holding IdentifiableContainer This class defines a (type-safe) protocol to pack and unpack thinned IdentifiableContainer. More...
class	IInputRename
	Interface to retrieve input rename map. More...
class	IMessageSvcHolder
	get a IMessageSvc* on 1st use (if not set) and release it on ~ More...
class	IRCUObject
	Base object class for RCU-style synchronization for Athena. More...
class	IRCUSvc
	Interface for RCU service. More...
class	ISlimmingHdlr
	This class defines a protocol to slim objects (removing parts of that object) More...
class	IThinningHdlr
	This class defines a protocol to pack and unpack thinned collections. More...
class	LeafCnv
class	NtupleCnvSvc
class	PerfMonAuditor
class	RCUObject
	Wrapper object controlled by RCU synchonization. More...
class	RCURead
	Helper to read data from a RCUObject. More...
class	RCUReadQuiesce
	Helper to read data from a RCUObject. More...
class	RCUSvc
	Service to allow cleaning up RCU objects at the EndEvent. More...
class	RCUUpdate
	Helper to update data in a RCUObject. More...
class	RCUUpdater
	Implementation of Updater for RCUSvc. More...
class	RecyclableDataObject
	Helper for recycling objects from event to event. More...
class	RecyclableDataQueue
	Holder for recyclable objects. More...
class	RootAsciiDumperAlg
class	RootAsciiDumperAlgHandle
class	RootBranchAddress
class	RootCnv
	This class provides the abstract converter to translate an object to/from its persistent ROOT representation. More...
class	RootCnvSvc
	This class provides the interface between Athena and RootSvc. More...
class	RootConnection
	This class provides the implementation of Athena::RootConnection class, similar to Gaudi IDataConnection. More...
class	RootGlobalsRestore
class	RootNtupleEventContext
class	RootNtupleEventSelector
	Class implementing the GAUDI IEvtSelector interface using ROOT TTree as a backend. More...
class	RootNtupleOutputMetadataTool
	This is the AthenaRoot version of AthenaServices/AthenaOutputStreamTool. More...
class	RootNtupleOutputStream
	algorithm that marks for write data objects in SG More...
class	RootOutputStreamTool
	This is the AthenaRoot version of AthenaServices/AthenaOutputStreamTool. More...
class	RootSvc
	This class provides the interface to the ROOT software. More...
class	ScopedTimer
	Helper class to create a "scoped cook timer" without having to declare the CookTimer itself within the scope (see CookTimer documentation) More...
class	SharedLibrary
	Shared library services. More...
class	SharedLibraryError
	Error in a shared library operation. More...
class	Signal
	Utilities for handling signals and fatal errors. More...
struct	StatusCategory
class	StdThinningHdlr
	Handle DataProxy holding std::vector<T> This class defines a (type-safe) protocol to pack and unpack thinned DataVector. More...
class	ThinningCacheTool
	Create ThinningCache for a given stream. More...
class	Timeout
	Singleton to access the timeout flag. More...
class	TimeoutMaster
	Class to modify timeout flag. More...
class	ToolLock
	RAII helper for acquiring the lock of an ILockableTool. More...
struct	TPCnvType
struct	TPCnvVers
class	xAODBranchAddress
class	xAODCnv
class	xAODCnvSvc
class	xAODEventContext
class	xAODEventSelector
	Class implementing the GAUDI IEvtSelector interface using ROOT TTree as a backend. More...

Typedefs
typedef void(*	DummyHandlerType) (int)
	Dummy handler type for standard signal() function. More...
typedef RootNtupleEventContext::FileNames_t	FileNames_t

Enumerations
enum	Status : StatusCode::code_t { Status::TIMEOUT = 10, Status::MISSING_DATA = 11 }
	Athena specific StatusCode values. More...

Functions
IMessageSvc *	getMessageSvc (bool quiet=false)
IMessageSvc *	getMessageSvc (const Options::CreateOptions o, bool quiet=false)
void	reportMessage (IMessageSvc *ims, const std::string &source, int type, const std::string &message)
	Wrappers for some of the IMessageSvc methods These can be used from libraries without explicit Gaudi dependency via weak linking. More...
int	outputLevel (const IMessageSvc *ims, const std::string &source)
void	setOutputLevel (IMessageSvc *ims, const std::string &source, int level)
int	ubsan_boost_suppress ()
template<class T1 , class T2 >
Callback1Rep< T1 > *	CreateCallback (void(*function)(T1, T2), const T2 &fill_2)
void DebugAids::stacktraceLine	ATLAS_NOT_THREAD_SAFE (IOFD fd, unsigned long addr)
	Write out stack trace line to FD. More...
void DebugAids::setStackTraceAddr2Line	ATLAS_NOT_THREAD_SAFE (const char *path)
void DebugAids::stacktrace	ATLAS_NOT_THREAD_SAFE (IOFD fd)
	Produce a stack trace. More...
void SharedLibrary::path	ATLAS_NOT_THREAD_SAFE (const std::string &path)
void Signal::handleQuit	ATLAS_NOT_THREAD_SAFE (QuitHook hook)
void Signal::handleFatal	ATLAS_NOT_THREAD_SAFE (const char *applicationName, IOFD fd, FatalHook hook, FatalReturn mainreturn, unsigned options)
	Install default handler for fatal signals. More...
void Signal::quit	ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *x)
	The quit signal handler. More...
bool Signal::fatalDump	ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *extra, IOFD fd, unsigned options)
IOFD Signal::handleFatalFd	ATLAS_NOT_THREAD_SAFE (void)
	Return the file descriptor #fataldump() uses for output. More...

Variables
std::atomic< bool >	getMessageSvcQuiet
	Set this to force off the warning messages from getMessageSvc (in unit tests, for example). More...
int	ubsan_boost_suppress_ = ubsan_boost_suppress()

Detailed Description

Some weak symbol referencing magic...

These are declared in AthenaKernel/getMessageSvc.h and will be non-nullptr in case the GaudiSvc/AthenaKernel shared libraries have been loaded.

Typedef Documentation

DummyHandlerType

typedef void(* Athena::DummyHandlerType) (int)

Dummy handler type for standard signal() function.

Definition at line 109 of file SealSignal.cxx.

FileNames_t

typedef RootNtupleEventContext::FileNames_t Athena::FileNames_t

Definition at line 213 of file RootNtupleEventSelector.cxx.

Enumeration Type Documentation

Status

enum Athena::Status : StatusCode::code_t

strong

Athena specific StatusCode values.

These can be used in place of Gaudi's StatusCode::XYZ if additional information should be returned. Some of these codes will result in special treatment of the event (e.g. sending them to the debug stream in the HLT).

Only generic return codes should be defined here. Algorithm-specific return values should be encoded in separate enums in the respective packages.

Enumerator
TIMEOUT	Timeout during event processing.
MISSING_DATA	Missing/corrupted input data.

Definition at line 22 of file AthStatusCode.h.

                  : StatusCode::code_t {
  TIMEOUT = 10,            
  MISSING_DATA = 11        
};

Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/9]

void Signal::handleFatal Athena::ATLAS_NOT_THREAD_SAFE	(	const char *	applicationName,
		IOFD	fd,
		FatalHook	hook,
		FatalReturn	mainreturn,
		unsigned	options
	)

Install default handler for fatal signals.

This method installs a handler for fatal signals such as floating point exceptions, illegal instructions, and memory violations. The behaviour is more precisely determined by options, a bitwise or of the option constants defined in the class declaration.

applicationName sets the application name to be used to report the signal in #fatalDump(). fd sets the file descriptor to which the fatal signal message is written; by default this will be the standard error output. hook sets the pre-exit application hook to invoke, mainreturn sets the hook to return to back to the application "main loop" (i.e. ignore the signal by jumping out of the signal back to the somewhere higher up in the application).

Options left to default values will not change the current state. This allows one to re-install signal handlers without disturbing already registered information. Use this to restore handlers after some other library has meddled with the handlers.

This installs #fatal() as the handler for fatal signals and on Windows for otherwise unhandled fatal structured exceptions. If #FATAL_ON_QUIT is included in options, quitting related signals (see #quit()) are also considered fatal. If #FATAL_ON_INT is set, SIGINT is considered fatal—but see also #fatal() documentation. If #USR1_DUMP_CORE is set, #DebugAids::coredump is registered as a handler for SIGUSR1 (please note the security risks of this option in its documentation).

A multi-threaded application should call this method in each thread. (FIXME: Calling this in one thread and blocking signals in others won't work on Linux, and in any case will probably produce nonsense stack traces (unless stacktrace can be fixed to dump the stacks of all the threads). Since the handler is always the same, I am not sure it will make the slightest difference which thread catches the signals, and on the other hand, it is best to dump the problems in the faulting thread if possible.)

Definition at line 646 of file SealSignal.cxx.

{
    // FIXME: Provide means to install handlers for fatal signals that
    // an application has requested and app was supposed to register a
    // handler before making the request?  (So that if the app handler
    // is not installed for some reason, an internal error hook can
    // run?)  Such fatal signals include:
    //   - SIGPIPE: read or write to broken pipe; child died
    //     (read or write to socket with ASYNC io?)
    //   - SIGLOST: lost a resource (e.g., lock on nfs server reboot)
    //   - SIGALRM: interval timer elapsed
    //   - SIGUSR1, SIGUSR2
    //   - SIGPOLL: pollable streams device events
    //   - SIGIO: i/o possible (from async i/o)
    //   - SIGVTALRM: virtual timer expired
    //   - SIGPROF: profiling timer expired
    //   - SIGRTMIN - SIGRTMAX: POSIX real-time signals
    //
    // Some of these the application should probably just #block()
    // (e.g. SIGPIPE).  Some of them the app should block and then
    // wait or poll for events (SIGPOLL, SIGIO, possibly SIGALRM, the
    // real-time signals if they are used).
 
    static const int hups [] = {
#ifdef SIGHUP
    SIGHUP,     // hang up (lost terminal or process group leader)
#endif
#ifdef SIGTERM
    SIGTERM,    // terminate (e.g. system going down)
#endif
#ifdef SIGQUIT
    SIGQUIT,    /* user request to quit and leave debuggable
               state (from quit key on controlling
               terminal) */
 
#endif
    -1
    };
 
    static int fatals [] = {
#ifdef SIGFPE
    SIGFPE,     // arithmetic exception
#endif
#ifdef SIGILL
    SIGILL,     // illegal instruction
#endif
#ifdef SIGSEGV
    SIGSEGV,    // illegal address
#endif
#ifdef SIGBUS
    SIGBUS,     // hardware exception
#endif
#ifdef SIGIOT
    SIGIOT,     /* IOT trap.  Before SIGABRT so that if SIGIOT
               == SIGABRT then SIGABRT overrides SIGIOT;
               SIGABRT is in ISO C and POSIX.1, SIGIOT is
               not. */
#endif
#ifdef SIGABRT
    SIGABRT,    // abort
 
#endif
#ifdef SIGTRAP
    SIGTRAP,    // trace/breakpoint reached
#endif
#ifdef SIGEMT
    SIGEMT,     // emulation trap (may be used by profiler?)
#endif
#ifdef SIGSYS
    SIGSYS,     // invalid system call
#endif
#ifdef SIGXCPU
    SIGXCPU,    // cpu time limit exceeded
#endif
#ifdef SIGXFSZ
    SIGXFSZ,    // file size limit exceeded
#endif
    -1
    };
 
    // Make sure `strsignal' is properly initialised.
    name (1);
 
    // Remember app name if specified
    if (applicationName && *applicationName)
    s_applicationName = applicationName;
 
    // Automatically initialise s_fatalFd on first access
    if (s_fatalFd == IOFD_INVALID)
    s_fatalFd = STDERR_HANDLE;
 
    // Remember the fatal output fd if defined
    if (fd != IOFD_INVALID)
    s_fatalFd = fd;
 
    // Now that we know the fd, setup a callback for dumping shared
    // libraries via #SignalDumpLibs.  This avoids having to allocate
    // memory for the callback implementation in the middle of a fatal
    // signal, and on the other hand avoids a global object which
    // might not be initialised yet.
    delete SignalDumpCallback;
    SignalDumpCallback = new SharedLibrary::InfoHandler
             (CreateCallback (&SignalDumpLibs, s_fatalFd));
 
    // Remember the hooks if specified
    if (hook)
    s_fatalHook = hook;
 
    if (mainreturn)
    s_fatalReturn = mainreturn;
 
    // Remember the new options
    s_fatalOptions = options;
 
    // Signal::fatal() requires this, otherwise weird things can happen.
    // Programs not wanting to return to main should set FATAL_AUTO_EXIT.
    assert (s_fatalReturn || (s_fatalOptions & FATAL_AUTO_EXIT));
 
    // Install signal handlers.
    if (options & FATAL_ON_QUIT)
    for (unsigned sig = 0; hups [sig] != -1; ++sig)
        handle (hups [sig], fatal);
 
    for (unsigned sig = 0; fatals [sig] != -1; ++sig)
    handle (fatals [sig], fatal);
 
#ifdef SIGINT
    // interrupt key from controlling terminal
    if (options & FATAL_ON_INT)
    handle (SIGINT, fatal);
#endif
 
#ifdef SIGUSR1
    // program-defined signals SIGUSR1 and SIGUSR2
    if (options & USR1_DUMP_CORE)
    handle (SIGUSR1, (HandlerType) DebugAids::coredump);
#endif
 
#ifdef _WIN32
    SetUnhandledExceptionFilter (&SEHFatal);
#endif
}

ATLAS_NOT_THREAD_SAFE() [2/9]

void DebugAids::setStackTraceAddr2Line Athena::ATLAS_NOT_THREAD_SAFE

(

const char *

path

)

Definition at line 578 of file SealDebug.cxx.

{
  addr2LinePath = path;
}

ATLAS_NOT_THREAD_SAFE() [3/9]

void SharedLibrary::path Athena::ATLAS_NOT_THREAD_SAFE

(

const std::string &

path

)

Definition at line 164 of file SealSharedLib.cxx.

{
    /* Do not free `var'; most implementations of `putenv' use the
       string without copying it.  On systems where `putenv' copies,
       you'll see leaks from this routine.  It would be possible to
       check for this, but only by killing cross-compilation.
 
       NB: `HAVE_COPYING_PUTENV' will never be set as we are not
       checking for it :-)  */
 
    const char *pathvar = PATH;
    if (pathvar) {
        const int path_size = strlen(pathvar) + 1 + path.length () + 1;
    char *var = (char *) malloc (path_size);
    snprintf (var, path_size, "%s=%s", pathvar, path.c_str ());
    putenv (var);
#if HAVE_COPYING_PUTENV
    free (var);
#endif
    }
}

ATLAS_NOT_THREAD_SAFE() [4/9]

bool Signal::fatalDump Athena::ATLAS_NOT_THREAD_SAFE	(	int	sig,
		siginfo_t *	info,
		void *	extra,
		IOFD	fd,
		unsigned	options
	)

Definition at line 1515 of file SealSignal.cxx.

{
    const unsigned int buf_size = sizeof (buf);
    bool haveCore = false;
    if (sig < 0)
    {
    sig = -sig;
    haveCore = true;
    }
 
    if (options & FATAL_DUMP_SIG)
    {
    MYWRITE (fd, "\n", 1);
    if (s_applicationName)
    {
        MYWRITE (fd, s_applicationName,
             STDC::strlen (s_applicationName));
        MYWRITE (fd, " ", 1);
    }
 
    MYWRITE (fd, buf,
         snprintf (buf, SIGNAL_MESSAGE_BUFSIZE, "(pid=%ld ppid=%ld) received fatal signal %d"
              " (%.100s)%s\n",
              (long) ProcessInfo__pid (), (long) ProcessInfo__ppid (), // wlav :: -> __ (x2)
              sig, name (sig), haveCore ? " (core dumped)" : ""));
 
    MYWRITE (fd, buf, snprintf(buf, buf_size, "signal context:\n"));
    dumpInfo (fd, buf, buf_size, sig, info);
    }
 
    unsigned long sp = 0;
    if (options & FATAL_DUMP_CONTEXT)
    sp = dumpContext (fd, buf, buf_size, extra);
 
    if (options & FATAL_DUMP_STACK)
    {
    MYWRITE (fd, buf, snprintf(buf, buf_size, "\nstack trace:\n"));
        if (s_lastSP) {
          MYWRITE (fd, buf, snprintf(buf, buf_size, "\n(backtrace failed; raw dump follows)\n"));
          MYWRITE (fd, buf, snprintf(buf, buf_size, "%016lx:", s_lastSP.load()));
          dumpMemory (fd, buf, buf_size, reinterpret_cast<void*>(s_lastSP.load()), 1024);
          MYWRITE (fd, buf, snprintf(buf, buf_size, "\n\n"));
        }
        else {
          s_lastSP = sp;
          DebugAids::stacktrace (fd);
        }
        s_lastSP = 0;
    }
 
    if (options & FATAL_DUMP_LIBS)
    {
    MYWRITE (fd, buf, snprintf(buf, buf_size, "\nshared libraries present:\n"));
    try { SharedLibrary::loaded (*SignalDumpCallback); }
    catch (...) { ; }
    }
 
    return true;
}

ATLAS_NOT_THREAD_SAFE() [5/9]

bool Signal::fatalDump Athena::ATLAS_NOT_THREAD_SAFE	(	int	sig,
		siginfo_t *	info,
		void *	x
	)

The quit signal handler.

The fatal signal handler.

This is the handler installed by #handleQuit(). Please use #handleQuit() and this method instead of installing your own handlers with #handle().

This handler first invokes the application hook if one was given to #handleQuit(). If the hook returns true, the signal handler for this signal (number sig) is reset to its default handler, and the signal is re-raised. This causes the program to exit via the signal and have a the correct exit status.

The application should do whatever is necessary for a graceful shutdown. Note however that this signal may arrive asynchronously at any time, hence it probably isn't safe to allocate memory, use the standard output streams, and so forth. What you can do is to set a flag, return false to return back to your application, detect the flag setting and drain your current event loop, and then quit. But do note that if #FATAL_AUTO_EXIT was set in call to #handleFatal(), #fatal() will call #quit() which in turn calls the application hook. Thus the hook should make sure it returns true if the application has crashed as noted in the documentation for <<QuitHook>>.

This is the handler installed by #handleFatal(). Please use #handleFatal() and this method instead of installing your handlers with #handle(). You should be able use the handler options to specify all the control you need.

The first thing this handler does is to reinstall itself for the benefit of platforms with single-delivery signals. Immediately after that it unblocks the delivery of that signal again, in case the signal handler itself gets in trouble. The next step is to check if the current crash level (the recursion of calls to #fatal(), see #fatalLevel()) exceeds the predefined limit of 4; if so, we give up and let the application die with this this signal. The handler then determines whether the signal is fatal: everything except SIGINT is, and SIGINT is fatal if #FATAL_ON_INT was set. If the signal is fatal, crash indicator is set (see #crashed()).

If this is not a nested fatal signal, the signal is fatal, and #FATAL_DUMP_CORE is set, the handler tries dump a core file. Then the handler will either attempt to quit or to return to the main program depending on #FATAL_AUTO_EXIT option setting. If it is set or this is a nested fatal signal, the handler will attempt to exit as follows: the application hook (or #fatalDump() in its absence) is invoked. If the hook returns true, #quit() is called; otherwise the signal handler will return (and crash or get an infinite sequence of fatal signals). Note that if an application hook is registered, #fataldump() is not called by default; the application hook must invoke it itself to get the dump.

If #FATAL_AUTO_EXIT is not set, the application must have registered a main return hook, which will be invoked. The hook must not return, but do a siglongjmp back to the main program (it should not throw unless all code is built with options that allow exceptions to be thrown from signal handlers). Note that the fatal signal may be asynchronous and may have arisen in code left in unsafe state, so returning back to the main program may not buy you much. It may make sense for a few things like rogue null pointer dereferences or floating point exceptions.

An interactive application using a main return hook should do something like this when the sigsetjmp in the main loop returns:

• disable "main loop entered" status
• inform the user about the fatal error (e.g. with a popup); the popup window should be precreated for best stability
• reset any locks the application holds, especially for user interface, including status bars, wait icons etc.
• suggest to run a debugger against the program right there
• in a windowing system ungrab pointer, keyboard and the server
• unblock the signal via #block(sig, false) as the operating system may think the signal is still being processed
• add an idle processor to re-return the "main loop entered" once all pending event queue events have been drained
• go onto processing gui events

Using a main return will most likely leak memory like a sieve, but in balance, the application just got a fatal signal and the leak is unlikely to be the greatest concern.

Definition at line 817 of file SealSignal.cxx.

{
    // Quit if no hook has been registered: we are coming in via
    // FATAL_AUTO_EXIT in fatal and the application did not call
    // handleQuit.
    if (! s_quitHook || (*s_quitHook) (sig, info, x))
    {
    // Reactivate the default signal handling behaviour for this
    // signal, which is to terminate the application one way or
    // the other.  Then exit through the signal.  This makes the
    // process exit status correct.
    revert (sig);
    raise (sig);
    }
}

ATLAS_NOT_THREAD_SAFE() [6/9]

void DebugAids::stacktrace Athena::ATLAS_NOT_THREAD_SAFE

(

IOFD

fd

)

Produce a stack trace.

Prints the current stack trace to file descriptor fd or if the default invalid descriptor, the currently registered stack trace descriptor as registered with #stacktraceFd(). Avoids unnecessary memory allocation so it should be safe to call this function even in dire situations. On some systems the implementation always outputs to the standard error and has no means for redirection. On these systems an attempt is made to redirect standard error momentarily elsewhere and then redirect standard error to the desired file descriptor, invoke the output, and redirect standard error back to its original location. If the redirection fails or the system has no stack tracing support, no stack trace is produced.

Definition at line 633 of file SealDebug.cxx.

{
    if (fd == IOFD_INVALID)
      fd = stacktraceFd();
 
    std::cerr.flush ();
    fflush (stderr);
 
#ifdef _WIN32
    // FIXME: Autoload all these functions so users don't need to
    // link in imagehlp.dll.
    if (! SymInitialize (GetCurrentProcess (), NULL, TRUE))
    {
    MYWRITELIT (fd, ("failed to dump stack trace:"
             " cannot get symbolic information\n"));
    return;
    }
 
    union SYMBUFFER {
    IMAGEHLP_SYMBOL sym;
    BYTE        buffer [ sizeof (IMAGEHLP_SYMBOL) + 512 ];
    };
 
    unsigned        level = 0;
    CONTEXT     context;
    STACKFRAME      frame;
    SYMBUFFER       symbol;
    IMAGEHLP_MODULE module;
    char        modulename [MAX_PATH];
    DWORD       section;
    DWORD       offset;
    const int       buf_size = 2*40+6;   // ample for two 128+ bit numbers
    char        buf [buf_size];
    // DWORD        exceptargs [] = { (DWORD) &context };
 
    // FIXME: XP 64-bit adds: RtlCaptureContext (&context);
    // This is documented to *not* work, but apparently it does.
    context.ContextFlags = CONTEXT_FULL;
    if (! GetThreadContext (GetCurrentThread (), &context))
    return;
 
    // LPTOP_LEVEL_EXCEPTION_FILTER oldseh
    //  = SetUnhandledExceptionFilter (&GrabExceptionContext);
    // RaiseException (0, 0, 1, exceptargs);
    // SetUnhandledExceptionFilter (oldseh);
 
    memset (&module, 0, sizeof (module));
    memset (&frame, 0, sizeof (frame));
 
    module.SizeOfStruct     = sizeof (module);
 
    frame.AddrPC.Offset     = context.Eip;
    frame.AddrPC.Mode       = AddrModeFlat;
    frame.AddrStack.Offset  = context.Esp;
    frame.AddrStack.Mode    = AddrModeFlat;
    frame.AddrFrame.Offset  = context.Ebp;
    frame.AddrFrame.Mode    = AddrModeFlat;
 
    while (true)
    {
    if (! StackWalk (IMAGE_FILE_MACHINE_I386,
             GetCurrentProcess (),
             GetCurrentThread (),
             &frame,
             &context,
             NULL,
             SymFunctionTableAccess,
             SymGetModuleBase,
             NULL)
        || frame.AddrFrame.Offset == 0)
        break;
 
    // FIXME: Throw away everything above stacktrace?  Keep looping
    // below until the name includes something we understand?
 
    // Print stack frame too?  If we know how many arguments there
    // are (from demangling function name -- see below, could count
    // commas), args are: *((ULONG *)frame.AddrFrame.Offset+2+ARG).
    MYWRITE (fd, buf, snprintf (buf, buf_size, "(%2u) 0x%08lx 0x%08lx   ",
                    level, frame.AddrPC.Offset,
                    frame.AddrFrame.Offset));
 
    memset (&symbol, 0, sizeof (symbol));
    symbol.sym.SizeOfStruct = sizeof (symbol);
    symbol.sym.MaxNameLength = sizeof (symbol) - sizeof (symbol.sym);
 
    offset = 0;
    if (SymGetSymFromAddr (GetCurrentProcess (), frame.AddrPC.Offset,
                   &offset, &symbol.sym))
    {
        // FIXME: Demangle name with:
        //   UnDecorateSymbolName (name, undecname, sizeof (undecname),
        //              UNDNAME_COMPLETE
        //              | UNDNAME_NO_THISTYPE
        //              | UNDNAME_NO_SPECIAL_SYMS
        //              | UNDNAME_NO_MEMBER_TYPE
        //              | UNDNAME_NO_MS_KEYWORDS
        //              | UNDNAME_NO_ACCESS_SPECIFIERS);
        MYWRITE (fd, symbol.sym.Name, STDC::strlen (symbol.sym.Name));
        MYWRITE (fd, buf, snprintf (buf, buf_size, " + %lx", offset));
 
        if (SymGetModuleInfo (GetCurrentProcess(), frame.AddrPC.Offset,
                  &module))
        {
        MYWRITELIT (fd, " [");
        MYWRITE (fd, module.ImageName,
             STDC::strlen (module.ImageName));
        MYWRITELIT (fd, "]");
        }
    }
    else
    {
        GetLogicalAddress ((PVOID) frame.AddrPC.Offset,
                   modulename, sizeof (modulename),
                   section, offset);
        MYWRITE (fd, buf, snprintf (buf, buf_size, "%04lx:%08lx [", section, offset));
        MYWRITE (fd, modulename, STDC::strlen (modulename));
        MYWRITELIT (fd, "]");
    }
    MYWRITELIT (fd, "\n");
    ++level;
    }
    SymCleanup (GetCurrentProcess ());
 
#elif (HAVE_U_STACK_TRACE || HAVE_XL_TRBK)      // hp-ux, aix
    // FIXME: deal with inability to duplicate the file handle
    int stderrfd = dup (STDERR_FILENO);
    if (stderrfd == -1)
    return;
 
    int newfd    = dup2 (fd, STDERR_FILENO);
    if (newfd == -1)
    {
    close (stderrfd);
    return;
    }
 
# if HAVE_U_STACK_TRACE     // hp-ux
    U_STACK_TRACE ();
# elif HAVE_XL_TRBK     // aix
    xl__trbk ();
# else
#  error "oops, you shouldn't have gotten here!"
# endif
 
    fflush (stderr);
    dup2 (stderrfd, STDERR_FILENO);
    close (newfd);
#elif HAVE_LINUX_UNWIND_BACKTRACE
    CxxUtils::backtraceByUnwind (stacktraceLine, fd);
 
#elif HAVE_BACKTRACE_SYMBOLS_FD && HAVE_DLADDR      // linux
    // we could have used backtrace_symbols_fd, except its output
    // format is pretty bad, so recode that here :-(
    void        *trace [MAX_BACKTRACE_DEPTH];
    int         depth = backtrace (trace, MAX_BACKTRACE_DEPTH);
 
    for (int n = 0; n < depth; ++n/*, nbufs = 0*/)
    {
    unsigned long   addr = (unsigned long) trace [n];
        stacktraceLine (fd, addr);
    }
 
#elif HAVE_EXCPT_H && HAVE_PDSC_H && HAVE_RLD_INTERFACE_H // tru64
    // Tru64 stack walk.  Uses the exception handling library and the
    // run-time linker's core functions (loader(5)).  FIXME: Tru64
    // should have _RLD_DLADDR like IRIX below.  Verify and update.
 
    const int   buffer_size = 100 + BitTraits<unsigned long>::HexDigits * 2 + 11;
    char    buffer [buffer_size];
    sigcontext  context;
    int     rc = 0;
 
    exc_capture_context (&context);
    while (!rc && context.sc_pc)
    {
    // FIXME: Elf32?
    pdsc_crd *func, *base, *crd
      = exc_remote_lookup_function_entry(0, 0, context.sc_pc, 0, &func, &base);
    Elf32_Addr addr = PDSC_CRD_BEGIN_ADDRESS(base, func);
    // const char *name = _rld_address_to_name(addr);
    const char *name = "<unknown function>";
    snprintf (buffer, buffer_size, " 0x%012lx %.100s + 0x%lx\n",
          context.sc_pc, name, context.sc_pc - addr);
    write (fd, buffer, STDC::strlen(buffer));
    rc = exc_virtual_unwind(0, &context);
    }
 
#elif HAVE_EXCEPTION_H && defined __sgi         // irix
    // IRIX stack walk -- like Tru64 but with a little different names.
    // NB: The guard above is to protect against unrelated <exception.h>
    //   provided by some compilers (e.g. KCC 4.0f).
    // NB: libexc.h has trace_back_stack and trace_back_stack_and_print
    //   but their output isn't pretty and nowhere as complete as ours.
    char       buffer [340];
    sigcontext context;
 
    exc_setjmp (&context);
    while (context.sc_pc >= 4)
    {
    // Do two lookups, one using exception handling tables and
    // another using _RLD_DLADDR, and use the one with a smaller
    // offset.  For signal handlers we seem to get things wrong:
    // _sigtramp's exception range is huge while based on Dl_info
    // the offset is small -- but both supposedly describe the
    // same thing.  Go figure.
    char            *name = 0;
    const char      *libname = 0;
    const char      *symname = 0;
    Elf32_Addr      offset = ~0L;
 
    // Do the exception/dwarf lookup
    Elf32_Addr      pc = context.sc_pc;
    Dwarf_Fde       fde = find_fde_name (&pc, &name);
    Dwarf_Addr      low_pc = context.sc_pc;
    Dwarf_Unsigned  udummy;
    Dwarf_Signed    sdummy;
    Dwarf_Ptr       pdummy;
    Dwarf_Off       odummy;
    Dwarf_Error     err;
 
    symname = name;
 
    // Determine offset using exception descriptor range information.
    if (dwarf_get_fde_range (fde, &low_pc, &udummy, &pdummy, &udummy,
                 &odummy, &sdummy, &odummy, &err) == DW_DLV_OK)
        offset = context.sc_pc - low_pc;
 
       // Now do a dladdr() lookup.  If the found symbol has the same
       // address, trust the more accurate offset from dladdr();
       // ignore the looked up mangled symbol name and prefer the
       // demangled name produced by find_fde_name().  If we find a
       // smaller offset, trust the dynamic symbol as well.  Always
       // trust the library name even if we can't match it with an
       // exact symbol.
    Elf32_Addr      addr = context.sc_pc;
    Dl_info         info;
 
    if (_rld_new_interface (_RLD_DLADDR, addr, &info))
    {
        if (info.dli_fname && info.dli_fname [0])
        libname = info.dli_fname;
 
        Elf32_Addr symaddr = (Elf32_Addr) info.dli_saddr;
        if (symaddr == low_pc)
        offset = addr - symaddr;
        else if (info.dli_sname
             && info.dli_sname [0]
             && addr - symaddr < offset)
        {
        offset = addr - symaddr;
        symname = info.dli_sname;
        }
    }
 
    // Print out the result
    if (libname && symname)
            write (fd, buffer, snprintf
           (buffer, buffer_size, " 0x%012lx %.100s + 0x%lx [%.200s]\n",
            addr, symname, offset, libname));
    else if (symname)
        write (fd, buffer, snprintf
           (buffer, buffer_size, " 0x%012lx %.100s + 0x%lx\n",
            addr, symname, offset));
    else
        write (fd, buffer, snprintf
           (buffer, buffer_size, " 0x%012lx <unknown function>\n", addr));
 
    // Free name from find_fde_name().
    free (name);
 
    // Check for termination.  exc_unwind() sets context.sc_pc to
    // 0 or an error (< 4).  However it seems we can't unwind
    // through signal stack frames though this is not mentioned in
    // the docs; it seems that for those we need to check for
    // changed pc after find_fde_name().  That seems to indicate
    // end of the post-signal stack frame.  (FIXME: Figure out how
    // to unwind through signal stack frame, e.g. perhaps using
    // sigcontext_t's old pc?  Or perhaps we can keep on going
    // down without doing the symbol lookup?)
    if (pc != context.sc_pc)
        break;
 
    exc_unwind (&context, fde);
    }
 
#elif defined PROG_PSTACK               // solaris
# ifdef PROG_CXXFILT
#  define CXXFILTER " | " PROG_CXXFILT
# else
#  define CXXFILTER
# endif
    // 64 should more than plenty for a space and a pid.
    const int buffer_size = sizeof(PROG_PSTACK) + 1 + BitTraits<unsigned long>::Digits
                 + 3 + sizeof(PROG_CXXFILT) + BitTraits<int>::Digits + 1;
    char buffer [buffer_size];
    snprintf (buffer, buffer_size, "%s %lu%s 1>&%d", PROG_PSTACK, (unsigned long) getpid (),
         "" CXXFILTER, fd);
    system (buffer);
# undef CXXFILTER
 
#elif __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
    // FIXME: Check for _Unwind*, compilers other than GCC support this API
    _Unwind_Backtrace (unwindWalkStack, &fd);
#endif
 
    // FIXME: mpatrol has some generic unix unwind code.
    // FIXME: from unix faq: ask debugger to dump stack trace
    // with something like:
    //   - gdb: echo "thread apply all where\nwhere\ndetach" | gdb $prog $pid
    //   - dbx: echo "where\ndetach" | dbx -a $program_path $pid
    //   - dbx (aix): echo "where\ndetach" | dbx -p $program_path $pid
}

ATLAS_NOT_THREAD_SAFE() [7/9]

void DebugAids::stacktraceLine Athena::ATLAS_NOT_THREAD_SAFE	(	IOFD	fd,
		unsigned long	addr
	)

Write out stack trace line to FD.

IP is the instruction pointer. (sss)

Definition at line 328 of file SealDebug.cxx.

{
  iovec     bufs [7];
  int       nbufs = 0;
  const int     addrbuf_size = 5 + BitTraits<unsigned long>::HexDigits;
  char      addrbuf [addrbuf_size];
 
#if HAVE_BACKTRACE_SYMBOLS_FD && HAVE_DLADDR
  const int     diffbuf_size = 15 + BitTraits<unsigned long>::HexDigits;
  char      diffbuf [diffbuf_size];
  static const char trailer [] = "]\n";
  Dl_info       info;
 
  if (dladdr ((void*)addr, &info) && info.dli_fname && info.dli_fname[0])
  {
    const char *libname = info.dli_fname;
           
    unsigned long   symaddr = (unsigned long) info.dli_saddr;
    bool        gte = (addr >= symaddr);
    unsigned long   diff = (gte ? addr - symaddr : symaddr - addr);
 
    // RS start
    int length = 0;
    
    const int     relbuf_size = 7 + BitTraits<unsigned long>::HexDigits;
    char      relbuf [relbuf_size];
    
    // difference of two pointers
    unsigned long libaddr = (unsigned long) info.dli_fbase;
    unsigned long relative_address = (addr >= libaddr) ? addr - libaddr : libaddr - addr;
    // ELF executables are usually not relocatable, and on 64-bit platforms
    // are usually loaded starting at 0x400000.  In that case, we should _not_
    // subtract the base address.  But clang15 by default appears to produce
    // position-independent executables (PIE) by default.  In that case,
    // we do need to subtract the offset.
    // I'm not sure how to reliably tell the difference short of parsing
    // the object headers.  For now, just assume that something
    // that doesn't have .so in the name and is loaded at 0x400000
    // is not relocatable.  This is not really portable, though.
    if (strstr (info.dli_fname, ".so") == 0 && libaddr == 0x400000)
      relative_address = addr;
 
    // need popen for addr2line ...
    int pfd;
    pid_t child_pid;
    char line[ LINE_MAX ];
    char dembuf[ LINE_MAX ];
    const char* symname = dembuf;
    size_t demlen = 0;
 
    // did we find valid entry ?
    size_t len = strlen(info.dli_fname);
    if ( len > 0 && len + 80 < LINE_MAX)
    {
      if (getenv ("LD_PRELOAD"))
        unsetenv ("LD_PRELOAD");
 
      if ( addr2LinePath == "/usr/bin/eu-addr2line" )
    {
      snprintf (line, LINE_MAX, "%s -f -e %s %p | /usr/bin/c++filt | /usr/bin/tr \\\\012 \\\\040 ",
            addr2LinePath.c_str(),
            info.dli_fname,
            (void*)relative_address); 
    }
      else
    {
      snprintf (line, LINE_MAX, "%s -f -C -e %s %p",
            addr2LinePath.c_str(),
            info.dli_fname,
            (void*)relative_address);
    }
 
      pfd = stacktracePopenFD( line, child_pid );
 
      length = 1;
      line[0] = ' ';
 
      // did we succeed to open the pipe?
      if ( pfd >= 0 )
      {
        demlen = stacktraceReadline (pfd, dembuf, sizeof(dembuf));
 
        length = stacktraceReadline (pfd, line+1, sizeof(line)-1);
        if (length >= 0) ++length;
 
        int stat = stacktracePcloseFD (pfd, child_pid);
 
        // don't print anything, if nothing is found
        if ( stat || line[1] == '?' || length < 0)
        {
          line[1] = '\0';
          length = 0;
        }
 
    if ( stat || demlen <= 0 || dembuf[0] == '?') {
          symname = info.dli_sname;
          if (!symname) symname = "???";
          demlen = strlen (symname);
        }
 
      }
    }
    // RS end
 
    bufs [nbufs].iov_base = addrbuf;
    bufs [nbufs].iov_len  = snprintf (addrbuf, addrbuf_size, " 0x%08lx ", addr);
    ++nbufs;
 
    bufs [nbufs].iov_base = (void *) symname; // discard const
    bufs [nbufs].iov_len  = demlen;
    ++nbufs;
 
    // RS start
    bufs [nbufs].iov_base = line;
    bufs [nbufs].iov_len  = length;
    ++nbufs;
    // RS end
 
    bufs [nbufs].iov_base = diffbuf;
    bufs [nbufs].iov_len  = snprintf (diffbuf, diffbuf_size, " %c 0x%lx [",
                                      gte ? '+' : '-', diff);
    ++nbufs;
 
    bufs [nbufs].iov_base = (void *) libname; // discard const
    bufs [nbufs].iov_len  = strlen (libname);
    ++nbufs;
 
    // RS start
    bufs [nbufs].iov_base = relbuf;
    bufs [nbufs].iov_len  = snprintf( relbuf, relbuf_size, " D[%p]", (void*)relative_address );
    ++nbufs;
    // RS end
 
    bufs [nbufs].iov_base = (void *) trailer; // discard const
    bufs [nbufs].iov_len  = 2;
    ++nbufs;
 
  }
  else
#endif
  {
    bufs [nbufs].iov_base = addrbuf;
    bufs [nbufs].iov_len  = snprintf (addrbuf, addrbuf_size, " 0x%08lx ", addr);
    ++nbufs;
    
    bufs [nbufs].iov_base = (void *) "<unknown function>\n"; //no const
    bufs [nbufs].iov_len  = 19;
    ++nbufs;
  }
 
  writev (fd, bufs, nbufs);
}

ATLAS_NOT_THREAD_SAFE() [8/9]

void Signal::handleQuit Athena::ATLAS_NOT_THREAD_SAFE

(

QuitHook

hook

)

Definition at line 581 of file SealSignal.cxx.

{
    static int hups [] = {
#ifdef SIGHUP
    // hang up (lost terminal or process group leader)
    SIGHUP,
#endif
#ifdef SIGTERM
    // terminate (e.g. system going down)
    SIGTERM,
#endif
#ifdef SIGQUIT
    // user request to quit and leave debuggable state (from quit
    // key on controlling terminal)
    SIGQUIT,
#endif
    -1
    };
 
    if (hook)
    s_quitHook = hook;
 
    for (unsigned sig = 0; hups [sig] != -1; ++sig)
    handle (hups [sig], quit);
}

ATLAS_NOT_THREAD_SAFE() [9/9]

bool Signal::crashed Athena::ATLAS_NOT_THREAD_SAFE

(

void

)

Return the file descriptor #fataldump() uses for output.

Return the crash status indicator: true if a fatal signal has been received since the program started.

Return the depth to which #fatal() is currently recursively entered, or zero if #fatal() is not currently active.

Return the current application quit signal hook.

Return the current fatal signal handling options.

Return the application fatal signal return hook.

Return the application fatal signal hook.

Registered through #handleFatal().

Registered through #handleFatal().

See also

#fatal()

Registered through #handleFatal().

See also

#fatal().

Set on invocation to #handleFatal().

Registered through #handleQuit().

Use this method in application fatal hook to decide which operations are safe to perform. For example, if the attempts to notify the user result in further signals, it is best to avoid such attempts at deeper recursion levels. Currently #fatal() ceases to call the application's hooks and forces termination if the nesting level reaches 4.

Set if #fatal() is entered with a fatal signal.

Definition at line 1580 of file SealSignal.cxx.

{
    // Automatically initialise on first access.
    if (s_fatalFd == IOFD_INVALID)
    s_fatalFd = STDERR_HANDLE;
 
    return s_fatalFd;
}

CreateCallback()

template<class T1 , class T2 >

Callback1Rep<T1>* Athena::CreateCallback ( void(*)(T1, T2)  function, const T2 &  fill_2  )

inline

Definition at line 136 of file SealSharedLib.h.

{ return new CallbackImpF11<T1,T2> (function, fill_2); }

getMessageSvc() [1/2]

IMessageSvc * Athena::getMessageSvc

(

bool

quiet = false

)

Definition at line 20 of file getMessageSvc.cxx.

{ return getMessageSvc( Options::Lazy, quiet ); }

getMessageSvc() [2/2]

IMessageSvc * Athena::getMessageSvc	(	const Options::CreateOptions	o,
		bool	quiet = false
	)

Definition at line 21 of file getMessageSvc.cxx.

                                                                               {
 
  // We cache the MessageSvc, but only once it has been found. This ensures that an
  // early call to this method (before MessageSvc is available) does not prevent
  // from finding it in subsequent calls. The limited use of ServiceHandle for this
  // purpose should be thread-safe:
  static ServiceHandle<IMessageSvc> msgSvc ATLAS_THREAD_SAFE ("MessageSvc", "getMessageSvc");
 
  if (msgSvc.get()) {
    msgSvc->addRef();  // even if cached, maintain correct ref-count
  }
  else {
    const bool warn = !(quiet || Athena::getMessageSvcQuiet);
    if ( ((opt==Athena::Options::Lazy && !Gaudi::svcLocator()->existsService("MessageSvc")) ||
          msgSvc.retrieve().isFailure()) && warn ) {
      std::cerr << "Athena::getMessageSvc: WARNING MessageSvc not found, will use std::cout" << std::endl;
    }
  }
 
  return msgSvc.get();
}

outputLevel()

int Athena::outputLevel	(	const IMessageSvc *	ims,
		const std::string &	source
	)

Definition at line 47 of file getMessageSvc.cxx.

                                                                       {
  if (ims) return ims->outputLevel(source);
  else return MSG::INFO;
}

reportMessage()

void Athena::reportMessage	(	IMessageSvc *	ims,
		const std::string &	source,
		int	type,
		const std::string &	message
	)

Wrappers for some of the IMessageSvc methods These can be used from libraries without explicit Gaudi dependency via weak linking.

(see e.g. TrigConf::MsgStream in TrigConfBase)

DO NOT MODIFY THE SIGNATURE OF THESE METHODS WITHOUT UPDATING THE TRIGCONF SIDE !!!

Definition at line 43 of file getMessageSvc.cxx.

                                                                                                         {
  if (ims) ims->reportMessage(source, type, message);
}

setOutputLevel()

void Athena::setOutputLevel	(	IMessageSvc *	ims,
		const std::string &	source,
		int	level
	)

Definition at line 52 of file getMessageSvc.cxx.

                                                                                {
  if(ims) ims->setOutputLevel(source, level);
}

ubsan_boost_suppress()

int Athena::ubsan_boost_suppress

(

)

Definition at line 21 of file ubsan_boost_suppress.cxx.

{
  // See <https://svn.boost.org/trac/boost/ticket/11632>
  CxxUtils::ubsan_suppress ([]() { boost::format("%1%") % "asd"; });
  return 0;
}

Variable Documentation

getMessageSvcQuiet

std::atomic< bool > Athena::getMessageSvcQuiet

Set this to force off the warning messages from getMessageSvc (in unit tests, for example).

Definition at line 18 of file getMessageSvc.cxx.

ubsan_boost_suppress_

int Athena::ubsan_boost_suppress_ = ubsan_boost_suppress()

Definition at line 29 of file ubsan_boost_suppress.cxx.