Docs/2.6

Linux Trace Toolkit: next generation

$
#
echo Command line as a regular user
echo Command line as a the `root` user

lttng enable-event --kernel --syscall open,fork,chdir,pipe

lttng list --kernel

sudo lttng create

sudo lttng enable-event --kernel sched_switch,sched_process_fork

sudo lttng enable-event --kernel --all

sudo lttng start

sudo lttng stop
sudo lttng destroy
#undef TRACEPOINT_PROVIDER
#define TRACEPOINT_PROVIDER hello_world

#undef TRACEPOINT_INCLUDE
#define TRACEPOINT_INCLUDE "./hello-tp.h"

#if !defined(_HELLO_TP_H) || defined(TRACEPOINT_HEADER_MULTI_READ)
#define _HELLO_TP_H

#include <lttng/tracepoint.h>

TRACEPOINT_EVENT(
    hello_world,
    my_first_tracepoint,
    TP_ARGS(
        int, my_integer_arg,
        char*, my_string_arg
    ),
    TP_FIELDS(
        ctf_string(my_string_field, my_string_arg)
        ctf_integer(int, my_integer_field, my_integer_arg)
    )
)

#endif /* _HELLO_TP_H */

#include <lttng/tracepoint-event.h>

#define TRACEPOINT_CREATE_PROBES
#define TRACEPOINT_DEFINE

#include "hello-tp.h"

gcc -c -I. hello-tp.c
#include <stdio.h>
#include "hello-tp.h"

int main(int argc, char *argv[])
{
    int x;

    puts("Hello, World!\nPress Enter to continue...");

    /*
     * The following getchar() call is only placed here for the purpose
     * of this demonstration, for pausing the application in order for
     * you to have time to list its events. It's not needed otherwise.
     */
    getchar();

    /*
     * A tracepoint() call. Arguments, as defined in hello-tp.h:
     *
     *     1st: provider name (always)
     *     2nd: tracepoint name (always)
     *     3rd: my_integer_arg (first user-defined argument)
     *     4th: my_string_arg (second user-defined argument)
     *
     * Notice the provider and tracepoint names are NOT strings;
     * they are in fact parts of variables created by macros in
     * hello-tp.h.
     */
    tracepoint(hello_world, my_first_tracepoint, 23, "hi there!");

    for (x = 0; x < argc; ++x) {
        tracepoint(hello_world, my_first_tracepoint, x, argv[x]);
    }

    puts("Quitting now!");

    tracepoint(hello_world, my_first_tracepoint, x * x, "x^2");

    return 0;
}

gcc -c hello.c
gcc -o hello hello.o hello-tp.o -llttng-ust -ldl

./hello world and beyond
Hello, World!
Press Enter to continue...

lttng list --userspace

lttng create

lttng enable-event --userspace hello_world:my_first_tracepoint

lttng start

lttng stop

lttng view
[18:10:27.684304496] (+?.?????????) hostname hello_world:my_first_tracepoint: { cpu_id = 0 }, { my_string_field = "hi there!", my_integer_field = 23 }
[18:10:27.684338440] (+0.000033944) hostname hello_world:my_first_tracepoint: { cpu_id = 0 }, { my_string_field = "./hello", my_integer_field = 0 }
[18:10:27.684340692] (+0.000002252) hostname hello_world:my_first_tracepoint: { cpu_id = 0 }, { my_string_field = "world", my_integer_field = 1 }
[18:10:27.684342616] (+0.000001924) hostname hello_world:my_first_tracepoint: { cpu_id = 0 }, { my_string_field = "and", my_integer_field = 2 }
[18:10:27.684343518] (+0.000000902) hostname hello_world:my_first_tracepoint: { cpu_id = 0 }, { my_string_field = "beyond", my_integer_field = 3 }
[18:10:27.684357978] (+0.000014460) hostname hello_world:my_first_tracepoint: { cpu_id = 0 }, { my_string_field = "x^2", my_integer_field = 16 }

lttng destroy

babeltrace ~/lttng-traces/my-session

babeltrace ~/lttng-traces/my-kernel-session | grep sys_

babeltrace ~/lttng-traces/my-kernel-session | grep sys_read | wc --lines
import sys
from collections import Counter
import babeltrace

def top5proc():
    if len(sys.argv) != 2:
        msg = 'Usage: python {} TRACEPATH'.format(sys.argv[0])
        raise ValueError(msg)

    # a trace collection holds one to many traces
    col = babeltrace.TraceCollection()

    # add the trace provided by the user
    # (LTTng traces always have the 'ctf' format)
    if col.add_trace(sys.argv[1], 'ctf') is None:
        raise RuntimeError('Cannot add trace')

    # this counter dict will hold execution times:
    #
    #   task command name -> total execution time (ns)
    exec_times = Counter()

    # this holds the last `sched_switch` timestamp
    last_ts = None

    # iterate events
    for event in col.events:
        # keep only `sched_switch` events
        if event.name != 'sched_switch':
            continue

        # keep only events which happened on CPU 0
        if event['cpu_id'] != 0:
            continue

        # event timestamp
        cur_ts = event.timestamp

        if last_ts is None:
            # we start here
            last_ts = cur_ts

        # previous task command (short) name
        prev_comm = event['prev_comm']

        # initialize entry in our dict if not yet done
        if prev_comm not in exec_times:
            exec_times[prev_comm] = 0

        # compute previous command execution time
        diff = cur_ts - last_ts

        # update execution time of this command
        exec_times[prev_comm] += diff

        # update last timestamp
        last_ts = cur_ts

    # display top 10
    for name, ns in exec_times.most_common(5):
        s = ns / 1000000000
        print('{:20}{} s'.format(name, s))

if __name__ == '__main__':
    top5proc()

python3 top5proc.py ~/lttng-sessions/my-session-.../kernel
swapper/0           48.607245889 s
chromium            7.192738188 s
pavucontrol         0.709894415 s
Compositor          0.660867933 s
Xorg.bin            0.616753786 s

lttng-sessiond

lttng-sessiond --daemonize

pkill lttng-sessiond
#include <lttng/lttng.h>

#undef TRACEPOINT_PROVIDER
#define TRACEPOINT_PROVIDER my_provider

#undef TRACEPOINT_INCLUDE
#define TRACEPOINT_INCLUDE "./tp.h"

#if !defined(_TP_H) || defined(TRACEPOINT_HEADER_MULTI_READ)
#define _TP_H

#include <lttng/tracepoint.h>

TRACEPOINT_EVENT(
    my_provider,
    my_first_tracepoint,
    TP_ARGS(
        int, my_integer_arg,
        char*, my_string_arg
    ),
    TP_FIELDS(
        ctf_string(my_string_field, my_string_arg)
        ctf_integer(int, my_integer_field, my_integer_arg)
    )
)

TRACEPOINT_EVENT(
    my_provider,
    my_other_tracepoint,
    TP_ARGS(
        int, my_int
    ),
    TP_FIELDS(
        ctf_integer(int, some_field, my_int)
    )
)

#endif /* _TP_H */

#include <lttng/tracepoint-event.h>

#define TRACEPOINT_CREATE_PROBES

#include "tp.h"

#undef TRACEPOINT_PROVIDER
#define TRACEPOINT_PROVIDER my_provider

#undef TRACEPOINT_INCLUDE
#define TRACEPOINT_INCLUDE "./tp.h"

#if !defined(_TP_H) || defined(TRACEPOINT_HEADER_MULTI_READ)
#define _TP_H

#include <lttng/tracepoint.h>

#endif /* _TP_H */

#include <lttng/tracepoint-event.h>

#define TRACEPOINT_CREATE_PROBES

#include "tp.h"

#define TRACEPOINT_CREATE_PROBES

#include "tp1.h"
#include "tp2.h"

lttng-gen-tp my-template.tp

CFLAGS=-I/custom/include/path lttng-gen-tp my-template.tp
TRACEPOINT_EVENT(
    /* tracepoint provider name */
    my_provider,

    /* tracepoint/event name */
    my_first_tracepoint,

    /* list of tracepoint arguments */
    TP_ARGS(
        int, my_integer_arg,
        char*, my_string_arg
    ),

    /* list of fields of eventual event  */
    TP_FIELDS(
        ctf_string(my_string_field, my_string_arg)
        ctf_integer(int, my_integer_field, my_integer_arg)
    )
)

    TP_ARGS(
        FILE*, stream,
        long int, offset,
        int, origin
    ),

/* for struct stat */
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

TRACEPOINT_EVENT(
    my_provider,
    my_tracepoint,
    TP_ARGS(
        int, my_int_arg,
        char*, my_str_arg,
        struct stat*, st
    ),
    TP_FIELDS(
        /* simple integer field with constant value */
        ctf_integer(
            int,                    /* field C type */
            my_constant_field,      /* field name */
            23 + 17                 /* argument expression */
        )

        /* my_int_arg tracepoint argument */
        ctf_integer(
            int,
            my_int_arg_field,
            my_int_arg
        )

        /* my_int_arg squared */
        ctf_integer(
            int,
            my_int_arg_field2,
            my_int_arg * my_int_arg
        )

        /* sum of first 4 characters of my_str_arg */
        ctf_integer(
            int,
            sum4,
            my_str_arg[0] + my_str_arg[1] +
            my_str_arg[2] + my_str_arg[3]
        )

        /* my_str_arg as string field */
        ctf_string(
            my_str_arg_field,       /* field name */
            my_str_arg              /* argument expression */
        )

        /* st_size member of st tracepoint argument, hexadecimal */
        ctf_integer_hex(
            off_t,                  /* field C type */
            size_field,             /* field name */
            st->st_size             /* argument expression */
        )

        /* st_size member of st tracepoint argument, as double */
        ctf_float(
            double,                 /* field C type */
            size_dbl_field,         /* field name */
            (double) st->st_size    /* argument expression */
        )

        /* half of my_str_arg string as text sequence */
        ctf_sequence_text(
            char,                   /* element C type */
            half_my_str_arg_field,  /* field name */
            my_str_arg,             /* argument expression */
            size_t,                 /* length expression C type */
            strlen(my_str_arg) / 2  /* length expression */
        )
    )
)

TRACEPOINT_EVENT(
    my_app,
    get_account,
    TP_ARGS(
        int, userid,
        size_t, len
    ),
    TP_FIELDS(
        ctf_integer(int, userid, userid)
        ctf_integer(size_t, len, len)
    )
)

TRACEPOINT_EVENT(
    my_app,
    get_settings,
    TP_ARGS(
        int, userid,
        size_t, len
    ),
    TP_FIELDS(
        ctf_integer(int, userid, userid)
        ctf_integer(size_t, len, len)
    )
)

TRACEPOINT_EVENT(
    my_app,
    get_transaction,
    TP_ARGS(
        int, userid,
        size_t, len
    ),
    TP_FIELDS(
        ctf_integer(int, userid, userid)
        ctf_integer(size_t, len, len)
    )
)

/* the tracepoint class */
TRACEPOINT_EVENT_CLASS(
    /* tracepoint provider name */
    my_app,

    /* tracepoint class name */
    my_class,

    /* arguments */
    TP_ARGS(
        int, userid,
        size_t, len
    ),

    /* fields */
    TP_FIELDS(
        ctf_integer(int, userid, userid)
        ctf_integer(size_t, len, len)
    )
)

/* the tracepoint instances */
TRACEPOINT_EVENT_INSTANCE(
    /* tracepoint provider name */
    my_app,

    /* tracepoint class name */
    my_class,

    /* tracepoint/event name */
    get_account,

    /* arguments */
    TP_ARGS(
        int, userid,
        size_t, len
    )
)
TRACEPOINT_EVENT_INSTANCE(
    my_app,
    my_class,
    get_settings,
    TP_ARGS(
        int, userid,
        size_t, len
    )
)
TRACEPOINT_EVENT_INSTANCE(
    my_app,
    my_class,
    get_transaction,
    TP_ARGS(
        int, userid,
        size_t, len
    )
)

#define MY_TRACEPOINT_ARGS \
    TP_ARGS( \
        int, userid, \
        size_t, len \
    )

TRACEPOINT_EVENT_CLASS(
    my_app,
    my_class,
    MY_TRACEPOINT_ARGS,
    TP_FIELDS(
        ctf_integer(int, userid, userid)
        ctf_integer(size_t, len, len)
    )
)

#define MY_APP_TRACEPOINT_INSTANCE(name) \
    TRACEPOINT_EVENT_INSTANCE( \
        my_app, \
        my_class, \
        name, \
        MY_TRACEPOINT_ARGS \
    )

MY_APP_TRACEPOINT_INSTANCE(get_account)
MY_APP_TRACEPOINT_INSTANCE(get_settings)
MY_APP_TRACEPOINT_INSTANCE(get_transaction)

TRACEPOINT_LOGLEVEL(PROVIDER_NAME, TRACEPOINT_NAME, LOG_LEVEL)

TRACEPOINT_LOGLEVEL(my_provider, my_tracepoint, TRACE_DEBUG_UNIT)

TRACEPOINT_EVENT(
    /* tracepoint provider name */
    my_provider,

    /* tracepoint/event name */
    my_first_tracepoint,

    /* list of tracepoint arguments */
    TP_ARGS(
        int, my_integer_arg,
        char*, my_string_arg
    ),

    /* list of fields of eventual event  */
    TP_FIELDS(
        ctf_string(my_string_field, my_string_arg)
        ctf_integer(int, my_integer_field, my_integer_arg)
    )
)

#define TRACEPOINT_DEFINE
#include "tp.h"

int main(int argc, char* argv[])
{
    int i;

    tracepoint(my_provider, my_first_tracepoint, 23, "Hello, World!");

    for (i = 0; i < argc; ++i) {
        tracepoint(my_provider, my_first_tracepoint, i, argv[i]);
    }

    return 0;
}

/* for struct stat */
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

TRACEPOINT_EVENT(
    my_provider,
    my_tracepoint,
    TP_ARGS(
        int, my_int_arg,
        char*, my_str_arg,
        struct stat*, st
    ),
    TP_FIELDS(
        ctf_integer(int, my_constant_field, 23 + 17)
        ctf_integer(int, my_int_arg_field, my_int_arg)
        ctf_integer(int, my_int_arg_field2, my_int_arg * my_int_arg)
        ctf_integer(int, sum4_field, my_str_arg[0] + my_str_arg[1] +
                                     my_str_arg[2] + my_str_arg[3])
        ctf_string(my_str_arg_field, my_str_arg)
        ctf_integer_hex(off_t, size_field, st->st_size)
        ctf_float(double, size_dbl_field, (double) st->st_size)
        ctf_sequence_text(char, half_my_str_arg_field, my_str_arg,
                          size_t, strlen(my_str_arg) / 2)
    )
)

#define TRACEPOINT_DEFINE
#include "tp.h"

int main(void)
{
    struct stat s;

    stat("/etc/fstab", &s);

    tracepoint(my_provider, my_tracepoint, 23, "Hello, World!", &s);

    return 0;
}

my_constant_field           40
my_int_arg_field            23
my_int_arg_field2           529
sum4_field                  389
my_str_arg_field            "Hello, World!"
size_field                  0x12d
size_dbl_field              301.0
half_my_str_arg_field       "Hello,"
#include <stdlib.h>
#include <stdio.h>
/* ... */

#define TRACEPOINT_CREATE_PROBES
#define TRACEPOINT_DEFINE
#include "tp.h"

/* ... */

int my_func(int a, const char* b)
{
    /* ... */

    tracepoint(my_provider, my_tracepoint, buf, sz, limit, &tt)

    /* ... */
}

/* ... */

gcc -c -I. file.c
#define TRACEPOINT_CREATE_PROBES

#include "tp.h"

#define TRACEPOINT_CREATE_PROBES
#define TRACEPOINT_DEFINE

#include "tp.h"

gcc -c -I. tp.c

ar rc tp.a tp.o

gcc -o app tp.o other.o files.o of.o your.o app.o -llttng-ust -ldl

gcc -o app tp.a other.o files.o of.o your.o app.o -llttng-ust -ldl

gcc -o app tp.a other.o files.o of.o your.o app.o -llttng-ust -lc

./app
#define TRACEPOINT_DEFINE
#define TRACEPOINT_PROBE_DYNAMIC_LINKAGE

/* include the header files of one or more tracepoint providers below */
#include "tp1.h"
#include "tp2.h"
#include "tp3.h"

gcc -c -fpic -I. tp.c

gcc -shared -Wl,--no-as-needed -o tp.so -llttng-ust tp.o

gcc -o app other.o files.o of.o your.o app.o -ldl

LD_PRELOAD=/path/to/tp.so ./app

./app

LD_PRELOAD=liblttng-ust-fork.so ./app

LD_PRELOAD="liblttng-ust-fork.so /path/to/tp.so" ./app

pkg-config --libs lttng-ust

pkg-config --modversion lttng-ust
#include <lttng/tracef.h>

    /* ... */

    tracef("my message, my integer: %d", my_integer);

    /* ... */

gcc -o app app.c -llttng-ust

./app

lttng enable-event --userspace 'lttng_ust_tracef:*'

LD_PRELOAD=liblttng-ust-libc-wrapper.so my-app

LD_PRELOAD=liblttng-ust-pthread-wrapper.so my-app

LD_PRELOAD="liblttng-ust-libc-wrapper.so liblttng-ust-pthread-wrapper.so" my-app

LD_PRELOAD=liblttng-ust-cyg-profile-fast.so my-app

LD_PRELOAD=liblttng-ust-cyg-profile.so my-app

LD_PRELOAD=liblttng-ust-dl.so my-app
import java.util.logging.Logger;
import org.lttng.ust.agent.LTTngAgent;

public class Test
{
    private static final int answer = 42;

    public static void main(String[] argv) throws Exception
    {
        // create a logger
        Logger logger = Logger.getLogger("jello");

        // call this as soon as possible (before logging)
        LTTngAgent lttngAgent = LTTngAgent.getLTTngAgent();

        // log at will!
        logger.info("some info");
        logger.warning("some warning");
        Thread.sleep(500);
        logger.finer("finer information; the answer is " + answer);
        Thread.sleep(123);
        logger.severe("error!");

        // not mandatory, but cleaner
        lttngAgent.dispose();
    }
}

javac -cp /usr/lib/lttng/java/liblttng-ust-agent.jar Test.java

java -cp /usr/lib/lttng/java/liblttng-ust-agent.jar:. Test
import org.apache.log4j.Logger;
import org.apache.log4j.BasicConfigurator;
import org.lttng.ust.agent.LTTngAgent;

public class Test
{
    private static final int answer = 42;

    public static void main(String[] argv) throws Exception
    {
        // create and configure a logger
        Logger logger = Logger.getLogger(Test.class);
        BasicConfigurator.configure();

        // call this as soon as possible (before logging)
        LTTngAgent lttngAgent = LTTngAgent.getLTTngAgent();

        // log at will!
        logger.info("some info");
        logger.warn("some warning");
        Thread.sleep(500);
        logger.debug("debug information; the answer is " + answer);
        Thread.sleep(123);
        logger.error("error!");
        logger.fatal("fatal error!");

        // not mandatory, but cleaner
        lttngAgent.dispose();
    }
}

javac -cp /usr/lib/lttng/java/liblttng-ust-agent.jar:$LOG4JCP Test.java

java -cp /usr/lib/lttng/java/liblttng-ust-agent.jar:$LOG4JCP:. Test

git clone git://git.lttng.org/lttng-modules.git
/* subsystem name is "hello" */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM hello

#if !defined(_TRACE_HELLO_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_HELLO_H

#include <linux/tracepoint.h>

TRACE_EVENT(
    /* "hello" is the subsystem name, "world" is the event name */
    hello_world,

    /* tracepoint function prototype */
    TP_PROTO(int foo, const char* bar),

    /* arguments for this tracepoint */
    TP_ARGS(foo, bar),

    /* LTTng doesn't need those */
    TP_STRUCT__entry(),
    TP_fast_assign(),
    TP_printk("", 0)
);

#endif

/* this part must be outside protection */
#include <trace/define_trace.h>

/* called from driver core with dev locked */
static int usb_probe_device(struct device *dev)
{
    struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
    struct usb_device *udev = to_usb_device(dev);
    int error = 0;

    trace_hello_world(udev->devnum, udev->product);

    /* ... */
}

/* ... */

#include "usb.h"

#define CREATE_TRACE_POINTS
#include <trace/events/hello.h>

/* ... */

#undef TRACE_SYSTEM
#define TRACE_SYSTEM hello

#if !defined(_TRACE_HELLO_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_HELLO_H

#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/tracepoint.h>

LTTNG_TRACEPOINT_EVENT(
    /* format identical to mainline version for those */
    hello_world,
    TP_PROTO(int foo, const char* bar),
    TP_ARGS(foo, bar),

    /* possible differences */
    TP_STRUCT__entry(
        __field(int, my_int)
        __field(char, char0)
        __field(char, char1)
        __string(product, bar)
    ),

    /* notice the use of tp_assign()/tp_strcpy() and no semicolons */
    TP_fast_assign(
        tp_assign(my_int, foo)
        tp_assign(char0, bar[0])
        tp_assign(char1, bar[1])
        tp_strcpy(product, bar)
    ),

    /* This one is actually not used by LTTng either, but must be
     * present for the moment.
     */
    TP_printk("", 0)

/* no semicolon after this either */
)

#endif

/* other difference: do NOT include <trace/define_trace.h> */
#include "../../../probes/define_trace.h"

#include <linux/module.h>
#include "../lttng-tracer.h"

/* Build time verification of mismatch between mainline TRACE_EVENT()
 * arguments and LTTng adaptation layer LTTNG_TRACEPOINT_EVENT() arguments.
 */
#include <trace/events/hello.h>

/* create LTTng tracepoint probes */
#define LTTNG_PACKAGE_BUILD
#define CREATE_TRACE_POINTS
#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module

#include "../instrumentation/events/lttng-module/hello.h"

MODULE_LICENSE("GPL and additional rights");
MODULE_AUTHOR("Your name <your-email>");
MODULE_DESCRIPTION("LTTng hello probes");
MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
    __stringify(LTTNG_MODULES_MINOR_VERSION) "."
    __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
    LTTNG_MODULES_EXTRAVERSION);

# ...

obj-m += lttng-probe-module.o
obj-m += lttng-probe-power.o

obj-m += lttng-probe-hello.o

# ...

make KERNELDIR=/path/to/custom/linux

sudo make modules_install

sudo pkill -u root lttng-sessiond
sudo lttng-sessiond --extra-kmod-probes=hello

sudo lttng-sessiond --kmod-probes=hello,ext4,net,block,signal,sched

lsmod | grep lttng_probe_hello

lttng list --kernel | grep hello

sudo lttng create my-session
sudo lttng enable-event --kernel hello_world
sudo lttng start

sudo lttng stop
sudo lttng view
[15:30:34.835895035] (+?.?????????) hostname hello_world: { cpu_id = 1 }, { my_int = 8, char0 = 68, char1 = 97, product = "DataTraveler 2.0" }
[15:30:42.262781421] (+7.426886386) hostname hello_world: { cpu_id = 1 }, { my_int = 9, char0 = 80, char1 = 97, product = "Patriot Memory" }
[15:30:48.175621778] (+5.912840357) hostname hello_world: { cpu_id = 1 }, { my_int = 10, char0 = 68, char1 = 97, product = "DataTraveler 2.0" }
/* ... */

/* Build time verification of mismatch between mainline TRACE_EVENT()
 * arguments and LTTng adaptation layer LTTNG_TRACEPOINT_EVENT() arguments.
 */
#include <trace/events/hello.h>

/* ... */

#include <tracepoints/hello.h>

make ccflags-y=-I/path/to/kernel/module KERNELDIR=/path/to/custom/linux

echo -n 'Hello, World!' > /proc/lttng-logger

git clone git://git.urcu.so/urcu.git
cd urcu
./bootstrap
./configure --libdir=/usr/lib32 CFLAGS=-m32
make
sudo make install
sudo ldconfig

git clone http://git.lttng.org/lttng-ust.git
cd lttng-ust
./bootstrap
./configure --prefix=/usr \
          --libdir=/usr/lib32 \
          CFLAGS=-m32 CXXFLAGS=-m32 \
          LDFLAGS=-L/usr/lib32
make
sudo make install
sudo ldconfig

git clone http://git.lttng.org/lttng-tools.git
cd lttng-ust
./bootstrap
./configure --prefix=/usr \
          --libdir=/usr/lib32 CFLAGS=-m32 CXXFLAGS=-m32 \
          LDFLAGS=-L/usr/lib32
make
cd src/bin/lttng-consumerd
sudo make install
sudo ldconfig

make clean
./bootstrap
./configure --prefix=/usr \
          --with-consumerd32-libdir=/usr/lib32 \
          --with-consumerd32-bin=/usr/lib32/lttng/libexec/lttng-consumerd
make
sudo make install
sudo ldconfig

gcc -o hello64 -I. hello.c hello-tp.c -ldl -llttng-ust

gcc -o hello32 -I. -m32 hello.c hello-tp.c -L/usr/lib32 \
  -ldl -llttng-ust -Wl,-rpath,/usr/lib32

lttng create session-3264
lttng enable-event -u -a
./hello32
./hello64
lttng stop

lttng create my-session

lttng create --output /tmp/some-directory my-session

lttng create other-session
lttng create yet-another-session

lttng list

lttng set-session other-session

lttng destroy my-session

lttng enable-event -u --tracepoint my_app:hello_world
lttng enable-event -u --tracepoint my_app:hello_you --loglevel TRACE_WARNING
lttng enable-event -u --tracepoint 'my_other_app:*'
lttng enable-event -u --tracepoint my_app:foo_bar \
                 --filter 'some_field <= 23 && !other_field'
lttng enable-event -k --tracepoint sched_switch
lttng enable-event -k --tracepoint gpio_value
lttng enable-event -k --function usb_probe_device usb_probe_device
lttng enable-event -k --syscall --all

lttng enable-event -k --syscall open
lttng enable-event -k --syscall read
lttng enable-event -k --syscall fork,chdir,pipe

lttng list --kernel --syscall

lttng list some-session

lttng enable-event -u --tracepoint my_app:hello_you
lttng enable-event -u --tracepoint my_app:hello_you --loglevel TRACE_DEBUG

lttng disable-event --userspace my_app:hello_you

lttng start

lttng stop

lttng list some-session

lttng enable-channel --kernel my-channel

lttng enable-channel --userspace --session other-session --overwrite \
                   --tracefile-size 1048576 1mib-channel

lttng enable-event --kernel --channel some-channel sched_switch

lttng enable-event --userspace --channel my-channel app:tp
lttng enable-event --userspace --channel other-channel app:tp

lttng disable-event --kernel some-channel

lttng enable-channel --kernel --overwrite my-channel

lttng enable-channel --userspace --num-subbuf 16 --subbuf-size 512k big-channel

lttng enable-channel --kernel --tracefile-size 1M --tracefile-count 3 my-channel

lttng enable-event --kernel --all --channel my-channel
lttng start
my-channel_0_0    my-channel_1_0
my-channel_0_1    my-channel_1_1
my-channel_0_2    my-channel_1_2

lttng add-context --userspace --type vpid --type perf:thread:cpu-cycles

lttng add-context --kernel --channel my-channel --type tid

lttng save my-session

lttng load my-session

lttng load --input-path /path/to/my-session.lttng

lttng-relayd

lttng create my-session --set-url net://distant-host

lttng create --live

lttng create --live 100000

lttng view

babeltrace --input-format lttng-live net://localhost

babeltrace --input-format lttng-live net://localhost/host/hostname/my-session

lttng create --snapshot my-snapshot-session

lttng snapshot record --name my-snapshot

lttng snapshot record --name my-snapshot --max-size 2M

lttng --mi xml create some-session
lttng --mi xml list some-session
lttng --mi xml list --kernel
lttng --mi xml enable-event --kernel --syscall open
lttng --mi xml start

TP provider name	TP name	Instrumented function
`ust_libc`	`malloc`	`malloc()`
	`calloc`	`calloc()`
	`realloc`	`realloc()`
	`free`	`free()`
	`memalign`	`memalign()`
	`posix_memalign`	`posix_memalign()`

TP provider name	TP name	Instrumented function
`ust_pthread`	`pthread_mutex_lock_req`	`pthread_mutex_lock()` (request time)
	`pthread_mutex_lock_acq`	`pthread_mutex_lock()` (acquire time)
	`pthread_mutex_trylock`	`pthread_mutex_trylock()`
	`pthread_mutex_unlock`	`pthread_mutex_unlock()`

Macro	Description and parameters
`__field(t, n)`	Standard integer, displayed in base 10. `t` Integer C type (`int`, `unsigned char`, `size_t`, …). `n` Field name.
`__field_hex(t, n)`	Standard integer, displayed in base 16. `t` Integer C type. `n` Field name.
`__field_oct(t, n)`	Standard integer, displayed in base 8. `t` Integer C type. `n` Field name.
`__field_network(t, n)`	Integer in network byte order (big endian), displayed in base 10. `t` Integer C type. `n` Field name.
`__field_network_hex(t, n)`	Integer in network byte order (big endian), displayed in base 16. `t` Integer C type. `n` Field name.
`__array(t, n, s)`	Statically-sized array, elements displayed in base 10. `t` Array element C type. `n` Field name. `s` Number of elements.
`__array_hex(t, n, s)`	Statically-sized array, elements displayed in base 16. `t` array element C type. `n` field name. `s` number of elements.
`__array_text(t, n, s)`	Statically-sized array, displayed as text. `t` Array element C type (always char). `n` Field name. `s` Number of elements.
`__dynamic_array(t, n, s)`	Dynamically-sized array, displayed in base 10. `t` Array element C type. `n` Field name. `s` Length C expression.
`__dynamic_array_hex(t, n, s)`	Dynamically-sized array, displayed in base 16. `t` Array element C type. `n` Field name. `s` Length C expression.
`__dynamic_array_text(t, n, s)`	Dynamically-sized array, displayed as text. `t` Array element C type (always char). `n` Field name. `s` Length C expression.
`__string(n, s)`	Null-terminated string. The behaviour is undefined behavior if `s` is `NULL`. `n` Field name. `s` String source (pointer).

Macro	Description and parameters
`tp_assign(d, s)`	Assignment of C expression `s` to tracepoint field `d`. `d` Name of destination tracepoint field. `s` Source C expression (may refer to tracepoint arguments).
`tp_memcpy(d, s, l)`	Memory copy of `l` bytes from `s` to tracepoint field `d` (use with array fields). `d` Name of destination tracepoint field. `s` Source C expression (may refer to tracepoint arguments). `l` Number of bytes to copy.
`tp_memcpy_from_user(d, s, l)`	Memory copy of `l` bytes from user space `s` to tracepoint field `d` (use with array fields). `d` Name of destination tracepoint field. `s` Source C expression (may refer to tracepoint arguments). `l` Number of bytes to copy.
`tp_memcpy_dyn(d, s)`	Memory copy of dynamically-sized array from `s` to tracepoint field `d`. The number of bytes is known from the field’s length expression (use with dynamically-sized array fields). `d` Name of destination tracepoint field. `s` Source C expression (may refer to tracepoint arguments). `l` Number of bytes to copy.
`tp_strcpy(d, s)`	String copy of `s` to tracepoint field `d` (use with string fields). `d` Name of destination tracepoint field. `s` Source C expression (may refer to tracepoint arguments).

Docs/2.6

Options

The LTTng Documentation

Welcome!

Target audience

Chapter descriptions

Convention

Acknowledgements