Use boot_id as monotonic clock uuid

[lttng-ust.git] / liblttng-ust / ltt-events.c

diff --git a/liblttng-ust/ltt-events.c b/liblttng-ust/ltt-events.c
index ee88b43142d6e39c57f974102ba45328a7aef210..85afc1ba63599027ea930d4aea52a0f07856241c 100644 (file)
--- a/liblttng-ust/ltt-events.c
+++ b/liblttng-ust/ltt-events.c
@@ -20,6 +20,9 @@
 #include <sys/ipc.h>
 #include <stdint.h>
 #include <stddef.h>
+#include <inttypes.h>
+#include <time.h>
+#include "clock.h"
 
 #include <urcu-bp.h>
 #include <urcu/compiler.h>
@@ -309,20 +312,10 @@ int ltt_session_enable(struct ltt_session *session)
        cds_list_for_each_entry(chan, &session->chan, list) {
                if (chan->header_type)
                        continue;               /* don't change it if session stop/restart */
-               /*
-                * Because we don't use any timer in the application, we
-                * currently cannot guarantee that we have frequent
-                * events that let us detect 27-bit overflows.
-                * Therefore, for now, we force large event headers,
-                * which contain 64-bit timestamps.
-                */
-               chan->header_type = 2;  /* large */
-#if 0
                if (chan->free_event_id < 31)
                        chan->header_type = 1;  /* compact */
                else
                        chan->header_type = 2;  /* large */
-#endif //0
        }
 
        CMM_ACCESS_ONCE(session->active) = 1;
@@ -997,8 +990,8 @@ int _ltt_stream_packet_context_declare(struct ltt_session *session)
 {
        return lttng_metadata_printf(session,
                "struct packet_context {\n"
-               "       uint64_t timestamp_begin;\n"
-               "       uint64_t timestamp_end;\n"
+               "       uint64_clock_monotonic_t timestamp_begin;\n"
+               "       uint64_clock_monotonic_t timestamp_end;\n"
                "       uint32_t events_discarded;\n"
                "       uint32_t content_size;\n"
                "       uint32_t packet_size;\n"
@@ -1024,11 +1017,11 @@ int _ltt_event_header_declare(struct ltt_session *session)
        "       enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n"
        "       variant <id> {\n"
        "               struct {\n"
-       "                       uint27_t timestamp;\n"
+       "                       uint27_clock_monotonic_t timestamp;\n"
        "               } compact;\n"
        "               struct {\n"
        "                       uint32_t id;\n"
-       "                       uint64_t timestamp;\n"
+       "                       uint64_clock_monotonic_t timestamp;\n"
        "               } extended;\n"
        "       } v;\n"
        "} align(%u);\n"
@@ -1037,11 +1030,11 @@ int _ltt_event_header_declare(struct ltt_session *session)
        "       enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n"
        "       variant <id> {\n"
        "               struct {\n"
-       "                       uint32_t timestamp;\n"
+       "                       uint32_clock_monotonic_t timestamp;\n"
        "               } compact;\n"
        "               struct {\n"
        "                       uint32_t id;\n"
-       "                       uint64_t timestamp;\n"
+       "                       uint64_clock_monotonic_t timestamp;\n"
        "               } extended;\n"
        "       } v;\n"
        "} align(%u);\n\n",
@@ -1050,6 +1043,31 @@ int _ltt_event_header_declare(struct ltt_session *session)
        );
 }
 
+/*
+ * Approximation of NTP time of day to clock monotonic correlation,
+ * taken at start of trace.
+ * Yes, this is only an approximation. Yes, we can (and will) do better
+ * in future versions.
+ */
+static
+uint64_t measure_clock_offset(void)
+{
+       uint64_t offset, monotonic[2], realtime;
+       struct timespec rts = { 0, 0 };
+       int ret;
+
+       monotonic[0] = trace_clock_read64();
+       ret = clock_gettime(CLOCK_REALTIME, &rts);      
+       if (ret < 0)
+               return 0;
+       monotonic[1] = trace_clock_read64();
+       offset = (monotonic[0] + monotonic[1]) >> 1;
+       realtime = rts.tv_sec * 1000000000ULL;
+       realtime += rts.tv_nsec;
+       offset = realtime - offset;
+       return offset;
+}
+
 /*
  * Output metadata into this session's metadata buffers.
  */
@@ -1057,7 +1075,7 @@ static
 int _ltt_session_metadata_statedump(struct ltt_session *session)
 {
        unsigned char *uuid_c = session->uuid;
-       char uuid_s[37];
+       char uuid_s[37], clock_uuid_s[CLOCK_UUID_LEN];
        struct ltt_channel *chan;
        struct ltt_event *event;
        int ret = 0;
@@ -1113,6 +1131,56 @@ int _ltt_session_metadata_statedump(struct ltt_session *session)
        if (ret)
                goto end;
 
+       ret = lttng_metadata_printf(session,
+               "clock {\n"
+               "       name = %s;\n",
+               "monotonic"
+               );
+       if (ret)
+               goto end;
+
+       if (!trace_clock_uuid(clock_uuid_s)) {
+               ret = lttng_metadata_printf(session,
+                       "       uuid = \"%s\";\n",
+                       clock_uuid_s
+                       );
+               if (ret)
+                       goto end;
+       }
+
+       ret = lttng_metadata_printf(session,
+               "       description = \"Monotonic Clock\";\n"
+               "       freq = %" PRIu64 "; /* Frequency, in Hz */\n"
+               "       /* clock value offset from Epoch is: offset * (1/freq) */\n"
+               "       offset = %" PRIu64 ";\n"
+               "};\n\n",
+               trace_clock_freq(),
+               measure_clock_offset()
+               );
+       if (ret)
+               goto end;
+
+       ret = lttng_metadata_printf(session,
+               "typealias integer {\n"
+               "       size = 27; align = 1; signed = false;\n"
+               "       map = clock.monotonic.value;\n"
+               "} := uint27_clock_monotonic_t;\n"
+               "\n"
+               "typealias integer {\n"
+               "       size = 32; align = %u; signed = false;\n"
+               "       map = clock.monotonic.value;\n"
+               "} := uint32_clock_monotonic_t;\n"
+               "\n"
+               "typealias integer {\n"
+               "       size = 64; align = %u; signed = false;\n"
+               "       map = clock.monotonic.value;\n"
+               "} := uint64_clock_monotonic_t;\n\n",
+               lttng_alignof(uint32_t) * CHAR_BIT,
+               lttng_alignof(uint64_t) * CHAR_BIT
+               );
+       if (ret)
+               goto end;
+
        ret = _ltt_stream_packet_context_declare(session);
        if (ret)
                goto end;