Merge branch 'master' into gui

Fix compilation error on some platforms.

See also: https://bugs.gentoo.org/show_bug.cgi?id=548850

Start a simple Qt GUI and share some code with the ASCII printer.

Fix compilation error on some platforms.

See also: https://bugs.gentoo.org/show_bug.cgi?id=548850

Stay backwards compatible to old Boost 1.41 for RHEL 6 compatibility.

Set CMAKE_INSTALL_RPATH_USE_LINK_PATH to true.

This makes it simpler to run heaptrack against e.g. a
libunwind available in the CMAKE_INSTALL_PREFIX. Otherwise,
one would have to set the LD_LIBRARY_PATH manually.

Don't fail to compile when aligned alloc is not available.

Make symlinked heaptrack shell script work properly.

Link against pthread in the heaptrack libraries.

This is required to run properly against debuggees that do not
use threads at all.

Reported-by: Yehezkel Horowitz <horowity@checkpoint.com>
Reported-by: Anatolii Koval <AKoval@luxoft.com>

Use dlmopen when trying to inject heaptrack_inject.

Some systems use an optimized dlopen symbol (especially embeded linux
modifications), but these don't touch dlmopen, which is more general.

This prevents an "dlopen - symbol not found" error when trying to
inject heaptrack on such systems to a running process.

Improve output and document -p and --pid arguments.

Fix build on machines where size_t != lu.

Reported-by: Yehezkel Horowitz <horowity@checkpoint.com>

Don't override LD_PRELOAD, just prepend to it.

This enables usage on targets that use LD_PRELOAD themselves already.

Add backtrace filter via --filter-bt-function.

Only allocations with a function matching the filter will be printed.

Make warnings errors as we rely on the libbacktrace features.

Allow for whitespace in program name and arguments.

Use correct allocation data for massif peak data.

This way, the sum of the detailed backtraces equals the total snapshot
count. While the x axis is wrong then, this is not so important I
think. Rather, we want to find the memory hotspots which is much
easier this way.

Disable malloc_info baseline when attaching to running process.

In such cases, we are more interested in the relative increase. We
do not want to apply the relative threshold based on the absolute
baseline for example, but rather to the data we obtained.

Make start time const.

Don't fail when trying to join the timer thread.

Silence GDB stdout messages by using --batch-silent.

Also print exit message when killing heaptrack via CTRL+C.

Do not load gdbinit file or symbols when attaching to process.

Instead, only load the two libs we actually need, libdl for dlopen
and libheaptrack_inject for the init function.

Cleanup code for operator new skipping in backtraces.

Also stop backtraces after __static_initialization_and_destruction_0.

Additionally, we can now cope with backtraces that either show
main or __libc_start_main, and stop at the first occurrance
of either symbol.

Fix major regression: Get backtrace in malloc properly.

Zomg, I must have been asleep when I comitted this - sorry.

Remove explicit std:: qualification, we use that namespace.

Instead of yielding the thread, sleep for one micro second.

This significantly improves the performance of the threaded
test example. The reason are the far reduced numbers of context
switches (goes down by about 90%):

Perf stat results averaged over ten runs are:

before:
       1537.459666      task-clock (msec)         #    2.741 CPUs utilized            ( +-  1.98% )
           164,214      context-switches          #    0.107 M/sec                    ( +-  4.77% )
             1,238      cpu-migrations            #    0.805 K/sec                    ( +-  1.42% )
             3,996      page-faults               #    0.003 M/sec                    ( +-  0.26% )
     3,531,767,774      cycles                    #    2.297 GHz                      ( +-  1.96% ) [56.85%]
   <not supported>      stalled-cycles-frontend
   <not supported>      stalled-cycles-backend
     4,404,564,712      instructions              #    1.25  insns per cycle          ( +-  1.81% ) [82.34%]
       895,286,284      branches                  #  582.315 M/sec                    ( +-  1.83% ) [82.05%]
        14,800,878      branch-misses             #    1.65% of all branches          ( +-  2.07% ) [83.04%]

       0.560967210 seconds time elapsed                                          ( +-  1.78% )

after:

        940.204408      task-clock (msec)         #    1.970 CPUs utilized            ( +-  0.97% )
            16,628      context-switches          #    0.018 M/sec                    ( +-  2.09% )
             1,709      cpu-migrations            #    0.002 M/sec                    ( +-  2.02% )
             3,733      page-faults               #    0.004 M/sec                    ( +-  0.62% )
     2,299,207,706      cycles                    #    2.445 GHz                      ( +-  0.95% ) [54.67%]
   <not supported>      stalled-cycles-frontend
   <not supported>      stalled-cycles-backend
     3,203,389,330      instructions              #    1.39  insns per cycle          ( +-  1.48% ) [84.25%]
       717,416,828      branches                  #  763.043 M/sec                    ( +-  1.01% ) [77.86%]
        11,127,629      branch-misses             #    1.55% of all branches          ( +-  0.98% ) [76.95%]

       0.477194059 seconds time elapsed                                          ( +-  0.34% )

Note that we utilize less CPUs (which is good, as it safes power), but
still decrease the total run time, as do number of cycles spent
and instructions executed.

Use acquire semantics after all... ;-)

According to this page, the relaxed semantics are a useless
optimization and might in fact degrade performance on some systems:

http://www.boost.org/doc/libs/master/doc/html/atomic/usage_examples.html#boost_atomic.usage_examples.example_spinlock

Cleanup spinlock implementation.

- use atomic::exchange
- use relaxed memory order in loop

Cope with broken backtraces.

Still output a 0 trace index and print ?? later.

Refactor code once more for yet better thread safety at shutdown.

Instead of using flockfile, we use a simple spin lock now. This
is even a bit faster than using flockfile, and does not have any
issues at shutdown, when the file was deleted already.

Also, the spin lock can easily be combined with the check for
when the timer thread should be stopped.

Furthermore, the code is restructured to ensure the thread-unsafe
API is only ever getting called while the lock is held.

To simplify future development, some debug log can now be enabled
which will trace the heaptrack execution.

Set cmake requirement to 2.8.9 and use LINK_PRIVATE.

Hopefully this restores building it with an older CMake version.

Only one trap can be added.

This prevents leakage of the /tmp/heaptrack_fifo$$ files.

Adapt to libunwind changes with unw_set_cache_size.

Silence build warnings, as was done before in vogl/apitrace.

Add noexcept

Compile in pedantic mode.

Remove dead code

Write accurate end time on shutdown.

Also print out bytes allocated per second and allocations per
second in heaptrack_print overview.

Minimize changes against libbacktrace.

Instead, we export more elf internals and call that directly from
heaptrack_interpret. This should make it simpler to keep the
libbacktrace checkout in sync with upstream changes.

Remove dead code and enable more warnings when building.

Update libbacktrace to latest version from GCC 4.9 git branch.

This should fix a serious memory issue in libbacktrace, see:

https://gcc.gnu.org/ml/gcc-patches/2014-05/msg00547.html

Thanks for the report and analysis to André Wöbbeking.

CCMAIL: Woebbeking@kde.org

Mark Boost and Threads as required dependencies.

Overwrite symbols after dlopen in injected heaptrack.

Mark module cache dirty on initialization.

This is required for multiple reattachements.

Use a custom thread + sleep_for instead of a C timer.

This makes re-attaching work without deadlocks in timer_delete
for me. And we can clean the code up even more now:

Much less code, yet still more accurate. The overhead is negleglible
in my tests. And this makes it trivial for the future to let users
configure the interval themselves.

Refactor the code to allow multiple runtime-injections.

This is sometimes useful. This way, you can hop on/off
as you like and just investigate the areas you are
interested in.

Refactor hook initialization in heaptrack_preload.

The previous code works with clang, but not with GCC. This new
code works with GCC, and, hopefully, also with clang. It does not
depend on static initialization order anymore, as the string
identifiers of the hook functions are initialized via constexpr now.

This fixes the heaptrack_preload usage for me on this machine.

Remove code that does not compile with slightly older compilers.

Add compile-check around unw_set_cache_log_size.

Silence warning when debuggee quit already.

Restore original function addresses when shutting down injected heaptrack.

This should bring back the original behavior and performance.
And we might also be able to re-attach then if desired.

Return output stream

Merge branch 'inject'

Stop heaptrack when heaptrack_interpret goes away.

Add -p/--pid option to attach heaptrack to a running process.

We use gdb to attach to the process, then call dlopen there and
finally an initialization hook in the new libheaptrack_inject.so.
To prevent an underflow in the total memory consumption, we
call malloc_info and parse that in heaptrack_interpret to get a
baseline for the current total memory consumption at the point
where we attached to the process.

The code is refactored into a shared libheaptrack.cpp with common
code, and two libraries, libheaptrack_inject.so and the old
libheaptrack_preload.so. The heaptrack bash script is adapted to
support both versions.

Restructure argument parsing in shell script.

This makes it easier to maintain and the arguments become position-
independent, which is very useful.

Get rid of temporary string allocations.

Use lambdas instead of passing printf labels with magic numbers.

This also gets rid of useless string allocations to format the byte
sizes of data members that are never printed.

Cleanup/fix: We add +1 above already, so no need to do it again.

Use mprotect on addresses we want to overwrite.

This seems to be more reliable than the other method.

Also overload posix_memalign.

Overwrite realloc, calloc and cfree at runtime.

Overwrite dlopen/dlclose as well at runtime.

Ensure the hook function is convertible to the original function.

Further cleanup the code

Make the hook list easier extensible.

Cleanup code a bit.

Also overwrite free.

Make runtime-patching work!

Wow, awesome. What was missing where the offsets, i.e. the dlpi_addr
must be added to the p_vaddr, as well as the r_offset. Or so it seems.
Now I don't see any crashes anymore, and my custom malloc gest called!

first work towards runtime injection, not really working yet

Remove spurious define, only required on some faulty machine of mine.

Add LGPL v2.1+ text in COPYING file.

Fix line information written by heaptrack_interpret.

The line numbers where written in decimal format, but heaptrack_print
expects hexadecimal numbers when reading. This lead to completely
wrong line numbers in the end.

Always show the biggest heap in the total memory consumption.

This still has some issues, but is better than nothing.

Add some platform checks to give better error messages at cmake time.

Skip anything below main in massif backtraces.

Properly handle case where __libc_start_main is encountered before main itself.

We still want to break in main.

Sort massif output file.

This is expected by e.g. the massif-visualizer and probably other
tools as well.

Introduce tunable massif threshold and detailed freq parameters.

Print full backtraces in generated massif files.

These files easily become quite large. We really need our own
heaptrack-visualizer to efficiently read the data and handle it.

Print first level of backtrace in generated massif files.

Basic support for massif output file generation.

So far, it only includes the total heap memory usage. Backtraces
will be added in the next step.

Use thread instead of signal and increase timestamp frequency.

Sadly, this creates a new thread for every timer apparently,
but still, it's better than using signals which randomly influence
other functions and sometimes fubar our output files. Or so I think.

Remember the debugee command line.

This is sometimes useful and also tracked by massif and other tools.

Simplify code and write exe path directly to stream.

No need for a temporary string allocation here.

Simplify code, it's not worth the imagined performance gain.

Unset automatic locking of stdout and stdin.

This is not required in the heaptrack_interpret process.

Prefer C I/O API for speed.

It's sad that this gives such a noticeable speedup :(

Use fputs if we don't need to format anything.

Cleanup module handling code and change the file format a bit.

We now output a single line per module and delegate the whole
interpretation of the dl_phdr_info data to heaptrack_interpret.

This allows us to reduce the size of Module a bit, leading to hope-
fully faster binary searches amongst other benefits.

Remove code that depends on local libunwind patches.

Fixup handling of posix_memaling.

The return value of zero indicates success here. This should fix
some inconsistencies on applications that use this function.

Don't print 0B leaked lines.

Properly take cfree into account.

Ensure we only ever initialize once.

Use the same error handler for both init error callbacks.

This happens rarely, and the error message is still helpful.

Fixup callback handlers, the wrong data was passed in.

Cleanup: get rid of obsolete isExe member in module.

It is only required for the call to backtrace_fileline_initialize.