Docs/2.13

Linux Trace Toolkit: next generation

$
#
echo Command line as a regular user
echo Command line as a the `root` user
#
#
#
apt-get install lttng-tools
apt-get install lttng-modules-dkms
apt-get install liblttng-ust-dev
#
apt-get install liblttng-ust-agent-java
#
apt-get install python3-lttngust
#
#
apt-add-repository ppa:lttng/stable-2.13
apt-get update
#
#
#
apt-get install lttng-tools
apt-get install lttng-modules-dkms
apt-get install liblttng-ust-dev
#
apt-get install liblttng-ust-agent-java
#
apt-get install python3-lttngust
#
#
#
apt install lttng-modules-dkms
apt install liblttng-ust-dev
apt install lttng-tools
#
apt install liblttng-ust-agent-java
#
apt install python3-lttngust
#
#
yum install lttng-tools
yum install lttng-ust
$

cd $(mktemp -d) &&
wget http://lttng.org/files/lttng-modules/lttng-modules-latest-2.13.tar.bz2 &&
tar -xf lttng-modules-latest-2.13.tar.bz2 &&
cd lttng-modules-2.13.* &&
make &&
sudo make modules_install &&
sudo depmod -a
#
$
$
pacman -Sy lttng-ust
yay -Sy lttng-tools
yay -Sy lttng-modules
#
pacman -Sy python-lttngust
#
#
apk add lttng-tools
apk add lttng-ust-dev
$

cd $(mktemp -d) &&
wget http://lttng.org/files/lttng-modules/lttng-modules-latest-2.13.tar.bz2 &&
tar -xf lttng-modules-latest-2.13.tar.bz2 &&
cd lttng-modules-2.13.* &&
make &&
sudo make modules_install &&
sudo depmod -a
$
make menuconfig
IMAGE_INSTALL_append = " lttng-tools lttng-modules lttng-ust"
$

cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-modules/lttng-modules-latest-2.13.tar.bz2 &&
tar -xf lttng-modules-latest-2.13.tar.bz2 &&
cd lttng-modules-2.13.* &&
make &&
sudo make modules_install &&
sudo depmod -a
$

cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-ust/lttng-ust-latest-2.13.tar.bz2 &&
tar -xf lttng-ust-latest-2.13.tar.bz2 &&
cd lttng-ust-2.13.* &&
./configure &&
make &&
sudo make install &&
sudo ldconfig
$

cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-tools/lttng-tools-latest-2.13.tar.bz2 &&
tar -xf lttng-tools-latest-2.13.tar.bz2 &&
cd lttng-tools-2.13.* &&
./configure &&
make &&
sudo make install &&
sudo ldconfig
#

lttng-sessiond
Warning: No tracing group detected
modprobe: ERROR: could not insert 'lttng_ring_buffer_client_discard': Key was rejected by service
Error: Unable to load required module lttng-ring-buffer-client-discard
Warning: No kernel tracer available
#
lttng create my-kernel-session --output=/tmp/my-kernel-trace
#
#
lttng list --kernel
lttng list --kernel --syscall
#
#
lttng enable-event --kernel sched_switch,sched_process_fork
lttng enable-event --kernel --syscall open,close
#
lttng enable-event --kernel --all
#
lttng start
#
lttng destroy
#
chown -R $(whoami) /tmp/my-kernel-trace
#undef LTTNG_UST_TRACEPOINT_PROVIDER
#define LTTNG_UST_TRACEPOINT_PROVIDER hello_world

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

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

#include <lttng/tracepoint.h>

LTTNG_UST_TRACEPOINT_EVENT(
    hello_world,
    my_first_tracepoint,
    LTTNG_UST_TP_ARGS(
        int, my_integer_arg,
        char *, my_string_arg
    ),
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_string(my_string_field, my_string_arg)
        lttng_ust_field_integer(int, my_integer_field, my_integer_arg)
    )
)

#endif /* _HELLO_TP_H */

#include <lttng/tracepoint-event.h>

#define LTTNG_UST_TRACEPOINT_CREATE_PROBES
#define LTTNG_UST_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[])
{
    unsigned int i;

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

    /*
     * The following getchar() call only exists for the purpose of this
     * demonstration, to pause the application in order for you to have
     * time to list its tracepoints. You don't need it otherwise.
     */
    getchar();

    /*
     * An lttng_ust_tracepoint() call.
     *
     * Arguments, as defined in `hello-tp.h`:
     *
     * 1. Tracepoint provider name (required)
     * 2. Tracepoint name (required)
     * 3. `my_integer_arg` (first user-defined argument)
     * 4. `my_string_arg` (second user-defined argument)
     *
     * Notice the tracepoint provider and tracepoint names are
     * C identifiers, NOT strings: they're in fact parts of variables
     * that the macros in `hello-tp.h` create.
     */
    lttng_ust_tracepoint(hello_world, my_first_tracepoint, 23,
                         "hi there!");

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

    puts("Quitting now!");
    lttng_ust_tracepoint(hello_world, my_first_tracepoint,
                         i * i, "i^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-sessiond --daemonize
$
lttng list --userspace
$
lttng create my-user-space-session
$
lttng enable-event --userspace hello_world:my_first_tracepoint
$
lttng start
$
lttng destroy
$
babeltrace2 ~/lttng-traces/my-user-space-session*
$
babeltrace2 /tmp/my-kernel-trace | grep _switch
$
babeltrace2 /tmp/my-kernel-trace | grep _open | wc --lines
import bt2
import sys
import collections

def top5proc():
    # Get the trace path from the first command-line argument
    it = bt2.TraceCollectionMessageIterator(sys.argv[1])

    # This counter dictionary will hold execution times:
    #
    #     Task command name -> Total execution time (ns)
    exec_times = collections.Counter()

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

    for msg in it:
        # We only care about event messages
        if type(msg) is not bt2._EventMessageConst:
            continue

        # Event of the event message
        event = msg.event

        # Keep only `sched_switch` events
        if event.cls.name != 'sched_switch':
            continue

        # Keep only records of events which LTTng emitted from CPU 0
        if event.packet.context_field['cpu_id'] != 0:
            continue

        # Event timestamp (ns)
        cur_ts = msg.default_clock_snapshot.ns_from_origin

        if last_ts is None:
            # Start here
            last_ts = cur_ts

        # (Short) name of the previous task command
        prev_comm = str(event.payload_field['prev_comm'])

        # Initialize an entry in our dictionary if not done yet
        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

    # Print top 5
    for name, ns in exec_times.most_common(5):
        print('{:20}{} s'.format(name, ns / 1e9))

if __name__ == '__main__':
    top5proc()

$
python3 top5proc.py /tmp/my-kernel-trace/kernel
swapper/0           48.607245889 s
chromium            7.192738188 s
pavucontrol         0.709894415 s
Compositor          0.660867933 s
Xorg.bin            0.616753786 s
$
$
lttng enable-event --userspace hello:world
lttng enable-event --userspace hello:world --loglevel=INFO
$
lttng [GENERAL OPTIONS] <COMMAND> [COMMAND OPTIONS]
#include <lttng/lttng.h>

#undef LTTNG_UST_TRACEPOINT_PROVIDER
#define LTTNG_UST_TRACEPOINT_PROVIDER provider_name

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

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

#include <lttng/tracepoint.h>

/*
 * Use LTTNG_UST_TRACEPOINT_EVENT(), LTTNG_UST_TRACEPOINT_EVENT_CLASS(),
 * LTTNG_UST_TRACEPOINT_EVENT_INSTANCE(), and
 * LTTNG_UST_TRACEPOINT_LOGLEVEL() here.
 */

#endif /* _TP_H */

#include <lttng/tracepoint-event.h>

LTTNG_UST_TRACEPOINT_EVENT(
    /* Tracepoint provider name */
    provider_name,

    /* Tracepoint name */
    tracepoint_name,

    /* Input arguments */
    LTTNG_UST_TP_ARGS(
        arguments
    ),

    /* Output event fields */
    LTTNG_UST_TP_FIELDS(
        fields
    )
)

LTTNG_UST_TP_ARGS(
    type, arg_name
)

LTTNG_UST_TP_ARGS(
    int, count,
    float, ratio,
    const char*, query
)

#include "my-custom-structure.h"

LTTNG_UST_TRACEPOINT_EVENT(
    my_provider,
    my_tracepoint,
    LTTNG_UST_TP_ARGS(
        const struct my_custom_structure *, my_custom_structure,
        float, ratio,
        const char *, query
    ),
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_string(query_field, query)
        lttng_ust_field_float(double, ratio_field, ratio)
        lttng_ust_field_integer(int, recv_size,
                                my_custom_structure->recv_size)
        lttng_ust_field_integer(int, send_size,
                                my_custom_structure->send_size)
    )
)

lttng_ust_tracepoint(my_provider, my_tracepoint,
                     my_structure, some_ratio, the_query);

LTTNG_UST_TRACEPOINT_EVENT(
    my_app,
    get_account,
    LTTNG_UST_TP_ARGS(
        int, userid,
        size_t, len
    ),
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_integer(int, userid, userid)
        lttng_ust_field_integer(size_t, len, len)
    )
)

LTTNG_UST_TRACEPOINT_EVENT(
    my_app,
    get_settings,
    LTTNG_UST_TP_ARGS(
        int, userid,
        size_t, len
    ),
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_integer(int, userid, userid)
        lttng_ust_field_integer(size_t, len, len)
    )
)

LTTNG_UST_TRACEPOINT_EVENT(
    my_app,
    get_transaction,
    LTTNG_UST_TP_ARGS(
        int, userid,
        size_t, len
    ),
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_integer(int, userid, userid)
        lttng_ust_field_integer(size_t, len, len)
    )
)

/* The tracepoint class */
LTTNG_UST_TRACEPOINT_EVENT_CLASS(
    /* Tracepoint class provider name */
    my_app,

    /* Tracepoint class name */
    my_class,

    /* Input arguments */
    LTTNG_UST_TP_ARGS(
        int, userid,
        size_t, len
    ),

    /* Output event fields */
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_integer(int, userid, userid)
        lttng_ust_field_integer(size_t, len, len)
    )
)

/* The tracepoint instances */
LTTNG_UST_TRACEPOINT_EVENT_INSTANCE(
    /* Tracepoint class provider name */
    my_app,

    /* Tracepoint class name */
    my_class,

    /* Instance provider name */
    my_app,

    /* Tracepoint name */
    get_account,

    /* Input arguments */
    LTTNG_UST_TP_ARGS(
        int, userid,
        size_t, len
    )
)
LTTNG_UST_TRACEPOINT_EVENT_INSTANCE(
    my_app,
    my_class,
    get_settings,
    LTTNG_UST_TP_ARGS(
        int, userid,
        size_t, len
    )
)
LTTNG_UST_TRACEPOINT_EVENT_INSTANCE(
    my_app,
    my_class,
    get_transaction,
    LTTNG_UST_TP_ARGS(
        int, userid,
        size_t, len
    )
)

LTTNG_UST_TRACEPOINT_LOGLEVEL(provider_name, tracepoint_name, log_level)

/* Tracepoint definition */
LTTNG_UST_TRACEPOINT_EVENT(
    my_app,
    get_transaction,
    LTTNG_UST_TP_ARGS(
        int, userid,
        size_t, len
    ),
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_integer(int, userid, userid)
        lttng_ust_field_integer(size_t, len, len)
    )
)

/* Log level assignment */
LTTNG_UST_TRACEPOINT_LOGLEVEL(my_app, get_transaction,
                              LTTNG_UST_TRACEPOINT_LOGLEVEL_DEBUG_UNIT)

#define LTTNG_UST_TRACEPOINT_CREATE_PROBES

#include "tp.h"

#include "my-custom-structure.h"

LTTNG_UST_TRACEPOINT_EVENT(
    my_provider,
    my_tracepoint,
    LTTNG_UST_TP_ARGS(
        int, argc,
        const char *, cmd_name
    ),
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_string(cmd_name, cmd_name)
        lttng_ust_field_integer(int, number_of_args, argc)
    )
)

#include "tp.h"

int main(int argc, char* argv[])
{
    lttng_ust_tracepoint(my_provider, my_tracepoint, argc, argv[0]);
    return 0;
}

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

LTTNG_UST_TRACEPOINT_EVENT(
    my_provider,
    my_tracepoint,
    LTTNG_UST_TP_ARGS(
        int, my_int_arg,
        char *, my_str_arg,
        struct stat *, st
    ),
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_integer(int, my_constant_field, 23 + 17)
        lttng_ust_field_integer(int, my_int_arg_field, my_int_arg)
        lttng_ust_field_integer(int, my_int_arg_field2,
                                my_int_arg * my_int_arg)
        lttng_ust_field_integer(int, sum4_field,
                                my_str_arg[0] + my_str_arg[1] +
                                my_str_arg[2] + my_str_arg[3])
        lttng_ust_field_string(my_str_arg_field, my_str_arg)
        lttng_ust_field_integer_hex(off_t, size_field, st->st_size)
        lttng_ust_field_float(double, size_dbl_field, (double) st->st_size)
        lttng_ust_field_sequence_text(char, half_my_str_arg_field,
                                      my_str_arg, size_t,
                                      strlen(my_str_arg) / 2)
    )
)

#define LTTNG_UST_TRACEPOINT_DEFINE
#include "tp.h"

int main(void)
{
    struct stat s;

    stat("/etc/fstab", &s);
    lttng_ust_tracepoint(my_provider, my_tracepoint, 23,
                         "Hello, World!", &s);

    return 0;
}

lttng_ust_tracepoint_enabled(provider_name, tracepoint_name)

lttng_ust_do_tracepoint(provider_name, tracepoint_name, ...)

if (lttng_ust_tracepoint_enabled(my_provider, my_tracepoint)) {
    stuff = prepare_stuff();
}

lttng_ust_tracepoint(my_provider, my_tracepoint, stuff);

$
gcc -I. -c tpp.c
#define LTTNG_UST_TRACEPOINT_DEFINE

$
gcc -c app.c
$
gcc -o app app.o tpp.o -llttng-ust -ldl
$
./app
$
gcc -I. -c tpp.c
$
ar rcs tpp.a tpp.o
#define LTTNG_UST_TRACEPOINT_DEFINE

$
gcc -c app.c
$
gcc -o app app.o tpp.a -llttng-ust -ldl
$
./app
$
gcc -I. -fpic -c tpp.c
$
gcc -shared -o libtpp.so tpp.o -llttng-ust -ldl
#define LTTNG_UST_TRACEPOINT_DEFINE

$
gcc -c app.c
$
gcc -o app app.o -ldl -L. -ltpp
$
./app
$
gcc -I. -fpic -c tpp.c
$
gcc -shared -o libtpp.so tpp.o -llttng-ust -ldl
#define LTTNG_UST_TRACEPOINT_DEFINE
#define LTTNG_UST_TRACEPOINT_PROBE_DYNAMIC_LINKAGE

$
gcc -c app.c
$
gcc -o app app.o -ldl
$
LD_PRELOAD=./libtpp.so ./app
$
./app
$
gcc -I. -fpic -c tpp.c
$
gcc -shared -o libtpp.so tpp.o -llttng-ust -ldl
#define LTTNG_UST_TRACEPOINT_DEFINE
#define LTTNG_UST_TRACEPOINT_PROBE_DYNAMIC_LINKAGE

$
gcc -c app.c
$
gcc -o app app.o -ldl
$
./app
$
gcc -I. -fpic -c tpp.c
#define LTTNG_UST_TRACEPOINT_DEFINE

$
gcc -I. -fpic -c emon.c
$
gcc -shared -o libemon.so emon.o tpp.o -llttng-ust -ldl
$
gcc -c app.c
$
gcc -o app app.o -L. -lemon
$
./app
$
gcc -I. -fpic -c tpp.c
$
gcc -shared -o libtpp.so tpp.o -llttng-ust -ldl
#define LTTNG_UST_TRACEPOINT_DEFINE

$
gcc -I. -fpic -c emon.c
$
gcc -shared -o libemon.so emon.o -ldl -L. -ltpp
$
gcc -c app.c
$
gcc -o app app.o -L. -lemon
$
./app
$
gcc -I. -fpic -c tpp.c
$
gcc -shared -o libtpp.so tpp.o -llttng-ust -ldl
#define LTTNG_UST_TRACEPOINT_DEFINE
#define LTTNG_UST_TRACEPOINT_PROBE_DYNAMIC_LINKAGE

$
gcc -I. -fpic -c emon.c
$
gcc -shared -o libemon.so emon.o -ldl
$
gcc -c app.c
$
gcc -o app app.o -L. -lemon
$
LD_PRELOAD=./libtpp.so ./app
$
./app
$
gcc -I. -fpic -c tpp.c
$
gcc -shared -o libtpp.so tpp.o -llttng-ust -ldl
#define LTTNG_UST_TRACEPOINT_DEFINE
#define LTTNG_UST_TRACEPOINT_PROBE_DYNAMIC_LINKAGE

$
gcc -I. -fpic -c emon.c
$
gcc -shared -o libemon.so emon.o -ldl
$
gcc -c app.c
$
gcc -o app app.o -L. -lemon
$
./app
$
gcc -I. -fpic -c tpp.c
$
gcc -shared -o libtpp.so tpp.o -llttng-ust -ldl
#define LTTNG_UST_TRACEPOINT_DEFINE

$
gcc -I. -fpic -c emon.c
$
gcc -shared -o libemon.so emon.o -ldl -L. -ltpp
$
gcc -c app.c
$
gcc -o app app.o -ldl -L. -lemon
$
./app
$
gcc -I. -fpic -c tpp.c
$
gcc -shared -o libtpp.so tpp.o -llttng-ust -ldl
#define LTTNG_UST_TRACEPOINT_DEFINE
#define LTTNG_UST_TRACEPOINT_PROBE_DYNAMIC_LINKAGE

$
gcc -I. -fpic -c emon.c
$
gcc -shared -o libemon.so emon.o -ldl
$
gcc -c app.c
$
gcc -o app app.o -ldl -L. -lemon
$
./app
$
gcc -I. -fpic -c tpp.c
$
gcc -shared -o libtpp.so tpp.o -llttng-ust -ldl
#define LTTNG_UST_TRACEPOINT_DEFINE
#define LTTNG_UST_TRACEPOINT_PROBE_DYNAMIC_LINKAGE

$
gcc -I. -fpic -c emon.c
$
gcc -shared -o libemon.so emon.o -ldl
$
gcc -c app.c
$
gcc -o app app.o -L. -lemon
$
LD_PRELOAD=./libtpp.so ./app
$
./app
$
gcc -I. -c tpp.c
#define LTTNG_UST_TRACEPOINT_DEFINE

$
gcc -I. -fpic -c emon.c
$
gcc -shared -o libemon.so emon.o
$
gcc -c app.c
$
gcc -o app app.o tpp.o -llttng-ust -ldl -L. -lemon
$
./app
$
gcc -I. -c tpp.c
#define LTTNG_UST_TRACEPOINT_DEFINE

$
gcc -c app.c
$

gcc -Wl,--export-dynamic -o app app.o tpp.o \
    -llttng-ust -ldl
$
gcc -I. -fpic -c emon.c
$
gcc -shared -o libemon.so emon.o
$
./app
$
LD_PRELOAD=liblttng-ust-fork.so ./my-app
$
LD_PRELOAD=liblttng-ust-fork.so:/path/to/tp.so ./my-app
$
LD_PRELOAD=liblttng-ust-fd.so ./my-app
$
gcc -o my-app my-app.o tp.o $(pkg-config --cflags --libs lttng-ust)
$

cd $(mktemp -d) &&
wget https://lttng.org/files/urcu/userspace-rcu-latest-0.13.tar.bz2 &&
tar -xf userspace-rcu-latest-0.13.tar.bz2 &&
cd userspace-rcu-0.13.* &&
./configure --libdir=/usr/local/lib32 CFLAGS=-m32 &&
make &&
sudo make install &&
sudo ldconfig
$

cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-ust/lttng-ust-latest-2.13.tar.bz2 &&
tar -xf lttng-ust-latest-2.13.tar.bz2 &&
cd lttng-ust-2.13.* &&
./configure --libdir=/usr/local/lib32 \
            CFLAGS=-m32 CXXFLAGS=-m32 \
            LDFLAGS='-L/usr/local/lib32 -L/usr/lib32' &&
make &&
sudo make install &&
sudo ldconfig
$
LDFLAGS='-L/usr/lib/i386-linux-gnu -L/usr/lib32'
$

cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-tools/lttng-tools-latest-2.13.tar.bz2 &&
tar -xf lttng-tools-latest-2.13.tar.bz2 &&
cd lttng-tools-2.13.* &&
./configure --libdir=/usr/local/lib32 CFLAGS=-m32 CXXFLAGS=-m32 \
            LDFLAGS='-L/usr/local/lib32 -L/usr/lib32' \
            --disable-bin-lttng --disable-bin-lttng-crash \
            --disable-bin-lttng-relayd --disable-bin-lttng-sessiond &&
make &&
cd src/bin/lttng-consumerd &&
sudo make install &&
sudo ldconfig
$

cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-tools/lttng-tools-latest-2.13.tar.bz2 &&
tar -xf lttng-tools-latest-2.13.tar.bz2 &&
cd lttng-tools-2.13.* &&
./configure --with-consumerd32-libdir=/usr/local/lib32 \
            --with-consumerd32-bin=/usr/local/lib32/lttng/libexec/lttng-consumerd &&
make &&
sudo make install &&
sudo ldconfig
-m32 -L/usr/lib32 -L/usr/local/lib32 \
-Wl,-rpath,/usr/lib32,-rpath,/usr/local/lib32
$
$
$

gcc -m32 -c -I. hello-tp.c
gcc -m32 -c hello.c
gcc -m32 -o hello hello.o hello-tp.o \
    -L/usr/lib32 -L/usr/local/lib32 \
    -Wl,-rpath,/usr/lib32,-rpath,/usr/local/lib32 \
    -llttng-ust -ldl
#include <lttng/tracef.h>

    /* ... */

    lttng_ust_tracef("my message: %d (%s)", my_integer, my_string);

    /* ... */

$
gcc -o app app.c -llttng-ust
$
lttng enable-event --userspace 'lttng_ust_tracef:*'
#include <lttng/tracelog.h>

    /* ... */

    tracelog(LTTNG_UST_TRACEPOINT_LOGLEVEL_WARNING,
            "my message: %d (%s)", my_integer, my_string);

    /* ... */

$
gcc -o app app.c -llttng-ust
$

lttng enable-event --userspace 'lttng_ust_tracelog:*' \
                   --loglevel=WARNING
$

lttng enable-event --userspace 'lttng_ust_tracelog:*' \
                   --loglevel-only=INFO
$
LD_PRELOAD=liblttng-ust-libc-wrapper.so my-app
$
LD_PRELOAD=liblttng-ust-libc-wrapper.so:liblttng-ust-dl.so my-app
import org.lttng.ust.agent.jul.LttngLogHandler;

Handler lttngUstLogHandler = new LttngLogHandler();

Logger myLogger = Logger.getLogger("some-logger");

myLogger.addHandler(lttngUstLogHandler);

myLogger.removeHandler(lttngUstLogHandler);
lttngUstLogHandler.close();

import java.io.IOException;
import java.util.logging.Handler;
import java.util.logging.Logger;
import org.lttng.ust.agent.jul.LttngLogHandler;

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");

        // Create an LTTng-UST log handler
        Handler lttngUstLogHandler = new LttngLogHandler();

        // Add the LTTng-UST log handler to our logger
        logger.addHandler(lttngUstLogHandler);

        // 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
        logger.removeHandler(lttngUstLogHandler);
        lttngUstLogHandler.close();
    }
}

$
javac -cp /usr/share/java/jarpath/lttng-ust-agent-common.jar:/usr/share/java/jarpath/lttng-ust-agent-jul.jar Test.java
$
$
$
lttng create
lttng enable-event --jul jello
lttng start
$
java -cp /usr/share/java/jarpath/lttng-ust-agent-common.jar:/usr/share/java/jarpath/lttng-ust-agent-jul.jar:. Test
$
$
lttng stop
lttng view
import org.lttng.ust.agent.log4j.LttngLogAppender;

Appender lttngUstLogAppender = new LttngLogAppender();

Logger myLogger = Logger.getLogger("some-logger");

myLogger.addAppender(lttngUstLogAppender);

myLogger.removeAppender(lttngUstLogAppender);
lttngUstLogAppender.close();

import org.apache.log4j.Appender;
import org.apache.log4j.Logger;
import org.lttng.ust.agent.log4j.LttngLogAppender;

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");

        // Create an LTTng-UST log appender
        Appender lttngUstLogAppender = new LttngLogAppender();

        // Add the LTTng-UST log appender to our logger
        logger.addAppender(lttngUstLogAppender);

        // 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.fatal("error!");

        // Not mandatory, but cleaner
        logger.removeAppender(lttngUstLogAppender);
        lttngUstLogAppender.close();
    }
}

$
javac -cp /usr/share/java/jarpath/lttng-ust-agent-common.jar:/usr/share/java/jarpath/lttng-ust-agent-log4j.jar:$LOG4JPATH Test.java
$
$
$
lttng create
lttng enable-event --log4j jello
lttng start
$
java -cp /usr/share/java/jarpath/lttng-ust-agent-common.jar:/usr/share/java/jarpath/lttng-ust-agent-log4j.jar:$LOG4JPATH:. Test
$
$
lttng stop
lttng view
import org.lttng.ust.agent.context.ContextInfoManager;
import org.lttng.ust.agent.context.IContextInfoRetriever;

class MyContextInfoRetriever implements IContextInfoRetriever
{
    @Override
    public Object retrieveContextInfo(String key)
    {
        if (key.equals("intCtx")) {
            return (short) 17;
        } else if (key.equals("strContext")) {
            return "context value!";
        } else {
            return null;
        }
    }
}

IContextInfoRetriever cir = new MyContextInfoRetriever();
ContextInfoManager cim = ContextInfoManager.getInstance();
cim.registerContextInfoRetriever("retrieverName", cir);

ContextInfoManager cim = ContextInfoManager.getInstance();
cim.unregisterContextInfoRetriever("retrieverName");

import java.util.logging.Handler;
import java.util.logging.Logger;
import org.lttng.ust.agent.jul.LttngLogHandler;
import org.lttng.ust.agent.context.ContextInfoManager;
import org.lttng.ust.agent.context.IContextInfoRetriever;

public class Test
{
    // Our context information retriever class
    private static class MyContextInfoRetriever
    implements IContextInfoRetriever
    {
        @Override
        public Object retrieveContextInfo(String key) {
            if (key.equals("intCtx")) {
                return (short) 17;
            } else if (key.equals("strContext")) {
                return "context value!";
            } else {
                return null;
            }
        }
    }

    private static final int answer = 42;

    public static void main(String args[]) throws Exception
    {
        // Get the context information manager instance
        ContextInfoManager cim = ContextInfoManager.getInstance();

        // Create and register our context information retriever
        IContextInfoRetriever cir = new MyContextInfoRetriever();
        cim.registerContextInfoRetriever("myRetriever", cir);

        // Create a logger
        Logger logger = Logger.getLogger("jello");

        // Create an LTTng-UST log handler
        Handler lttngUstLogHandler = new LttngLogHandler();

        // Add the LTTng-UST log handler to our logger
        logger.addHandler(lttngUstLogHandler);

        // 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
        logger.removeHandler(lttngUstLogHandler);
        lttngUstLogHandler.close();
        cim.unregisterContextInfoRetriever("myRetriever");
    }
}

$
javac -cp /usr/share/java/jarpath/lttng-ust-agent-common.jar:/usr/share/java/jarpath/lttng-ust-agent-jul.jar Test.java
$
$
lttng create
lttng enable-event --jul jello
$
$
lttng add-context --jul --type='$app.myRetriever:intCtx'
lttng add-context --jul --type='$app.myRetriever:strContext'
$
lttng start
$
java -cp /usr/share/java/jarpath/lttng-ust-agent-common.jar:/usr/share/java/jarpath/lttng-ust-agent-jul.jar:. Test
$
$
lttng stop
lttng view
import lttngust

import lttngust
import logging
import time

def example():
    logging.basicConfig()
    logger = logging.getLogger('my-logger')

    while True:
        logger.debug('debug message')
        logger.info('info message')
        logger.warn('warn message')
        logger.error('error message')
        logger.critical('critical message')
        time.sleep(1)

if __name__ == '__main__':
    example()

$
$
$
lttng create
lttng enable-event --python my-logger
lttng start
$
python test.py
$
$
lttng stop
lttng view
$
echo "Some message, some $variable" > /dev/lttng-logger
echo 'Hello, World!' > /dev/lttng-logger
sleep 2
df --human-readable --print-type / > /dev/lttng-logger

$
$
$
lttng create
lttng enable-event --kernel lttng_logger
lttng start
$
bash test.bash
$
$
lttng stop
lttng view
$

cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-modules/lttng-modules-latest-2.13.tar.bz2 &&
tar -xf lttng-modules-latest-2.13.tar.bz2 &&
cd lttng-modules-2.13.*
#undef TRACE_SYSTEM
#define TRACE_SYSTEM my_subsys

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

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

LTTNG_TRACEPOINT_EVENT(
    /*
     * Format is identical to the TRACE_EVENT() version for the three
     * following macro parameters:
     */
    my_subsys_my_event,
    TP_PROTO(int my_int, const char *my_string),
    TP_ARGS(my_int, my_string),

    /* LTTng-modules specific macros */
    TP_FIELDS(
        ctf_integer(int, my_int_field, my_int)
        ctf_string(my_bar_field, my_bar)
    )
)

#endif /* !defined(_LTTNG_MY_SUBSYS_H) || defined(TRACE_HEADER_MULTI_READ) */

#include "../../../probes/define_trace.h"

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

/*
 * Build-time verification of mismatch between mainline
 * TRACE_EVENT() arguments and the LTTng-modules adaptation
 * layer LTTNG_TRACEPOINT_EVENT() arguments.
 */
#include <trace/events/my_subsys.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/my_subsys.h"

MODULE_LICENSE("GPL and additional rights");
MODULE_AUTHOR("Your name <your-email>");
MODULE_DESCRIPTION("LTTng my_subsys 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-my-subsys.o

# ...

$
#
make KERNELDIR=/path/to/linux
make modules_install && depmod -a
LTTNG_TRACEPOINT_EVENT_CODE(
    /*
     * Format identical to the LTTNG_TRACEPOINT_EVENT()
     * version for the following three macro parameters:
     */
    my_subsys_my_event,
    TP_PROTO(int my_int, const char *my_string),
    TP_ARGS(my_int, my_string),

    /* Declarations of custom local variables */
    TP_locvar(
        int a = 0;
        unsigned long b = 0;
        const char *name = "(undefined)";
        struct my_struct *my_struct;
    ),

    /*
     * Custom code which uses both tracepoint arguments
     * (in TP_ARGS()) and local variables (in TP_locvar()).
     *
     * Local variables are actually members of a structure pointed
     * to by the special variable tp_locvar.
     */
    TP_code(
        if (my_int) {
            tp_locvar->a = my_int + 17;
            tp_locvar->my_struct = get_my_struct_at(tp_locvar->a);
            tp_locvar->b = my_struct_compute_b(tp_locvar->my_struct);
            tp_locvar->name = my_struct_get_name(tp_locvar->my_struct);
            put_my_struct(tp_locvar->my_struct);

            if (tp_locvar->b) {
                tp_locvar->a = 1;
            }
        }
    ),

    /*
     * Format identical to the LTTNG_TRACEPOINT_EVENT()
     * version for this, except that tp_locvar members can be
     * used in the argument expression parameters of
     * the ctf_*() macros.
     */
    TP_FIELDS(
        ctf_integer(unsigned long, my_struct_b, tp_locvar->b)
        ctf_integer(int, my_struct_a, tp_locvar->a)
        ctf_string(my_string_field, my_string)
        ctf_string(my_struct_name, tp_locvar->name)
    )
)

#
lttng-sessiond --extra-kmod-probes=my_subsys,usb
#
lttng-sessiond --kmod-probes=my_subsys,usb
$
lsmod | grep lttng_probe_usb
#
pkill lttng-sessiond
Error: No session daemon is available
$
lttng-sessiond --daemonize
#
lttng-sessiond --daemonize
$
lttng create
$
lttng create SESSION
$
lttng create my-session --output=/tmp/some-directory
$
lttng list
$
lttng set-session SESSION
$
lttng destroy
$
lttng list --userspace
$
lttng list --kernel --syscall
#
lttng enable-event --kernel sched_switch
#
lttng enable-event --kernel --syscall open,write,read,close
#
lttng enable-event --kernel sched_switch --filter='prev_comm == "bash"'
#

lttng enable-event --kernel --all \
                   --filter='$ctx.tid == 1988 || $ctx.tid == 1534'
$

lttng enable-event --jul my_logger \
                   --filter='$app.retriever:cur_msg_id > 3'
$
lttng enable-event --userspace my_app:'*' --loglevel=INFO
$

lttng enable-event --userspace my_app:'*' \
                   --exclude=my_app:set_user,my_app:handle_sig
$
lttng enable-event --log4j --all --loglevel-only=WARN
$

lttng enable-event --userspace my_app:my_tracepoint \
                   --channel=my-channel
#

lttng enable-event --kernel \
                   --userspace-probe=/usr/lib/libc.so.6:malloc \
                   libc_malloc
#

lttng enable-event --kernel \
                   --userspace-probe=sdt:serv:server:accept_request \
                   server_accept_request
$
$

lttng enable-event --userspace my_app:my_tracepoint
lttng enable-event --userspace my_app:my_tracepoint \
                   --loglevel=INFO
$
lttng disable-event --python my-logger
$
lttng disable-event --jul --session=my-session '*'
#
lttng disable-event --kernel --channel=my-chan --all-events
$
lttng status
$
lttng list SESSION
$
lttng start
$
lttng stop
$
lttng clear
$
lttng clear --all
#
lttng enable-channel --kernel my-channel
$

lttng enable-channel --userspace --num-subbuf=4 --subbuf-size=1M \
                     --buffers-pid my-channel
$
$
$
$
lttng create
lttng enable-channel --userspace --blocking-timeout=inf blocking-chan
lttng enable-event --userspace --channel=blocking-chan --all
lttng start
$
LTTNG_UST_ALLOW_BLOCKING=1 my-app
#

lttng enable-channel --kernel --tracefile-count=8 \
                     --tracefile-size=4194304 my-channel
$
lttng enable-channel --userspace --overwrite my-channel
$
$
lttng enable-event --userspace --channel=my-channel app:tp
lttng enable-event --userspace --channel=other-channel app:tp
#
lttng disable-channel --kernel my-channel
$
lttng add-context --list
$
lttng add-context --userspace --type=vpid --type=perf:thread:cpu-cycles
#
#
lttng add-context --userspace --type=perf:thread:raw:r0110:test
lttng add-context --kernel --type=perf:cpu:raw:r0013c:x86unhalted
#

lttng add-context --kernel --channel=my-channel \
                  --type=tid --type=callstack-user
#

lttng add-context --kernel --channel=my-channel \
                  --type='$app:retriever:cur_msg_id'
$
lttng track --userspace --vpid=3,4,7,10,13
$
lttng track --userspace --vpid=1,15,16
$
lttng untrack --userspace --vpid=3,7,10,13
$
lttng track --userspace --vpid --all
#
lttng untrack --kernel --uid --all
#
lttng track --kernel --uid=http,11
$
lttng save SESSION
$
lttng load SESSION
$
lttng-relayd
$
lttng create my-session --set-url=net://remote-system
$
lttng create my-session --live
$
babeltrace2 net://localhost/host/HOSTNAME/my-session
$
babeltrace2 net://localhost
$
lttng create my-session --snapshot
$
lttng snapshot record --name=my-first-snapshot
$
lttng snapshot list-output
#
lttng create my-session
#
#
lttng enable-event --kernel sched_'*'
lttng start
#
lttng rotate
#
lttng destroy
#
lttng create my-session
#
lttng enable-event --kernel sched_'*'
#
lttng enable-rotation --timer=10s
#
lttng start
#
lttng destroy
#
lttng-sessiond --daemonize
#
#
lttng create pitou
lttng enable-event --kernel --syscall --all
#

lttng add-trigger --condition=event-rule-matches \
                  --type=syscall --name='exec*' \
                  --filter='filename == "*/ls"' \
                  --action=start-session pitou
#
lttng list-triggers
#
lttng list pitou
Recording session pitou: [inactive]
$
ls ~
#
lttng list pitou
Recording session pitou: [active]
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#include <string.h>
#include <lttng/lttng.h>

/*
 * Subscribes to notifications, through the notification channel
 * `notification_channel`, which match the condition of the trigger
 * named `trigger_name`.
 *
 * Returns `true` on success.
 */
static bool subscribe(struct lttng_notification_channel *notification_channel,
                      const char *trigger_name)
{
    const struct lttng_condition *condition = NULL;
    struct lttng_triggers *triggers = NULL;
    unsigned int trigger_count;
    unsigned int i;
    enum lttng_error_code error_code;
    enum lttng_trigger_status trigger_status;
    bool ret = false;

    /* Get all LTTng triggers */
    error_code = lttng_list_triggers(&triggers);
    assert(error_code == LTTNG_OK);

    /* Get the number of triggers */
    trigger_status = lttng_triggers_get_count(triggers, &trigger_count);
    assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);

    /* Find the trigger named `trigger_name` */
    for (i = 0; i < trigger_count; i++) {
        const struct lttng_trigger *trigger;
        const char *this_trigger_name;

        trigger = lttng_triggers_get_at_index(triggers, i);
        trigger_status = lttng_trigger_get_name(trigger, &this_trigger_name);
        assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);

        if (strcmp(this_trigger_name, trigger_name) == 0) {
            /* Trigger found: subscribe with its condition */
            enum lttng_notification_channel_status notification_channel_status;

            notification_channel_status = lttng_notification_channel_subscribe(
                notification_channel,
                lttng_trigger_get_const_condition(trigger));
            assert(notification_channel_status ==
                   LTTNG_NOTIFICATION_CHANNEL_STATUS_OK);
            ret = true;
            break;
        }
    }

    lttng_triggers_destroy(triggers);
    return ret;
}

/*
 * Handles the evaluation `evaluation` of a single notification.
 */
static void handle_evaluation(const struct lttng_evaluation *evaluation)
{
    enum lttng_evaluation_status evaluation_status;
    const struct lttng_event_field_value *array_field_value;
    const struct lttng_event_field_value *string_field_value;
    enum lttng_event_field_value_status event_field_value_status;
    const char *string_field_string_value;

    /* Get the value of the first captured (string) field */
    evaluation_status = lttng_evaluation_event_rule_matches_get_captured_values(
        evaluation, &array_field_value);
    assert(evaluation_status == LTTNG_EVALUATION_STATUS_OK);
    event_field_value_status =
        lttng_event_field_value_array_get_element_at_index(
            array_field_value, 0, &string_field_value);
    assert(event_field_value_status == LTTNG_EVENT_FIELD_VALUE_STATUS_OK);
    assert(lttng_event_field_value_get_type(string_field_value) ==
           LTTNG_EVENT_FIELD_VALUE_TYPE_STRING);
    event_field_value_status = lttng_event_field_value_string_get_value(
            string_field_value, &string_field_string_value);
    assert(event_field_value_status == LTTNG_EVENT_FIELD_VALUE_STATUS_OK);

    /* Print the string value of the field */
    puts(string_field_string_value);
}

int main(int argc, char *argv[])
{
    int exit_status = EXIT_SUCCESS;
    struct lttng_notification_channel *notification_channel;
    enum lttng_notification_channel_status notification_channel_status;
    const struct lttng_condition *condition;
    const char *trigger_name;
    bool subscribe_res;

    assert(argc >= 2);
    trigger_name = argv[1];

    /*
     * Create a notification channel.
     *
     * A notification channel connects the user application to the LTTng
     * session daemon.
     *
     * You can use this notification channel to listen to various types
     * of notifications.
     */
    notification_channel = lttng_notification_channel_create(
        lttng_session_daemon_notification_endpoint);
    assert(notification_channel);

    /*
     * Subscribe to notifications which match the condition of the
     * trigger named `trigger_name`.
     */
    if (!subscribe(notification_channel, trigger_name)) {
        fprintf(stderr,
                "Error: Failed to subscribe to notifications (trigger `%s`).\n",
                trigger_name);
        exit_status = EXIT_FAILURE;
        goto end;
    }

    /*
     * Notification loop.
     *
     * Put this in a dedicated thread to avoid blocking the main thread.
     */
    while (true) {
        struct lttng_notification *notification;
        enum lttng_notification_channel_status status;
        const struct lttng_evaluation *notification_evaluation;

        /* Receive the next notification */
        status = lttng_notification_channel_get_next_notification(
            notification_channel, &notification);

        switch (status) {
        case LTTNG_NOTIFICATION_CHANNEL_STATUS_OK:
            break;
        case LTTNG_NOTIFICATION_CHANNEL_STATUS_NOTIFICATIONS_DROPPED:
            /*
             * The session daemon can drop notifications if a receiving
             * application doesn't consume the notifications fast
             * enough.
             */
            continue;
        case LTTNG_NOTIFICATION_CHANNEL_STATUS_CLOSED:
            /*
             * The session daemon closed the notification channel.
             *
             * This is typically caused by a session daemon shutting
             * down.
             */
            goto end;
        default:
            /* Unhandled conditions or errors */
            exit_status = EXIT_FAILURE;
            goto end;
        }

        /*
         * Handle the condition evaluation.
         *
         * A notification provides, amongst other things:
         *
         * * The condition that caused LTTng to send this notification.
         *
         * * The condition evaluation, which provides more specific
         *   information on the evaluation of the condition.
         */
        handle_evaluation(lttng_notification_get_evaluation(notification));

        /* Destroy the notification object */
        lttng_notification_destroy(notification);
    }

end:
    lttng_notification_channel_destroy(notification_channel);
    return exit_status;
}

$
gcc -o notif-app notif-app.c $(pkg-config --cflags --libs lttng-ctl)
#
lttng-sessiond --daemonize
#

lttng add-trigger --name=sched-switch-notif \
                  --condition=event-rule-matches \
                  --type=kernel --name=sched_switch \
                  --filter='next_comm == "bash"' --capture=prev_comm \
                  --action=notify
#
lttng list-triggers
#
./notif-app sched-switch-notif
$
lttng --mi=xml list my-session
$
lttng regenerate metadata
$
lttng regenerate statedump
$
lttng stop
$
lttng snapshot record --name=my-snapshot
$
lttng create my-session --shm-path=/path/to/shm/on/nvram
$
lttng-crash /path/to/shm/on/nvram
$
lttng-crash --extract=/path/to/trace /path/to/shm/on/nvram
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <lttng/lttng.h>

int main(int argc, char *argv[])
{
    int exit_status = EXIT_SUCCESS;
    struct lttng_notification_channel *notification_channel;
    struct lttng_condition *condition;
    struct lttng_action *action;
    struct lttng_trigger *trigger;
    const char *recording_session_name;
    const char *channel_name;

    assert(argc >= 3);
    recording_session_name = argv[1];
    channel_name = argv[2];

    /*
     * Create a notification channel.
     *
     * A notification channel connects the user application to the LTTng
     * session daemon.
     *
     * You can use this notification channel to listen to various types
     * of notifications.
     */
    notification_channel = lttng_notification_channel_create(
        lttng_session_daemon_notification_endpoint);

    /*
     * Create a "buffer usage becomes greater than" condition.
     *
     * In this case, the condition is satisfied when the buffer usage
     * becomes greater than or equal to 75 %.
     *
     * We create the condition for a specific recording session name,
     * channel name, and for the user space tracing domain.
     *
     * The following condition types also exist:
     *
     * * The buffer usage of a channel becomes less than a given value.
     *
     * * The consumed data size of a recording session becomes greater
     *   than a given value.
     *
     * * A recording session rotation becomes ongoing.
     *
     * * A recording session rotation becomes completed.
     *
     * * A given event rule matches an event.
     */
    condition = lttng_condition_buffer_usage_high_create();
    lttng_condition_buffer_usage_set_threshold_ratio(condition, .75);
    lttng_condition_buffer_usage_set_session_name(condition,
                                                  recording_session_name);
    lttng_condition_buffer_usage_set_channel_name(condition,
                                                  channel_name);
    lttng_condition_buffer_usage_set_domain_type(condition,
                                                 LTTNG_DOMAIN_UST);

    /*
     * Create an action (receive a notification) to execute when the
     * condition created above is satisfied.
     */
    action = lttng_action_notify_create();

    /*
     * Create a trigger.
     *
     * A trigger associates a condition to an action: LTTng executes
     * the action when the condition is satisfied.
     */
    trigger = lttng_trigger_create(condition, action);

    /* Register the trigger to the LTTng session daemon. */
    lttng_register_trigger(trigger);

    /*
     * Now that we have registered a trigger, LTTng will send a
     * notification every time its condition is met through a
     * notification channel.
     *
     * To receive this notification, we must subscribe to notifications
     * which match the same condition.
     */
    lttng_notification_channel_subscribe(notification_channel,
                                         condition);

    /*
     * Notification loop.
     *
     * Put this in a dedicated thread to avoid blocking the main thread.
     */
    for (;;) {
        struct lttng_notification *notification;
        enum lttng_notification_channel_status status;
        const struct lttng_evaluation *notification_evaluation;
        const struct lttng_condition *notification_condition;
        double buffer_usage;

        /* Receive the next notification. */
        status = lttng_notification_channel_get_next_notification(
            notification_channel, &notification);

        switch (status) {
        case LTTNG_NOTIFICATION_CHANNEL_STATUS_OK:
            break;
        case LTTNG_NOTIFICATION_CHANNEL_STATUS_NOTIFICATIONS_DROPPED:
            /*
             * The session daemon can drop notifications if a monitoring
             * application isn't consuming the notifications fast
             * enough.
             */
            continue;
        case LTTNG_NOTIFICATION_CHANNEL_STATUS_CLOSED:
            /*
             * The session daemon closed the notification channel.
             *
             * This is typically caused by a session daemon shutting
             * down.
             */
            goto end;
        default:
            /* Unhandled conditions or errors. */
            exit_status = EXIT_FAILURE;
            goto end;
        }

        /*
         * A notification provides, amongst other things:
         *
         * * The condition that caused LTTng to send this notification.
         *
         * * The condition evaluation, which provides more specific
         *   information on the evaluation of the condition.
         *
         * The condition evaluation provides the buffer usage
         * value at the moment the condition was satisfied.
         */
        notification_condition = lttng_notification_get_condition(
            notification);
        notification_evaluation = lttng_notification_get_evaluation(
            notification);

        /* We're subscribed to only one condition. */
        assert(lttng_condition_get_type(notification_condition) ==
            LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH);

        /*
         * Get the exact sampled buffer usage from the condition
         * evaluation.
         */
        lttng_evaluation_buffer_usage_get_usage_ratio(
            notification_evaluation, &buffer_usage);

        /*
         * At this point, instead of printing a message, we could do
         * something to reduce the buffer usage of the channel, like
         * disable specific events, for example.
         */
        printf("Buffer usage is %f %% in recording session \"%s\", "
               "user space channel \"%s\".\n", buffer_usage * 100,
               recording_session_name, channel_name);

        /* Destroy the notification object. */
        lttng_notification_destroy(notification);
    }

end:
    lttng_action_destroy(action);
    lttng_condition_destroy(condition);
    lttng_trigger_destroy(trigger);
    lttng_notification_channel_destroy(notification_channel);
    return exit_status;
}

$
gcc -o notif-app notif-app.c $(pkg-config --cflags --libs lttng-ctl)
$
$
$
lttng create my-session
lttng enable-event --userspace --all
lttng start
$
./notif-app my-session channel0
Buffer usage is 81.45197 % in recording session "my-session", user space
channel "channel0".
LTTNG_TRACEPOINT_ENUM(name, TP_ENUM_VALUES(entries))

LTTNG_TRACEPOINT_ENUM(
    my_enum,
    TP_ENUM_VALUES(
        ctf_enum_auto("AUTO: EXPECT 0")
        ctf_enum_value("VALUE: 23", 23)
        ctf_enum_value("VALUE: 27", 27)
        ctf_enum_auto("AUTO: EXPECT 28")
        ctf_enum_range("RANGE: 101 TO 303", 101, 303)
        ctf_enum_auto("AUTO: EXPECT 304")
    )
)

Distribution	Available in releases
Ubuntu	Ubuntu 22.04 LTS Jammy Jellyfish, Ubuntu 23.04 Lunar Lobster, and Ubuntu 23.10 Mantic Minotaur. Ubuntu 18.04 LTS Bionic Beaver and Ubuntu 20.04 LTS Focal Fossa: use the LTTng Stable 2.13 PPA.
Debian	Debian 12 bookworm.
Fedora	Fedora 37, Fedora 38, and Fedora 39.
Arch Linux	extra repository and AUR.
Alpine Linux	Alpine Linux 3.16, Alpine Linux 3.17, and Alpine Linux 3.18.
Buildroot	Buildroot 2022.02, Buildroot 2022.05, Buildroot 2022.08, Buildroot 2022.11, Buildroot 2023.02, Buildroot 2023.05, and Buildroot 2023.08.
OpenEmbedded and Yocto	Yocto Project 3.3 Honister, Yocto Project 4.0 Kirkstone, Yocto Project 4.1 Langdale, Yocto Project 4.2 Mickledore, and Yocto Project 4.3 Nanbield.

Field name	Field value
`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,`

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

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

Docs/2.13

Options

The LTTng Documentation

Welcome!

Target audience

What’s in this documentation?

Convention

Acknowledgements