__field(        u64,                    duration        )
                __field(        u64,                    outer_duration  )
                __field(        u64,                    nmi_total_ts    )
-               __field_struct( struct timespec,        timestamp       )
-               __field_desc(   long,   timestamp,      tv_sec          )
+               __field_struct( struct timespec64,      timestamp       )
+               __field_desc(   s64,    timestamp,      tv_sec          )
                __field_desc(   long,   timestamp,      tv_nsec         )
                __field(        unsigned int,           nmi_count       )
                __field(        unsigned int,           seqnum          )
        ),
 
-       F_printk("cnt:%u\tts:%010lu.%010lu\tinner:%llu\touter:%llunmi-ts:%llu\tnmi-count:%u\n",
+       F_printk("cnt:%u\tts:%010llu.%010lu\tinner:%llu\touter:%llunmi-ts:%llu\tnmi-count:%u\n",
                 __entry->seqnum,
                 __entry->tv_sec,
                 __entry->tv_nsec,
 
 
 /* Individual latency samples are stored here when detected. */
 struct hwlat_sample {
-       u64             seqnum;         /* unique sequence */
-       u64             duration;       /* delta */
-       u64             outer_duration; /* delta (outer loop) */
-       u64             nmi_total_ts;   /* Total time spent in NMIs */
-       struct timespec timestamp;      /* wall time */
-       int             nmi_count;      /* # NMIs during this sample */
+       u64                     seqnum;         /* unique sequence */
+       u64                     duration;       /* delta */
+       u64                     outer_duration; /* delta (outer loop) */
+       u64                     nmi_total_ts;   /* Total time spent in NMIs */
+       struct timespec64       timestamp;      /* wall time */
+       int                     nmi_count;      /* # NMIs during this sample */
 };
 
 /* keep the global state somewhere. */
                s.seqnum = hwlat_data.count;
                s.duration = sample;
                s.outer_duration = outer_sample;
-               s.timestamp = CURRENT_TIME;
+               ktime_get_real_ts64(&s.timestamp);
                s.nmi_total_ts = nmi_total_ts;
                s.nmi_count = nmi_count;
                trace_hwlat_sample(&s);
 
  * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
  *
  */
-
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/ftrace.h>
 
        trace_assign_type(field, entry);
 
-       trace_seq_printf(s, "#%-5u inner/outer(us): %4llu/%-5llu ts:%ld.%09ld",
+       trace_seq_printf(s, "#%-5u inner/outer(us): %4llu/%-5llu ts:%lld.%09ld",
                         field->seqnum,
                         field->duration,
                         field->outer_duration,
-                        field->timestamp.tv_sec,
+                        (long long)field->timestamp.tv_sec,
                         field->timestamp.tv_nsec);
 
        if (field->nmi_count) {
 
        trace_assign_type(field, iter->ent);
 
-       trace_seq_printf(s, "%llu %lld %ld %09ld %u\n",
+       trace_seq_printf(s, "%llu %lld %lld %09ld %u\n",
                         field->duration,
                         field->outer_duration,
-                        field->timestamp.tv_sec,
+                        (long long)field->timestamp.tv_sec,
                         field->timestamp.tv_nsec,
                         field->seqnum);