---

IgTrace Class Reference

Core tracing implementation. More...

#include <IgTools/IgTrace/src/IgTrace.h>

List of all members.

Static Public Member Functions
static void	debug (const char *format,...)
	Internal printf()-like debugging utility.
static bool	disable (void)
	Disable the profiling system.
static bool	enable (void)
	Enable the profiling system.
static bool	enabled (void)
	Check if the profiler is currently enabled.
static bool	filter (const char *info, void *stack[], int depth)
	Walk the stack evaluating filters.
static bool	initialize (void)
	Initialise the tracing core itself.
static const char *	options (void)
	Get user-provided profiling options.
static int	panic (const char *file, int line, const char *func, const char *expr)
	Internal assertion helper routine.
static const char *	program (void)
	Return program name.

---

Detailed Description

Core tracing implementation.

Implements utilities needed to implement actual trace modules.

Definition at line 18 of file IgTrace.h.

---

Member Function Documentation

void IgTrace::debug	(	const char *	format,
			...
	)			[static]

Internal printf()-like debugging utility.

Produces output if $IGTRACE_DEBUGGING environment variable is set to any value.

Definition at line 212 of file IgTrace.cc.

References e.

Referenced by initialize(), IgTraceMem::initialize(), IgTraceThrow::initialize(), and IgTraceMMap::initialize().

{
    static const char *debugging = getenv ("IGTRACE_DEBUGGING");
    if (debugging)
    {
        timeval tv;
        gettimeofday (&tv, 0);
        fprintf (stderr, "*** IgTrace(%lu, %.3f): ",
                 (unsigned long) getpid(),
                 tv.tv_sec + 1e-6*tv.tv_usec);

        va_list args;
        va_start (args, format);
        vfprintf (stderr, format, args);
        va_end (args);
    }
}

bool IgTrace::disable

(

void

)

[static]

Disable the profiling system.

This is safe to call from anywhere, but note that profiling system will only be disabled, not locked. Use IgTraceLock instead if you need to manage exclusive access.

Returns true if the profiler was enabled before the call.

Definition at line 167 of file IgTrace.cc.

References IgTraceAtomicDec(), and s_enabled.

Referenced by domalloc(), IgTraceMem::initialize(), IgTraceThrow::initialize(), IgTraceMMap::initialize(), and panic().

{
    IgTraceAtomic newval = IgTraceAtomicDec (&s_enabled);
    return newval >= 0;
}

bool IgTrace::enable

(

void

)

[static]

Enable the profiling system.

This is safe to call from anywhere, but note that profiling system will only be enabled, not unlocked. Use IgTraceLock instead if you need to manage exclusive access.

Returns true if the profiler is enabled after the call.

Definition at line 155 of file IgTrace.cc.

References IgTraceAtomicInc(), and s_enabled.

Referenced by domalloc(), IgTraceMem::initialize(), IgTraceThrow::initialize(), IgTraceMMap::initialize(), and panic().

{
    IgTraceAtomic newval = IgTraceAtomicInc (&s_enabled);
    return newval > 0;
}

bool IgTrace::enabled

(

void

)

[static]

Check if the profiler is currently enabled.

This function should be called by asynchronous signal handlers to check whether they should record profile data -- not for the actual running where the value of the flag has little useful value, but to make sure no data is gathered after the system has started to close down.

Definition at line 144 of file IgTrace.cc.

References s_enabled.

{
    return s_enabled > 0;
}

bool IgTrace::filter	(	const char *	info,
		void *	stack[],
		int	depth
	)			[static]

Walk the stack evaluating filters.

Definition at line 239 of file IgTrace.cc.

References IgTraceFilter::extraInfo, f, IgTraceFilter::functionName, i, IgTraceFilter::libraryName, IgTraceFilter::nextFilter, and IgHookTrace::symbol().

Referenced by domalloc(), domunmap(), dothrow(), and mmapreport().

{
    bool pass = true;
    IgTraceFilter *f = s_filters;
    while (f && pass)
    {
        if (info && f->extraInfo && strstr (info, f->extraInfo))
            pass = false;

        for (int i = 0; i < depth && pass; ++i)
        {
            bool        passthis = true;
            const char  *sym = 0;
            const char  *lib = 0;
            int         junk = 0;
            
            if (! IgHookTrace::symbol (stack[i], sym, lib, junk, junk))
                continue;

            if (passthis && sym && f->functionName && strstr (sym, f->functionName))
                passthis = false;

            if (passthis && lib && f->libraryName && strstr (lib, f->libraryName))
                passthis = false;

            if (! passthis)
                pass = false;
        }

        f = f->nextFilter;
    }

    return pass;
}

bool IgTrace::initialize

(

void

)

[static]

Initialise the tracing core itself.

Prepares the the program for tracing. Automatically triggered to run on library load. All trace modules should invoke this method before doing their own initialisation.

Returns true if tracing is activated in this process.

Definition at line 55 of file IgTrace.cc.

References debug(), IgTraceFilter::extraInfo, f, stor::func(), IgTraceFilter::functionName, info, IgTraceFilter::libraryName, IgTraceFilter::nextFilter, options(), s_activated, s_enabled, s_initialized, and target.

Referenced by IgTraceMem::initialize(), IgTraceThrow::initialize(), and IgTraceMMap::initialize().

{
    if (! s_initialized)
    {
        s_initialized = true;

        const char *options = IgTrace::options ();
        if (! options || ! *options)
        {
            IgTrace::debug ("$IGTRACE not set, not tracing this process\n");
            return s_activated = false;
        }
        while (options && *options)
        {
            while (*options == ' ' || *options == ',')
                ++options;

            if (! strncmp (options, "igtrace:reject='", 16))
            {
                options += 16;

                const char *info = options;
                int infolen = 0;
                while (*options && *options != '\'' && *options != ':')
                    ++options, ++infolen;
                if (*options == ':')
                    ++options;

                const char *func = options;
                int funclen = 0;
                while (*options && *options != '\'' && *options != ':')
                    ++options, ++funclen;
                if (*options == ':')
                    ++options;

                const char *lib = options;
                int liblen = 0;
                while (*options && *options != '\'' && *options != ':')
                    ++options, ++liblen;

                IgTraceFilter *f = new IgTraceFilter;
                f->nextFilter = 0;
                f->extraInfo     = (infolen ? strndup (info, infolen) : 0);
                f->functionName  = (funclen ? strndup (func, funclen) : 0);
                f->libraryName   = (liblen  ? strndup (lib,  liblen)  : 0);

                IgTraceFilter **chain = &s_filters;
                while (*chain)
                    chain = &(*chain)->nextFilter;
    
                *chain = f;

                while (*options && *options != '\'')
                    ++options;
            }
            else
                options++;

            while (*options && *options != ',' && *options != ' ')
                options++;
        }

        const char *target = getenv ("IGTRACE_TARGET");
        if (target && ! strstr (program_invocation_name, target))
        {
            IgTrace::debug ("Current process not selected for tracing:"
                            " process '%s' does not match '%s'\n",
                            program_invocation_name, target);
            return s_activated = false;
        }

        IgTrace::debug ("Activated in %s\n", program_invocation_name);
        IgTrace::debug ("Options: %s\n", IgTrace::options ());
        s_activated = true;
        s_enabled = 1;
    }

    if (! s_activated)
        return false;

    return true;
}

const char * IgTrace::options

(

void

)

[static]

Get user-provided profiling options.

Definition at line 175 of file IgTrace.cc.

References s_options.

Referenced by initialize(), IgTraceMem::initialize(), IgTraceThrow::initialize(), and IgTraceMMap::initialize().

{
     static const char *s_options = getenv ("IGTRACE");
     return s_options;
}

int IgTrace::panic	(	const char *	file,
		int	line,
		const char *	func,
		const char *	expr
	)			[static]

Internal assertion helper routine.

Definition at line 183 of file IgTrace.cc.

References disable(), enable(), i, offset, IgHookTrace::stacktrace(), IgHookTrace::symbol(), and GsfMatrixTools::trace().

{
    IgTrace::disable ();

#if __linux
    fprintf (stderr, "%s: ", program_invocation_name);
#endif
    fprintf (stderr, "%s:%d: %s: assertion failure: %s\n", file, line, func, expr);

    void *trace [128];
    int levels = IgHookTrace::stacktrace (trace, 128);
    for (int i = 2; i < levels; ++i)
    {
        const char      *sym = 0;
        const char      *lib = 0;
        int             offset = 0;
        int             liboffset = 0;
        IgHookTrace::symbol (trace [i], sym, lib, offset, liboffset);
        fprintf (stderr, "  %p %s + %d [%s + %d]\n", trace [i], sym, offset, lib, liboffset);
    }

    // abort ();
    IgTrace::enable ();
    return 1;
}

const char * IgTrace::program

(

void

)

[static]

Return program name.

Definition at line 232 of file IgTrace.cc.

Referenced by domalloc(), domunmap(), dothrow(), and mmapreport().

{
    return program_invocation_name;
}

---

The documentation for this class was generated from the following files:

• IgTools/IgTrace/src/IgTrace.h
• IgTools/IgTrace/src/IgTrace.cc

---