Metadata: add env fields to ease lttng path hierarchy creation for viewer
authorJonathan Rajotte <jonathan.rajotte-julien@efficios.com>
Thu, 5 Sep 2019 22:23:52 +0000 (18:23 -0400)
committerJérémie Galarneau <jeremie.galarneau@efficios.com>
Thu, 5 Sep 2019 22:39:59 +0000 (18:39 -0400)
Add the following fields in the env section of the metadata:

  - trace_name
      The session name without datetime information.
      Hence when the session is an auto-generated one, only print
      LTTNG_DEFAULT_NAME.
  - trace_creation_datetime:
      The datetime at which the session was created.
      We use session->creation time for it.
  - tracer_buffering_scheme
      The buffering scheme used. The value can be uid or pid.
  - tracer_buffering_id
      The key used by the buffering scheme (uid/pid).
  - architecture_bit_width
      The bit width of the computer architecture (e.g 32 or 64)
  - vpid_datetime
      The registration time of the vpid for per-pid mode.

Adding these fields ensure that the trace itself carry information that
is normally carried via folder hierarchy. e.g

test-20190417-174951/                      <- trace_name, trace_creation_datetime
└── ust                                    <- domain
    └── uid                                <- tracer_buffering_scheme
        └── 1000                           <- tracer_buffering_id
            └── 64-bit                     <- architecture_bit_width
                ├── channel0_0
                ├── index
                │   ├── channel0_0.idx
                └── metadata

Per-pid buffering is quite similar.

auto-20190722-174816                        <- trace_name, trace_creation_datetime
└── ust                                     <- domain
    └── pid                                 <- tracer_buffering_scheme
        └── sample-ust-7640-20190722-174818 <- procname, tracer_buffering_id, vpid_datetime
            ├── my-channel_0
            ├── index
            │   ├── my-channel_0.idx
            ├── metadata

Signed-off-by: Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>
src/bin/lttng-sessiond/ust-app.c
src/bin/lttng-sessiond/ust-metadata.c
src/bin/lttng-sessiond/ust-registry.c
src/bin/lttng-sessiond/ust-registry.h
src/common/time.c

index 56860d714e3a6e5a605e75c56a1fb200037fd1bb..0e97b944ca094722f4bb36f468455633e1333608 100644 (file)
@@ -1993,7 +1993,8 @@ static int setup_buffer_reg_pid(struct ust_app_session *ua_sess,
                        app->byte_order, app->version.major, app->version.minor,
                        reg_pid->root_shm_path, reg_pid->shm_path,
                        ua_sess->effective_credentials.uid,
-                       ua_sess->effective_credentials.gid);
+                       ua_sess->effective_credentials.gid, ua_sess->tracing_id,
+                       app->uid);
        if (ret < 0) {
                /*
                 * reg_pid->registry->reg.ust is NULL upon error, so we need to
@@ -2060,7 +2061,8 @@ static int setup_buffer_reg_uid(struct ltt_ust_session *usess,
                        app->uint64_t_alignment, app->long_alignment,
                        app->byte_order, app->version.major,
                        app->version.minor, reg_uid->root_shm_path,
-                       reg_uid->shm_path, usess->uid, usess->gid);
+                       reg_uid->shm_path, usess->uid, usess->gid,
+                       ua_sess->tracing_id, app->uid);
        if (ret < 0) {
                /*
                 * reg_uid->registry->reg.ust is NULL upon error, so we need to
index a657f7c5d3d26b62472e66ecef3f188e987ee121..7c6cbc63d8370e29d7caf3ac7a2363c385c657b6 100644 (file)
@@ -217,6 +217,43 @@ void sanitize_ctf_identifier(char *out, const char *in)
        }
 }
 
+static
+int print_escaped_ctf_string(struct ust_registry_session *session, const char *string)
+{
+       int ret;
+       size_t i;
+       char cur;
+
+       i = 0;
+       cur = string[i];
+       while (cur != '\0') {
+               switch (cur) {
+               case '\n':
+                       ret = lttng_metadata_printf(session, "%s", "\\n");
+                       break;
+               case '\\':
+               case '"':
+                       ret = lttng_metadata_printf(session, "%c", '\\');
+                       if (ret) {
+                               goto error;
+                       }
+                       /* We still print the current char */
+                       /* Fallthrough */
+               default:
+                       ret = lttng_metadata_printf(session, "%c", cur);
+                       break;
+               }
+
+               if (ret) {
+                       goto error;
+               }
+
+               cur = string[++i];
+       }
+error:
+       return ret;
+}
+
 /* Called with session registry mutex held. */
 static
 int ust_metadata_enum_statedump(struct ust_registry_session *session,
@@ -869,6 +906,98 @@ int64_t measure_clock_offset(void)
        return offset_best_sample.offset;
 }
 
+static
+int print_metadata_session_information(struct ust_registry_session *registry)
+{
+       int ret;
+       struct ltt_session *session = NULL;
+       char creation_datetime[ISO8601_STR_LEN];
+
+       rcu_read_lock();
+       session = session_find_by_id(registry->tracing_id);
+       if (!session) {
+               ret = -1;
+               goto error;
+       }
+
+       /* Print the trace name */
+       ret = lttng_metadata_printf(registry, " trace_name = \"");
+       if (ret) {
+               goto error;
+       }
+
+       /*
+        * This is necessary since the creation time is present in the session
+        * name when it is generated.
+        */
+       if (session->has_auto_generated_name) {
+               ret = print_escaped_ctf_string(registry, DEFAULT_SESSION_NAME);
+       } else {
+               ret = print_escaped_ctf_string(registry, session->name);
+       }
+       if (ret) {
+               goto error;
+       }
+
+       ret = lttng_metadata_printf(registry, "\";\n");
+       if (ret) {
+               goto error;
+       }
+
+       /* Prepare creation time */
+       ret = time_to_iso8601_str(session->creation_time, creation_datetime,
+                       sizeof(creation_datetime));
+       if (ret) {
+               goto error;
+       }
+
+       /* Output the reste of the information */
+       ret = lttng_metadata_printf(registry,
+                       "       trace_creation_datetime = \"%s\";\n"
+                       "       hostname = \"%s\";\n",
+                       creation_datetime, session->hostname);
+       if (ret) {
+               goto error;
+       }
+
+error:
+       if (session) {
+               session_put(session);
+       }
+       rcu_read_unlock();
+       return ret;
+}
+
+static
+int print_metadata_app_information(struct ust_registry_session *registry,
+               struct ust_app *app)
+{
+       int ret;
+       char datetime[ISO8601_STR_LEN];
+
+       if (!app) {
+               ret = 0;
+               goto end;
+       }
+
+       ret = time_to_iso8601_str(
+                       app->registration_time, datetime, sizeof(datetime));
+       if (ret) {
+               goto end;
+       }
+
+       ret = lttng_metadata_printf(registry,
+                       "       tracer_patchlevel = %u;\n"
+                       "       vpid = %d;\n"
+                       "       procname = \"%s\";\n"
+                       "       vpid_datetime = \"%s\";\n",
+                       app->version.patchlevel, (int) app->pid, app->name,
+                       datetime);
+
+end:
+       return ret;
+}
+
 /*
  * Should be called with session registry mutex held.
  */
@@ -880,7 +1009,6 @@ int ust_metadata_session_statedump(struct ust_registry_session *session,
        char uuid_s[UUID_STR_LEN],
                clock_uuid_s[UUID_STR_LEN];
        int ret = 0;
-       char hostname[HOST_NAME_MAX];
 
        assert(session);
 
@@ -930,40 +1058,36 @@ int ust_metadata_session_statedump(struct ust_registry_session *session,
        if (ret)
                goto end;
 
-       /* ignore error, just use empty string if error. */
-       hostname[0] = '\0';
-       ret = gethostname(hostname, sizeof(hostname));
-       if (ret && errno == ENAMETOOLONG)
-               hostname[HOST_NAME_MAX - 1] = '\0';
        ret = lttng_metadata_printf(session,
                "env {\n"
-               "       hostname = \"%s\";\n"
                "       domain = \"ust\";\n"
                "       tracer_name = \"lttng-ust\";\n"
                "       tracer_major = %u;\n"
-               "       tracer_minor = %u;\n",
-               hostname,
+               "       tracer_minor = %u;\n"
+               "       tracer_buffering_scheme = \"%s\";\n"
+               "       tracer_buffering_id = %u;\n"
+               "       architecture_bit_width = %u;\n",
                major,
-               minor
-               );
-       if (ret)
+               minor,
+               app ? "pid" : "uid",
+               app ? (int) app->pid : (int) session->tracing_uid,
+               session->bits_per_long);
+       if (ret) {
+               goto end;
+       }
+
+       ret = print_metadata_session_information(session);
+       if (ret) {
                goto end;
+       }
 
        /*
         * If per-application registry, we can output extra information
         * about the application.
         */
-       if (app) {
-               ret = lttng_metadata_printf(session,
-                       "       tracer_patchlevel = %u;\n"
-                       "       vpid = %d;\n"
-                       "       procname = \"%s\";\n",
-                       app->version.patchlevel,
-                       (int) app->pid,
-                       app->name
-                       );
-               if (ret)
-                       goto end;
+       ret = print_metadata_app_information(session, app);
+       if (ret) {
+               goto end;
        }
 
        ret = lttng_metadata_printf(session,
index 7345bcbddcca8d646a1751179b7bc4de3c5865a0..4d4094e7361836c5617e42eb61ecea84d56e1ba1 100644 (file)
@@ -880,7 +880,9 @@ int ust_registry_session_init(struct ust_registry_session **sessionp,
                const char *root_shm_path,
                const char *shm_path,
                uid_t euid,
-               gid_t egid)
+               gid_t egid,
+               uint64_t tracing_id,
+               uid_t tracing_uid)
 {
        int ret;
        struct ust_registry_session *session;
@@ -962,6 +964,9 @@ int ust_registry_session_init(struct ust_registry_session **sessionp,
                goto error;
        }
 
+       session->tracing_id = tracing_id;
+       session->tracing_uid = tracing_uid;
+
        pthread_mutex_lock(&session->lock);
        ret = ust_metadata_session_statedump(session, app, major, minor);
        pthread_mutex_unlock(&session->lock);
index 2940ab7accea9534b3fe63696f4b5ea6a60a55e6..2fc2dff87b8e72f074d8e524f33580aae01f1550 100644 (file)
@@ -131,6 +131,10 @@ struct ust_registry_session {
         */
        uint32_t major;
        uint32_t minor;
+
+       /* The id of the parent session */
+       uint64_t tracing_id;
+       uid_t tracing_uid;
 };
 
 struct ust_registry_channel {
@@ -291,7 +295,9 @@ int ust_registry_session_init(struct ust_registry_session **sessionp,
                const char *root_shm_path,
                const char *shm_path,
                uid_t euid,
-               gid_t egid);
+               gid_t egid,
+               uint64_t tracing_id,
+               uid_t tracing_uid);
 void ust_registry_session_destroy(struct ust_registry_session *session);
 
 int ust_registry_create_event(struct ust_registry_session *session,
@@ -351,7 +357,15 @@ int ust_registry_session_init(struct ust_registry_session **sessionp,
                uint32_t uint32_t_alignment,
                uint32_t uint64_t_alignment,
                uint32_t long_alignment,
-               int byte_order)
+               int byte_order,
+               uint32_t major,
+               uint32_t minor,
+               const char *root_shm_path,
+               const char *shm_path,
+               uid_t euid,
+               gid_t egid,
+               uint64_t tracing_id,
+               uid_t tracing_uid);
 {
        return 0;
 }
index 885f58cb175bf4a2336cf957047abcc339642c15..c69002f3456c33de8ea6ff33fef7610d5745d3b2 100644 (file)
@@ -16,6 +16,7 @@
  */
 
 #include <common/time.h>
+#include <common/error.h>
 #include <common/macros.h>
 #include <common/error.h>
 #include <stddef.h>
This page took 0.046164 seconds and 4 git commands to generate.