$ { lttng export-maps; echo 'SELECT * FROM vmap;' } | sqlite3 :memory:

The lttng export-maps command does NOT provide an atomic snapshot of the counter values: the connected session daemon (see lttng-sessiond(8)) reads the values one by one, and LTTng tracers may concurrently update any of them while the command runs.

Therefore, lttng export-maps does NOT guarantee that its output reflects the state of the counters at a single instant.

To obtain a consistent view of the counter values, LTTng recommends to either:

Moreover, lttng export-maps doesn’t guarantee the order in which it writes its INSERT INTO statements; don’t rely on it.

CREATE TABLE channels (


  id   INTEGER PRIMARY KEY,


  name TEXT NOT NULL,


  type TEXT NOT NULL CHECK (type IN ('kernel', 'user')),


  UNIQUE (name, type)
);
CREATE TABLE groups (


  id          INTEGER PRIMARY KEY,


  channel_id  INTEGER NOT NULL REFERENCES channels(id),


  type        TEXT NOT NULL


              CHECK (type IN ('kernel-global', 'user-per-user',


                              'user-per-process', 'shared')),


  owner_id    INTEGER,


  owner_name  TEXT,


  value_type  TEXT NOT NULL


              CHECK (value_type IN ('signed-int-32', 'signed-int-64')),


  CHECK ((owner_id IS NULL) =


         (type NOT IN ('user-per-user', 'user-per-process')))
);
CREATE TABLE keys (


  id   INTEGER PRIMARY KEY,


  name TEXT NOT NULL UNIQUE
);
CREATE TABLE entries (


  group_id     INTEGER NOT NULL REFERENCES groups(id),


  part_id      INTEGER,


  key_id       INTEGER NOT NULL REFERENCES keys(id),


  value        INTEGER NOT NULL,


  has_overflow INTEGER NOT NULL CHECK (has_overflow IN (0, 1))
);
CREATE VIEW vmap AS
SELECT c.name AS channel_name,


       c.type AS channel_type,


       g.type AS group_type,


       g.owner_id,


       g.owner_name,


       g.value_type,


       e.part_id,


       k.name AS key,


       e.value,


       e.has_overflow
FROM entries e
JOIN groups g   ON e.group_id   = g.id
JOIN channels c ON g.channel_id = c.id
JOIN keys k     ON e.key_id     = k.id;

kernel-global

user-per-user

user-per-process

shared

This column is informational only: LTTng makes no guarantee that the name is set (it may be NULL), that it’s unique amongst the groups of a map channel, or that it remains stable across versions.

Always use owner_id (together with group_type) to identify an owner reliably.

Always NULL for the kernel-global and shared group types.

The schema is stable for a given format name.

Any future incompatible change to the schema would introduce a new --format value so that existing consumers keep working.

Defaults to $HOME.

Useful when the Unix user running the commands has a non-writable home directory.

Note that the legacy output doesn’t show anything related to features introduced after LTTng 2.14.

The --sessiond-path general option overrides this environment variable.

The NO_COLOR environment variable overrides this.

One of:

auto (default)

always

never

See NO_COLOR <https://no-color.org/> to learn more.

This is where LTTng stores the name of the Unix user’s current recording session between executions of lttng(1). lttng-create(1) and lttng-set-session(1) set the current recording session.

Override this path with the --output option of the lttng-create(1) command.

$LTTNG_HOME defaults to the value of the HOME environment variable.

The export becomes the initialization script of sqlite3, which then drops to its interactive prompt with the data loaded:

$ sqlite3 -init <(lttng export-maps) :memory:

See the --session option.

$ lttng export-maps --session=my-session > maps.sql

This groups by owner_id (the reliable process identifier) and shows the informational owner_name for display only.

$ { lttng export-maps; cat << EOF


    SELECT owner_id AS pid, owner_name AS command, SUM(value) AS total


    FROM vmap


    WHERE channel_name = 'my-counters' AND group_type = 'user-per-process'


    GROUP BY owner_id


    ORDER BY total DESC


    LIMIT 10;


  EOF


  } | sqlite3 :memory: