OPT_STRING('i', "input", &input_name, "file", "input file name"),
 #ifdef HAVE_LIBBABELTRACE_SUPPORT
                OPT_STRING(0, "to-ctf", &to_ctf, NULL, "Convert to CTF format"),
+               OPT_BOOLEAN(0, "tod", &opts.tod, "Convert time to wall clock time"),
 #endif
                OPT_BOOLEAN('f', "force", &opts.force, "don't complain, do it"),
                OPT_BOOLEAN(0, "all", &opts.all, "Convert all events"),
 
 #include "config.h"
 #include <linux/ctype.h>
 #include <linux/err.h>
+#include <linux/time64.h>
+#include "util.h"
+#include "clockid.h"
 
 #define pr_N(n, fmt, ...) \
        eprintf(n, debug_data_convert, fmt, ##__VA_ARGS__)
        return 0;
 }
 
-static int ctf_writer__setup_clock(struct ctf_writer *cw)
+static int ctf_writer__setup_clock(struct ctf_writer *cw,
+                                  struct perf_session *session,
+                                  bool tod)
 {
        struct bt_ctf_clock *clock = cw->clock;
+       const char *desc = "perf clock";
+       int64_t offset = 0;
 
-       bt_ctf_clock_set_description(clock, "perf clock");
+       if (tod) {
+               struct perf_env *env = &session->header.env;
+
+               if (!env->clock.enabled) {
+                       pr_err("Can't provide --tod time, missing clock data. "
+                              "Please record with -k/--clockid option.\n");
+                       return -1;
+               }
+
+               desc   = clockid_name(env->clock.clockid);
+               offset = env->clock.tod_ns - env->clock.clockid_ns;
+       }
 
 #define SET(__n, __v)                          \
 do {                                           \
 } while (0)
 
        SET(frequency,   1000000000);
-       SET(offset_s,    0);
-       SET(offset,      0);
+       SET(offset,      offset);
+       SET(description, desc);
        SET(precision,   10);
        SET(is_absolute, 0);
 
        memset(cw, 0, sizeof(*cw));
 }
 
-static int ctf_writer__init(struct ctf_writer *cw, const char *path)
+static int ctf_writer__init(struct ctf_writer *cw, const char *path,
+                           struct perf_session *session, bool tod)
 {
        struct bt_ctf_writer            *writer;
        struct bt_ctf_stream_class      *stream_class;
 
        cw->clock = clock;
 
-       if (ctf_writer__setup_clock(cw)) {
+       if (ctf_writer__setup_clock(cw, session, tod)) {
                pr("Failed to setup CTF clock.\n");
                goto err_cleanup;
        }
        if (err)
                return err;
 
-       /* CTF writer */
-       if (ctf_writer__init(cw, path))
-               return -1;
-
        err = -1;
        /* perf.data session */
        session = perf_session__new(&data, 0, &c.tool);
-       if (IS_ERR(session)) {
-               err = PTR_ERR(session);
-               goto free_writer;
-       }
+       if (IS_ERR(session))
+               return PTR_ERR(session);
+
+       /* CTF writer */
+       if (ctf_writer__init(cw, path, session, opts->tod))
+               goto free_session;
 
        if (c.queue_size) {
                ordered_events__set_alloc_size(&session->ordered_events,
 
        /* CTF writer env/clock setup  */
        if (ctf_writer__setup_env(cw, session))
-               goto free_session;
+               goto free_writer;
 
        /* CTF events setup */
        if (setup_events(cw, session))
-               goto free_session;
+               goto free_writer;
 
        if (opts->all && setup_non_sample_events(cw, session))
-               goto free_session;
+               goto free_writer;
 
        if (setup_streams(cw, session))
-               goto free_session;
+               goto free_writer;
 
        err = perf_session__process_events(session);
        if (!err)
 
        return err;
 
-free_session:
-       perf_session__delete(session);
 free_writer:
        ctf_writer__cleanup(cw);
+free_session:
+       perf_session__delete(session);
        pr_err("Error during conversion setup.\n");
        return err;
 }