48 files changed, 200 insertions, 227 deletions

diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
index bf9ba26981a5..94332902a1cf 100644
--- a/drivers/base/power/wakeup.c
+++ b/drivers/base/power/wakeup.c
@@ -998,7 +998,7 @@ static int print_wakeup_source_stats(struct seq_file *m,
 
                 active_time = ktime_sub(now, ws->last_time);
                 total_time = ktime_add(total_time, active_time);
-                if (active_time.tv64 > max_time.tv64)
+                if (active_time > max_time)
                         max_time = active_time;
 
                 if (ws->autosleep_enabled)
diff --git a/drivers/media/rc/ir-rx51.c b/drivers/media/rc/ir-rx51.c
index 82fb6f2ca011..e6efa8c267a0 100644
--- a/drivers/media/rc/ir-rx51.c
+++ b/drivers/media/rc/ir-rx51.c
@@ -109,7 +109,7 @@ static enum hrtimer_restart lirc_rx51_timer_cb(struct hrtimer *timer)
 
                 now = timer->base->get_time();
 
-        } while (hrtimer_get_expires_tv64(timer) < now.tv64);
+        } while (hrtimer_get_expires_tv64(timer) < now);
 
         return HRTIMER_RESTART;
 end:
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 84a52db9b05f..5cf196dfc193 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -394,8 +394,8 @@ int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
         rtc->aie_timer.period = ktime_set(0, 0);
 
         /* Alarm has to be enabled & in the future for us to enqueue it */
-        if (alarm->enabled && (rtc_tm_to_ktime(now).tv64 <
-                         rtc->aie_timer.node.expires.tv64)) {
+        if (alarm->enabled && (rtc_tm_to_ktime(now) <
+                         rtc->aie_timer.node.expires)) {
 
                 rtc->aie_timer.enabled = 1;
                 timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node);
@@ -766,7 +766,7 @@ static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
 
         /* Skip over expired timers */
         while (next) {
-                if (next->expires.tv64 >= now.tv64)
+                if (next->expires >= now)
                         break;
                 next = timerqueue_iterate_next(next);
         }
@@ -858,7 +858,7 @@ again:
         __rtc_read_time(rtc, &tm);
         now = rtc_tm_to_ktime(tm);
         while ((next = timerqueue_getnext(&rtc->timerqueue))) {
-                if (next->expires.tv64 > now.tv64)
+                if (next->expires > now)
                         break;
 
                 /* expire timer */
diff --git a/drivers/usb/chipidea/otg_fsm.c b/drivers/usb/chipidea/otg_fsm.c
index de8e22ec3902..93e24ce61a3a 100644
--- a/drivers/usb/chipidea/otg_fsm.c
+++ b/drivers/usb/chipidea/otg_fsm.c
@@ -234,8 +234,8 @@ static void ci_otg_add_timer(struct ci_hdrc *ci, enum otg_fsm_timer t)
                                 ktime_set(timer_sec, timer_nsec));
         ci->enabled_otg_timer_bits |= (1 << t);
         if ((ci->next_otg_timer == NUM_OTG_FSM_TIMERS) ||
-                        (ci->hr_timeouts[ci->next_otg_timer].tv64 >
-                                                ci->hr_timeouts[t].tv64)) {
+                        (ci->hr_timeouts[ci->next_otg_timer] >
+                                                ci->hr_timeouts[t])) {
                         ci->next_otg_timer = t;
                         hrtimer_start_range_ns(&ci->otg_fsm_hrtimer,
                                         ci->hr_timeouts[t], NSEC_PER_MSEC,
@@ -269,8 +269,8 @@ static void ci_otg_del_timer(struct ci_hdrc *ci, enum otg_fsm_timer t)
                         for_each_set_bit(cur_timer, &enabled_timer_bits,
                                                         NUM_OTG_FSM_TIMERS) {
                                 if ((next_timer == NUM_OTG_FSM_TIMERS) ||
-                                        (ci->hr_timeouts[next_timer].tv64 <
-                                        ci->hr_timeouts[cur_timer].tv64))
+                                        (ci->hr_timeouts[next_timer] <
+                                         ci->hr_timeouts[cur_timer]))
                                         next_timer = cur_timer;
                         }
                 }
@@ -397,14 +397,14 @@ static enum hrtimer_restart ci_otg_hrtimer_func(struct hrtimer *t)
 
         now = ktime_get();
         for_each_set_bit(cur_timer, &enabled_timer_bits, NUM_OTG_FSM_TIMERS) {
-                if (now.tv64 >= ci->hr_timeouts[cur_timer].tv64) {
+                if (now >= ci->hr_timeouts[cur_timer]) {
                         ci->enabled_otg_timer_bits &= ~(1 << cur_timer);
                         if (otg_timer_handlers[cur_timer])
                                 ret = otg_timer_handlers[cur_timer](ci);
                 } else {
                         if ((next_timer == NUM_OTG_FSM_TIMERS) ||
-                                (ci->hr_timeouts[cur_timer].tv64 <
-                                        ci->hr_timeouts[next_timer].tv64))
+                                (ci->hr_timeouts[cur_timer] <
+                                        ci->hr_timeouts[next_timer]))
                                 next_timer = cur_timer;
                 }
         }
diff --git a/drivers/usb/host/ehci-timer.c b/drivers/usb/host/ehci-timer.c
index 69f50e6533a6..262e10cacc8c 100644
--- a/drivers/usb/host/ehci-timer.c
+++ b/drivers/usb/host/ehci-timer.c
@@ -425,7 +425,7 @@ static enum hrtimer_restart ehci_hrtimer_func(struct hrtimer *t)
          */
         now = ktime_get();
         for_each_set_bit(e, &events, EHCI_HRTIMER_NUM_EVENTS) {
-                if (now.tv64 >= ehci->hr_timeouts[e].tv64)
+                if (now >= ehci->hr_timeouts[e])
                         event_handlers[e](ehci);
                 else
                         ehci_enable_event(ehci, e, false);
diff --git a/drivers/usb/host/fotg210-hcd.c b/drivers/usb/host/fotg210-hcd.c
index 66efa9a67687..4dda56ef06cd 100644
--- a/drivers/usb/host/fotg210-hcd.c
+++ b/drivers/usb/host/fotg210-hcd.c
@@ -1381,7 +1381,7 @@ static enum hrtimer_restart fotg210_hrtimer_func(struct hrtimer *t)
          */
         now = ktime_get();
         for_each_set_bit(e, &events, FOTG210_HRTIMER_NUM_EVENTS) {
-                if (now.tv64 >= fotg210->hr_timeouts[e].tv64)
+                if (now >= fotg210->hr_timeouts[e])
                         event_handlers[e](fotg210);
                 else
                         fotg210_enable_event(fotg210, e, false);
diff --git a/fs/aio.c b/fs/aio.c
index 955c5241a8f2..4ab67e8cb776 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -1285,7 +1285,7 @@ static long read_events(struct kioctx *ctx, long min_nr, long nr,
                         struct io_event __user *event,
                         struct timespec __user *timeout)
 {
-        ktime_t until = { .tv64 = KTIME_MAX };
+        ktime_t until = KTIME_MAX;
         long ret = 0;
 
         if (timeout) {
@@ -1311,7 +1311,7 @@ static long read_events(struct kioctx *ctx, long min_nr, long nr,
          * the ringbuffer empty. So in practice we should be ok, but it's
          * something to be aware of when touching this code.
          */
-        if (until.tv64 == 0)
+        if (until == 0)
                 aio_read_events(ctx, min_nr, nr, event, &ret);
         else
                 wait_event_interruptible_hrtimeout(ctx->wait,
diff --git a/fs/nfs/flexfilelayout/flexfilelayout.c b/fs/nfs/flexfilelayout/flexfilelayout.c
index 45962fe5098c..c98f6db9aa6b 100644
--- a/fs/nfs/flexfilelayout/flexfilelayout.c
+++ b/fs/nfs/flexfilelayout/flexfilelayout.c
@@ -619,12 +619,11 @@ nfs4_ff_layoutstat_start_io(struct nfs4_ff_layout_mirror *mirror,
                             struct nfs4_ff_layoutstat *layoutstat,
                             ktime_t now)
 {
-        static const ktime_t notime = {0};
         s64 report_interval = FF_LAYOUTSTATS_REPORT_INTERVAL;
         struct nfs4_flexfile_layout *ffl = FF_LAYOUT_FROM_HDR(mirror->layout);
 
         nfs4_ff_start_busy_timer(&layoutstat->busy_timer, now);
-        if (ktime_equal(mirror->start_time, notime))
+        if (ktime_equal(mirror->start_time, 0))
                 mirror->start_time = now;
         if (mirror->report_interval != 0)
                 report_interval = (s64)mirror->report_interval * 1000LL;
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index 96a155ab5059..f6e871760f8d 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -1250,7 +1250,7 @@ static int o2hb_thread(void *data)
 
                 mlog(ML_HEARTBEAT,
                      "start = %lld, end = %lld, msec = %u, ret = %d\n",
-                     before_hb.tv64, after_hb.tv64, elapsed_msec, ret);
+                     before_hb, after_hb, elapsed_msec, ret);
 
                 if (!kthread_should_stop() &&
                     elapsed_msec < reg->hr_timeout_ms) {
diff --git a/fs/timerfd.c b/fs/timerfd.c
index 9ae4abb4110b..fb4407a7cf9e 100644
--- a/fs/timerfd.c
+++ b/fs/timerfd.c
@@ -55,7 +55,7 @@ static inline bool isalarm(struct timerfd_ctx *ctx)
 /*
  * This gets called when the timer event triggers. We set the "expired"
  * flag, but we do not re-arm the timer (in case it's necessary,
- * tintv.tv64 != 0) until the timer is accessed.
+ * tintv != 0) until the timer is accessed.
  */
 static void timerfd_triggered(struct timerfd_ctx *ctx)
 {
@@ -93,7 +93,7 @@ static enum alarmtimer_restart timerfd_alarmproc(struct alarm *alarm,
  */
 void timerfd_clock_was_set(void)
 {
-        ktime_t moffs = ktime_mono_to_real((ktime_t){ .tv64 = 0 });
+        ktime_t moffs = ktime_mono_to_real(0);
         struct timerfd_ctx *ctx;
         unsigned long flags;
 
@@ -102,8 +102,8 @@ void timerfd_clock_was_set(void)
                 if (!ctx->might_cancel)
                         continue;
                 spin_lock_irqsave(&ctx->wqh.lock, flags);
-                if (ctx->moffs.tv64 != moffs.tv64) {
-                        ctx->moffs.tv64 = KTIME_MAX;
+                if (ctx->moffs != moffs) {
+                        ctx->moffs = KTIME_MAX;
                         ctx->ticks++;
                         wake_up_locked(&ctx->wqh);
                 }
@@ -124,9 +124,9 @@ static void timerfd_remove_cancel(struct timerfd_ctx *ctx)
 
 static bool timerfd_canceled(struct timerfd_ctx *ctx)
 {
-        if (!ctx->might_cancel || ctx->moffs.tv64 != KTIME_MAX)
+        if (!ctx->might_cancel || ctx->moffs != KTIME_MAX)
                 return false;
-        ctx->moffs = ktime_mono_to_real((ktime_t){ .tv64 = 0 });
+        ctx->moffs = ktime_mono_to_real(0);
         return true;
 }
 
@@ -155,7 +155,7 @@ static ktime_t timerfd_get_remaining(struct timerfd_ctx *ctx)
         else
                 remaining = hrtimer_expires_remaining_adjusted(&ctx->t.tmr);
 
-        return remaining.tv64 < 0 ? ktime_set(0, 0): remaining;
+        return remaining < 0 ? ktime_set(0, 0): remaining;
 }
 
 static int timerfd_setup(struct timerfd_ctx *ctx, int flags,
@@ -184,7 +184,7 @@ static int timerfd_setup(struct timerfd_ctx *ctx, int flags,
                 ctx->t.tmr.function = timerfd_tmrproc;
         }
 
-        if (texp.tv64 != 0) {
+        if (texp != 0) {
                 if (isalarm(ctx)) {
                         if (flags & TFD_TIMER_ABSTIME)
                                 alarm_start(&ctx->t.alarm, texp);
@@ -261,9 +261,9 @@ static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count,
         if (ctx->ticks) {
                 ticks = ctx->ticks;
 
-                if (ctx->expired && ctx->tintv.tv64) {
+                if (ctx->expired && ctx->tintv) {
                         /*
-                         * If tintv.tv64 != 0, this is a periodic timer that
+                         * If tintv != 0, this is a periodic timer that
                          * needs to be re-armed. We avoid doing it in the timer
                          * callback to avoid DoS attacks specifying a very
                          * short timer period.
@@ -410,7 +410,7 @@ SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags)
         else
                 hrtimer_init(&ctx->t.tmr, clockid, HRTIMER_MODE_ABS);
 
-        ctx->moffs = ktime_mono_to_real((ktime_t){ .tv64 = 0 });
+        ctx->moffs = ktime_mono_to_real(0);
 
         ufd = anon_inode_getfd("[timerfd]", &timerfd_fops, ctx,
                                O_RDWR | (flags & TFD_SHARED_FCNTL_FLAGS));
@@ -469,7 +469,7 @@ static int do_timerfd_settime(int ufd, int flags,
          * We do not update "ticks" and "expired" since the timer will be
          * re-programmed again in the following timerfd_setup() call.
          */
-        if (ctx->expired && ctx->tintv.tv64) {
+        if (ctx->expired && ctx->tintv) {
                 if (isalarm(ctx))
                         alarm_forward_now(&ctx->t.alarm, ctx->tintv);
                 else
@@ -499,7 +499,7 @@ static int do_timerfd_gettime(int ufd, struct itimerspec *t)
         ctx = f.file->private_data;
 
         spin_lock_irq(&ctx->wqh.lock);
-        if (ctx->expired && ctx->tintv.tv64) {
+        if (ctx->expired && ctx->tintv) {
                 ctx->expired = 0;
 
                 if (isalarm(ctx)) {
diff --git a/include/linux/futex.h b/include/linux/futex.h
index 6435f46d6e13..7c5b694864cd 100644
--- a/include/linux/futex.h
+++ b/include/linux/futex.h
@@ -1,14 +1,14 @@
 #ifndef _LINUX_FUTEX_H
 #define _LINUX_FUTEX_H
 
+#include <linux/ktime.h>
 #include <uapi/linux/futex.h>
 
 struct inode;
 struct mm_struct;
 struct task_struct;
-union ktime;
 
-long do_futex(u32 __user *uaddr, int op, u32 val, union ktime *timeout,
+long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
               u32 __user *uaddr2, u32 val2, u32 val3);
 
 extern int
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 5e00f80b1535..cdab81ba29f8 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -228,8 +228,8 @@ static inline void hrtimer_set_expires_range_ns(struct hrtimer *timer, ktime_t t
 
 static inline void hrtimer_set_expires_tv64(struct hrtimer *timer, s64 tv64)
 {
-        timer->node.expires.tv64 = tv64;
-        timer->_softexpires.tv64 = tv64;
+        timer->node.expires = tv64;
+        timer->_softexpires = tv64;
 }
 
 static inline void hrtimer_add_expires(struct hrtimer *timer, ktime_t time)
@@ -256,11 +256,11 @@ static inline ktime_t hrtimer_get_softexpires(const struct hrtimer *timer)
 
 static inline s64 hrtimer_get_expires_tv64(const struct hrtimer *timer)
 {
-        return timer->node.expires.tv64;
+        return timer->node.expires;
 }
 static inline s64 hrtimer_get_softexpires_tv64(const struct hrtimer *timer)
 {
-        return timer->_softexpires.tv64;
+        return timer->_softexpires;
 }
 
 static inline s64 hrtimer_get_expires_ns(const struct hrtimer *timer)
@@ -297,7 +297,7 @@ extern void hrtimer_peek_ahead_timers(void);
  * this resolution values.
  */
 # define HIGH_RES_NSEC          1
-# define KTIME_HIGH_RES         (ktime_t) { .tv64 = HIGH_RES_NSEC }
+# define KTIME_HIGH_RES         (HIGH_RES_NSEC)
 # define MONOTONIC_RES_NSEC     HIGH_RES_NSEC
 # define KTIME_MONOTONIC_RES    KTIME_HIGH_RES
 
@@ -333,7 +333,7 @@ __hrtimer_expires_remaining_adjusted(const struct hrtimer *timer, ktime_t now)
          * hrtimer_start_range_ns() to prevent short timeouts.
          */
         if (IS_ENABLED(CONFIG_TIME_LOW_RES) && timer->is_rel)
-                rem.tv64 -= hrtimer_resolution;
+                rem -= hrtimer_resolution;
         return rem;
 }
 
diff --git a/include/linux/ktime.h b/include/linux/ktime.h
index 0fb7ffb1775f..8e573deda55e 100644
--- a/include/linux/ktime.h
+++ b/include/linux/ktime.h
@@ -24,21 +24,8 @@
 #include <linux/time.h>
 #include <linux/jiffies.h>
 
-/*
- * ktime_t:
- *
- * A single 64-bit variable is used to store the hrtimers
- * internal representation of time values in scalar nanoseconds. The
- * design plays out best on 64-bit CPUs, where most conversions are
- * NOPs and most arithmetic ktime_t operations are plain arithmetic
- * operations.
- *
- */
-union ktime {
-        s64     tv64;
-};
-
-typedef union ktime ktime_t;            /* Kill this */
+/* Nanosecond scalar representation for kernel time values */
+typedef s64     ktime_t;
 
 /**
  * ktime_set - Set a ktime_t variable from a seconds/nanoseconds value
@@ -50,39 +37,34 @@ typedef union ktime ktime_t;		/* Kill this */
 static inline ktime_t ktime_set(const s64 secs, const unsigned long nsecs)
 {
         if (unlikely(secs >= KTIME_SEC_MAX))
-                return (ktime_t){ .tv64 = KTIME_MAX };
+                return KTIME_MAX;
 
-        return (ktime_t) { .tv64 = secs * NSEC_PER_SEC + (s64)nsecs };
+        return secs * NSEC_PER_SEC + (s64)nsecs;
 }
 
 /* Subtract two ktime_t variables. rem = lhs -rhs: */
-#define ktime_sub(lhs, rhs) \
-                ({ (ktime_t){ .tv64 = (lhs).tv64 - (rhs).tv64 }; })
+#define ktime_sub(lhs, rhs)     ((lhs) - (rhs))
 
 /* Add two ktime_t variables. res = lhs + rhs: */
-#define ktime_add(lhs, rhs) \
-                ({ (ktime_t){ .tv64 = (lhs).tv64 + (rhs).tv64 }; })
+#define ktime_add(lhs, rhs)     ((lhs) + (rhs))
 
 /*
  * Same as ktime_add(), but avoids undefined behaviour on overflow; however,
  * this means that you must check the result for overflow yourself.
  */
-#define ktime_add_unsafe(lhs, rhs) \
-                ({ (ktime_t){ .tv64 = (u64) (lhs).tv64 + (rhs).tv64 }; })
+#define ktime_add_unsafe(lhs, rhs)      ((u64) (lhs) + (rhs))
 
 /*
  * Add a ktime_t variable and a scalar nanosecond value.
  * res = kt + nsval:
  */
-#define ktime_add_ns(kt, nsval) \
-                ({ (ktime_t){ .tv64 = (kt).tv64 + (nsval) }; })
+#define ktime_add_ns(kt, nsval)         ((kt) + (nsval))
 
 /*
  * Subtract a scalar nanosecod from a ktime_t variable
  * res = kt - nsval:
  */
-#define ktime_sub_ns(kt, nsval) \
-                ({ (ktime_t){ .tv64 = (kt).tv64 - (nsval) }; })
+#define ktime_sub_ns(kt, nsval)         ((kt) - (nsval))
 
 /* convert a timespec to ktime_t format: */
 static inline ktime_t timespec_to_ktime(struct timespec ts)
@@ -103,16 +85,16 @@ static inline ktime_t timeval_to_ktime(struct timeval tv)
 }
 
 /* Map the ktime_t to timespec conversion to ns_to_timespec function */
-#define ktime_to_timespec(kt)           ns_to_timespec((kt).tv64)
+#define ktime_to_timespec(kt)           ns_to_timespec((kt))
 
 /* Map the ktime_t to timespec conversion to ns_to_timespec function */
-#define ktime_to_timespec64(kt)         ns_to_timespec64((kt).tv64)
+#define ktime_to_timespec64(kt)         ns_to_timespec64((kt))
 
 /* Map the ktime_t to timeval conversion to ns_to_timeval function */
-#define ktime_to_timeval(kt)            ns_to_timeval((kt).tv64)
+#define ktime_to_timeval(kt)            ns_to_timeval((kt))
 
 /* Convert ktime_t to nanoseconds - NOP in the scalar storage format: */
-#define ktime_to_ns(kt)                 ((kt).tv64)
+#define ktime_to_ns(kt)                 (kt)
 
 
 /**
@@ -126,7 +108,7 @@ static inline ktime_t timeval_to_ktime(struct timeval tv)
  */
 static inline int ktime_equal(const ktime_t cmp1, const ktime_t cmp2)
 {
-        return cmp1.tv64 == cmp2.tv64;
+        return cmp1 == cmp2;
 }
 
 /**
@@ -141,9 +123,9 @@ static inline int ktime_equal(const ktime_t cmp1, const ktime_t cmp2)
  */
 static inline int ktime_compare(const ktime_t cmp1, const ktime_t cmp2)
 {
-        if (cmp1.tv64 < cmp2.tv64)
+        if (cmp1 < cmp2)
                 return -1;
-        if (cmp1.tv64 > cmp2.tv64)
+        if (cmp1 > cmp2)
                 return 1;
         return 0;
 }
@@ -182,7 +164,7 @@ static inline s64 ktime_divns(const ktime_t kt, s64 div)
          */
         BUG_ON(div < 0);
         if (__builtin_constant_p(div) && !(div >> 32)) {
-                s64 ns = kt.tv64;
+                s64 ns = kt;
                 u64 tmp = ns < 0 ? -ns : ns;
 
                 do_div(tmp, div);
@@ -199,7 +181,7 @@ static inline s64 ktime_divns(const ktime_t kt, s64 div)
          * so catch them on 64bit as well.
          */
         WARN_ON(div < 0);
-        return kt.tv64 / div;
+        return kt / div;
 }
 #endif
 
@@ -256,7 +238,7 @@ extern ktime_t ktime_add_safe(const ktime_t lhs, const ktime_t rhs);
 static inline __must_check bool ktime_to_timespec_cond(const ktime_t kt,
                                                        struct timespec *ts)
 {
-        if (kt.tv64) {
+        if (kt) {
                 *ts = ktime_to_timespec(kt);
                 return true;
         } else {
@@ -275,7 +257,7 @@ static inline __must_check bool ktime_to_timespec_cond(const ktime_t kt,
 static inline __must_check bool ktime_to_timespec64_cond(const ktime_t kt,
                                                        struct timespec64 *ts)
 {
-        if (kt.tv64) {
+        if (kt) {
                 *ts = ktime_to_timespec64(kt);
                 return true;
         } else {
@@ -290,20 +272,16 @@ static inline __must_check bool ktime_to_timespec64_cond(const ktime_t kt,
  * this resolution values.
  */
 #define LOW_RES_NSEC            TICK_NSEC
-#define KTIME_LOW_RES           (ktime_t){ .tv64 = LOW_RES_NSEC }
+#define KTIME_LOW_RES           (LOW_RES_NSEC)
 
 static inline ktime_t ns_to_ktime(u64 ns)
 {
-        static const ktime_t ktime_zero = { .tv64 = 0 };
-
-        return ktime_add_ns(ktime_zero, ns);
+        return ns;
 }
 
 static inline ktime_t ms_to_ktime(u64 ms)
 {
-        static const ktime_t ktime_zero = { .tv64 = 0 };
-
-        return ktime_add_ms(ktime_zero, ms);
+        return ms * NSEC_PER_MSEC;
 }
 
 # include <linux/timekeeping.h>
diff --git a/include/linux/tick.h b/include/linux/tick.h
index 62be0786d6d0..a04fea19676f 100644
--- a/include/linux/tick.h
+++ b/include/linux/tick.h
@@ -127,9 +127,7 @@ static inline void tick_nohz_idle_exit(void) { }
 
 static inline ktime_t tick_nohz_get_sleep_length(void)
 {
-        ktime_t len = { .tv64 = NSEC_PER_SEC/HZ };
-
-        return len;
+        return NSEC_PER_SEC / HZ;
 }
 static inline u64 get_cpu_idle_time_us(int cpu, u64 *unused) { return -1; }
 static inline u64 get_cpu_iowait_time_us(int cpu, u64 *unused) { return -1; }
diff --git a/include/linux/wait.h b/include/linux/wait.h
index 2408e8d5c05c..1421132e9086 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -510,7 +510,7 @@ do {									\
         hrtimer_init_on_stack(&__t.timer, CLOCK_MONOTONIC,              \
                               HRTIMER_MODE_REL);                        \
         hrtimer_init_sleeper(&__t, current);                            \
-        if ((timeout).tv64 != KTIME_MAX)                                \
+        if ((timeout) != KTIME_MAX)                             \
                 hrtimer_start_range_ns(&__t.timer, timeout,             \
                                        current->timer_slack_ns,         \
                                        HRTIMER_MODE_REL);               \
diff --git a/include/net/red.h b/include/net/red.h
index 76e0b5f922c6..208e718e16b9 100644
--- a/include/net/red.h
+++ b/include/net/red.h
@@ -207,7 +207,7 @@ static inline void red_set_parms(struct red_parms *p,
 
 static inline int red_is_idling(const struct red_vars *v)
 {
-        return v->qidlestart.tv64 != 0;
+        return v->qidlestart != 0;
 }
 
 static inline void red_start_of_idle_period(struct red_vars *v)
@@ -217,7 +217,7 @@ static inline void red_start_of_idle_period(struct red_vars *v)
 
 static inline void red_end_of_idle_period(struct red_vars *v)
 {
-        v->qidlestart.tv64 = 0;
+        v->qidlestart = 0;
 }
 
 static inline void red_restart(struct red_vars *v)
diff --git a/include/net/sock.h b/include/net/sock.h
index 282d065e286b..f0e867f58722 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -2193,8 +2193,8 @@ sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
          */
         if (sock_flag(sk, SOCK_RCVTSTAMP) ||
             (sk->sk_tsflags & SOF_TIMESTAMPING_RX_SOFTWARE) ||
-            (kt.tv64 && sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) ||
-            (hwtstamps->hwtstamp.tv64 &&
+            (kt && sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) ||
+            (hwtstamps->hwtstamp &&
              (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE)))
                 __sock_recv_timestamp(msg, sk, skb);
         else
diff --git a/include/trace/events/alarmtimer.h b/include/trace/events/alarmtimer.h
index a1c108c16c9c..ae4f358dd8e9 100644
--- a/include/trace/events/alarmtimer.h
+++ b/include/trace/events/alarmtimer.h
@@ -31,7 +31,7 @@ TRACE_EVENT(alarmtimer_suspend,
         ),
 
         TP_fast_assign(
-                __entry->expires = expires.tv64;
+                __entry->expires = expires;
                 __entry->alarm_type = flag;
         ),
 
@@ -57,8 +57,8 @@ DECLARE_EVENT_CLASS(alarm_class,
         TP_fast_assign(
                 __entry->alarm = alarm;
                 __entry->alarm_type = alarm->type;
-                __entry->expires = alarm->node.expires.tv64;
-                __entry->now = now.tv64;
+                __entry->expires = alarm->node.expires;
+                __entry->now = now;
         ),
 
         TP_printk("alarmtimer:%p type:%s expires:%llu now:%llu",
diff --git a/include/trace/events/timer.h b/include/trace/events/timer.h
index 28c5da6fdfac..1448637616d6 100644
--- a/include/trace/events/timer.h
+++ b/include/trace/events/timer.h
@@ -177,16 +177,14 @@ TRACE_EVENT(hrtimer_start,
         TP_fast_assign(
                 __entry->hrtimer        = hrtimer;
                 __entry->function       = hrtimer->function;
-                __entry->expires        = hrtimer_get_expires(hrtimer).tv64;
-                __entry->softexpires    = hrtimer_get_softexpires(hrtimer).tv64;
+                __entry->expires        = hrtimer_get_expires(hrtimer);
+                __entry->softexpires    = hrtimer_get_softexpires(hrtimer);
         ),
 
         TP_printk("hrtimer=%p function=%pf expires=%llu softexpires=%llu",
                   __entry->hrtimer, __entry->function,
-                  (unsigned long long)ktime_to_ns((ktime_t) {
-                                  .tv64 = __entry->expires }),
-                  (unsigned long long)ktime_to_ns((ktime_t) {
-                                  .tv64 = __entry->softexpires }))
+                  (unsigned long long) __entry->expires,
+                  (unsigned long long) __entry->softexpires)
 );
 
 /**
@@ -211,13 +209,13 @@ TRACE_EVENT(hrtimer_expire_entry,
 
         TP_fast_assign(
                 __entry->hrtimer        = hrtimer;
-                __entry->now            = now->tv64;
+                __entry->now            = *now;
                 __entry->function       = hrtimer->function;
         ),
 
         TP_printk("hrtimer=%p function=%pf now=%llu", __entry->hrtimer, __entry->function,
-                  (unsigned long long)ktime_to_ns((ktime_t) { .tv64 = __entry->now }))
- );
+                  (unsigned long long) __entry->now)
+);
 
 DECLARE_EVENT_CLASS(hrtimer_class,
 
diff --git a/kernel/futex.c b/kernel/futex.c
index 9246d9f593d1..0842c8ca534b 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -2459,7 +2459,7 @@ retry:
         restart->fn = futex_wait_restart;
         restart->futex.uaddr = uaddr;
         restart->futex.val = val;
-        restart->futex.time = abs_time->tv64;
+        restart->futex.time = *abs_time;
         restart->futex.bitset = bitset;
         restart->futex.flags = flags | FLAGS_HAS_TIMEOUT;
 
@@ -2480,7 +2480,7 @@ static long futex_wait_restart(struct restart_block *restart)
         ktime_t t, *tp = NULL;
 
         if (restart->futex.flags & FLAGS_HAS_TIMEOUT) {
-                t.tv64 = restart->futex.time;
+                t = restart->futex.time;
                 tp = &t;
         }
         restart->fn = do_no_restart_syscall;
diff --git a/kernel/signal.c b/kernel/signal.c
index f5d4e275345e..ff046b73ff2d 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -587,7 +587,7 @@ int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
                         struct hrtimer *tmr = &tsk->signal->real_timer;
 
                         if (!hrtimer_is_queued(tmr) &&
-                            tsk->signal->it_real_incr.tv64 != 0) {
+                            tsk->signal->it_real_incr != 0) {
                                 hrtimer_forward(tmr, tmr->base->get_time(),
                                                 tsk->signal->it_real_incr);
                                 hrtimer_restart(tmr);
@@ -2766,7 +2766,7 @@ int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
 int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
                     const struct timespec *ts)
 {
-        ktime_t *to = NULL, timeout = { .tv64 = KTIME_MAX };
+        ktime_t *to = NULL, timeout = KTIME_MAX;
         struct task_struct *tsk = current;
         sigset_t mask = *which;
         int sig, ret = 0;
@@ -2786,7 +2786,7 @@ int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
 
         spin_lock_irq(&tsk->sighand->siglock);
         sig = dequeue_signal(tsk, &mask, info);
-        if (!sig && timeout.tv64) {
+        if (!sig && timeout) {
                 /*
                  * None ready, temporarily unblock those we're interested
                  * while we are sleeping in so that we'll be awakened when
diff --git a/kernel/time/alarmtimer.c b/kernel/time/alarmtimer.c
index 3921cf7fea8e..ab6ac077bdb7 100644
--- a/kernel/time/alarmtimer.c
+++ b/kernel/time/alarmtimer.c
@@ -254,13 +254,13 @@ static int alarmtimer_suspend(struct device *dev)
                 if (!next)
                         continue;
                 delta = ktime_sub(next->expires, base->gettime());
-                if (!min.tv64 || (delta.tv64 < min.tv64)) {
+                if (!min || (delta < min)) {
                         expires = next->expires;
                         min = delta;
                         type = i;
                 }
         }
-        if (min.tv64 == 0)
+        if (min == 0)
                 return 0;
 
         if (ktime_to_ns(min) < 2 * NSEC_PER_SEC) {
@@ -328,7 +328,7 @@ static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
         delta = ktime_sub(absexp, base->gettime());
 
         spin_lock_irqsave(&freezer_delta_lock, flags);
-        if (!freezer_delta.tv64 || (delta.tv64 < freezer_delta.tv64)) {
+        if (!freezer_delta || (delta < freezer_delta)) {
                 freezer_delta = delta;
                 freezer_expires = absexp;
                 freezer_alarmtype = type;
@@ -453,10 +453,10 @@ u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval)
 
         delta = ktime_sub(now, alarm->node.expires);
 
-        if (delta.tv64 < 0)
+        if (delta < 0)
                 return 0;
 
-        if (unlikely(delta.tv64 >= interval.tv64)) {
+        if (unlikely(delta >= interval)) {
                 s64 incr = ktime_to_ns(interval);
 
                 overrun = ktime_divns(delta, incr);
@@ -464,7 +464,7 @@ u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval)
                 alarm->node.expires = ktime_add_ns(alarm->node.expires,
                                                         incr*overrun);
 
-                if (alarm->node.expires.tv64 > now.tv64)
+                if (alarm->node.expires > now)
                         return overrun;
                 /*
                  * This (and the ktime_add() below) is the
@@ -522,7 +522,7 @@ static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,
         }
 
         /* Re-add periodic timers */
-        if (ptr->it.alarm.interval.tv64) {
+        if (ptr->it.alarm.interval) {
                 ptr->it_overrun += alarm_forward(alarm, now,
                                                 ptr->it.alarm.interval);
                 result = ALARMTIMER_RESTART;
@@ -730,7 +730,7 @@ static int update_rmtp(ktime_t exp, enum  alarmtimer_type type,
 
         rem = ktime_sub(exp, alarm_bases[type].gettime());
 
-        if (rem.tv64 <= 0)
+        if (rem <= 0)
                 return 0;
         rmt = ktime_to_timespec(rem);
 
@@ -755,7 +755,7 @@ static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
         struct alarm alarm;
         int ret = 0;
 
-        exp.tv64 = restart->nanosleep.expires;
+        exp = restart->nanosleep.expires;
         alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
 
         if (alarmtimer_do_nsleep(&alarm, exp))
@@ -835,7 +835,7 @@ static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
         restart = &current->restart_block;
         restart->fn = alarm_timer_nsleep_restart;
         restart->nanosleep.clockid = type;
-        restart->nanosleep.expires = exp.tv64;
+        restart->nanosleep.expires = exp;
         restart->nanosleep.rmtp = rmtp;
         ret = -ERESTART_RESTARTBLOCK;
 
diff --git a/kernel/time/clockevents.c b/kernel/time/clockevents.c
index 2c5bc77c0bb0..97ac0951f164 100644
--- a/kernel/time/clockevents.c
+++ b/kernel/time/clockevents.c
@@ -179,7 +179,7 @@ void clockevents_switch_state(struct clock_event_device *dev,
 void clockevents_shutdown(struct clock_event_device *dev)
 {
         clockevents_switch_state(dev, CLOCK_EVT_STATE_SHUTDOWN);
-        dev->next_event.tv64 = KTIME_MAX;
+        dev->next_event = KTIME_MAX;
 }
 
 /**
@@ -213,7 +213,7 @@ static int clockevents_increase_min_delta(struct clock_event_device *dev)
         if (dev->min_delta_ns >= MIN_DELTA_LIMIT) {
                 printk_deferred(KERN_WARNING
                                 "CE: Reprogramming failure. Giving up\n");
-                dev->next_event.tv64 = KTIME_MAX;
+                dev->next_event = KTIME_MAX;
                 return -ETIME;
         }
 
@@ -310,7 +310,7 @@ int clockevents_program_event(struct clock_event_device *dev, ktime_t expires,
         int64_t delta;
         int rc;
 
-        if (unlikely(expires.tv64 < 0)) {
+        if (unlikely(expires < 0)) {
                 WARN_ON_ONCE(1);
                 return -ETIME;
         }
diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c
index 161e340395d5..c7f780113884 100644
--- a/kernel/time/hrtimer.c
+++ b/kernel/time/hrtimer.c
@@ -171,7 +171,7 @@ hrtimer_check_target(struct hrtimer *timer, struct hrtimer_clock_base *new_base)
                 return 0;
 
         expires = ktime_sub(hrtimer_get_expires(timer), new_base->offset);
-        return expires.tv64 <= new_base->cpu_base->expires_next.tv64;
+        return expires <= new_base->cpu_base->expires_next;
 #else
         return 0;
 #endif
@@ -313,7 +313,7 @@ ktime_t ktime_add_safe(const ktime_t lhs, const ktime_t rhs)
          * We use KTIME_SEC_MAX here, the maximum timeout which we can
          * return to user space in a timespec:
          */
-        if (res.tv64 < 0 || res.tv64 < lhs.tv64 || res.tv64 < rhs.tv64)
+        if (res < 0 || res < lhs || res < rhs)
                 res = ktime_set(KTIME_SEC_MAX, 0);
 
         return res;
@@ -465,8 +465,8 @@ static inline void hrtimer_update_next_timer(struct hrtimer_cpu_base *cpu_base,
 static ktime_t __hrtimer_get_next_event(struct hrtimer_cpu_base *cpu_base)
 {
         struct hrtimer_clock_base *base = cpu_base->clock_base;
-        ktime_t expires, expires_next = { .tv64 = KTIME_MAX };
         unsigned int active = cpu_base->active_bases;
+        ktime_t expires, expires_next = KTIME_MAX;
 
         hrtimer_update_next_timer(cpu_base, NULL);
         for (; active; base++, active >>= 1) {
@@ -479,7 +479,7 @@ static ktime_t __hrtimer_get_next_event(struct hrtimer_cpu_base *cpu_base)
                 next = timerqueue_getnext(&base->active);
                 timer = container_of(next, struct hrtimer, node);
                 expires = ktime_sub(hrtimer_get_expires(timer), base->offset);
-                if (expires.tv64 < expires_next.tv64) {
+                if (expires < expires_next) {
                         expires_next = expires;
                         hrtimer_update_next_timer(cpu_base, timer);
                 }
@@ -489,8 +489,8 @@ static ktime_t __hrtimer_get_next_event(struct hrtimer_cpu_base *cpu_base)
          * the clock bases so the result might be negative. Fix it up
          * to prevent a false positive in clockevents_program_event().
          */
-        if (expires_next.tv64 < 0)
-                expires_next.tv64 = 0;
+        if (expires_next < 0)
+                expires_next = 0;
         return expires_next;
 }
 #endif
@@ -561,10 +561,10 @@ hrtimer_force_reprogram(struct hrtimer_cpu_base *cpu_base, int skip_equal)
 
         expires_next = __hrtimer_get_next_event(cpu_base);
 
-        if (skip_equal && expires_next.tv64 == cpu_base->expires_next.tv64)
+        if (skip_equal && expires_next == cpu_base->expires_next)
                 return;
 
-        cpu_base->expires_next.tv64 = expires_next.tv64;
+        cpu_base->expires_next = expires_next;
 
         /*
          * If a hang was detected in the last timer interrupt then we
@@ -622,10 +622,10 @@ static void hrtimer_reprogram(struct hrtimer *timer,
          * CLOCK_REALTIME timer might be requested with an absolute
          * expiry time which is less than base->offset. Set it to 0.
          */
-        if (expires.tv64 < 0)
-                expires.tv64 = 0;
+        if (expires < 0)
+                expires = 0;
 
-        if (expires.tv64 >= cpu_base->expires_next.tv64)
+        if (expires >= cpu_base->expires_next)
                 return;
 
         /* Update the pointer to the next expiring timer */
@@ -653,7 +653,7 @@ static void hrtimer_reprogram(struct hrtimer *timer,
  */
 static inline void hrtimer_init_hres(struct hrtimer_cpu_base *base)
 {
-        base->expires_next.tv64 = KTIME_MAX;
+        base->expires_next = KTIME_MAX;
         base->hres_active = 0;
 }
 
@@ -827,21 +827,21 @@ u64 hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval)
 
         delta = ktime_sub(now, hrtimer_get_expires(timer));
 
-        if (delta.tv64 < 0)
+        if (delta < 0)
                 return 0;
 
         if (WARN_ON(timer->state & HRTIMER_STATE_ENQUEUED))
                 return 0;
 
-        if (interval.tv64 < hrtimer_resolution)
-                interval.tv64 = hrtimer_resolution;
+        if (interval < hrtimer_resolution)
+                interval = hrtimer_resolution;
 
-        if (unlikely(delta.tv64 >= interval.tv64)) {
+        if (unlikely(delta >= interval)) {
                 s64 incr = ktime_to_ns(interval);
 
                 orun = ktime_divns(delta, incr);
                 hrtimer_add_expires_ns(timer, incr * orun);
-                if (hrtimer_get_expires_tv64(timer) > now.tv64)
+                if (hrtimer_get_expires_tv64(timer) > now)
                         return orun;
                 /*
                  * This (and the ktime_add() below) is the
@@ -1104,7 +1104,7 @@ u64 hrtimer_get_next_event(void)
         raw_spin_lock_irqsave(&cpu_base->lock, flags);
 
         if (!__hrtimer_hres_active(cpu_base))
-                expires = __hrtimer_get_next_event(cpu_base).tv64;
+                expires = __hrtimer_get_next_event(cpu_base);
 
         raw_spin_unlock_irqrestore(&cpu_base->lock, flags);
 
@@ -1296,7 +1296,7 @@ static void __hrtimer_run_queues(struct hrtimer_cpu_base *cpu_base, ktime_t now)
                          * are right-of a not yet expired timer, because that
                          * timer will have to trigger a wakeup anyway.
                          */
-                        if (basenow.tv64 < hrtimer_get_softexpires_tv64(timer))
+                        if (basenow < hrtimer_get_softexpires_tv64(timer))
                                 break;
 
                         __run_hrtimer(cpu_base, base, timer, &basenow);
@@ -1318,7 +1318,7 @@ void hrtimer_interrupt(struct clock_event_device *dev)
 
         BUG_ON(!cpu_base->hres_active);
         cpu_base->nr_events++;
-        dev->next_event.tv64 = KTIME_MAX;
+        dev->next_event = KTIME_MAX;
 
         raw_spin_lock(&cpu_base->lock);
         entry_time = now = hrtimer_update_base(cpu_base);
@@ -1331,7 +1331,7 @@ retry:
          * timers which run their callback and need to be requeued on
          * this CPU.
          */
-        cpu_base->expires_next.tv64 = KTIME_MAX;
+        cpu_base->expires_next = KTIME_MAX;
 
         __hrtimer_run_queues(cpu_base, now);
 
@@ -1379,13 +1379,13 @@ retry:
         cpu_base->hang_detected = 1;
         raw_spin_unlock(&cpu_base->lock);
         delta = ktime_sub(now, entry_time);
-        if ((unsigned int)delta.tv64 > cpu_base->max_hang_time)
-                cpu_base->max_hang_time = (unsigned int) delta.tv64;
+        if ((unsigned int)delta > cpu_base->max_hang_time)
+                cpu_base->max_hang_time = (unsigned int) delta;
         /*
          * Limit it to a sensible value as we enforce a longer
          * delay. Give the CPU at least 100ms to catch up.
          */
-        if (delta.tv64 > 100 * NSEC_PER_MSEC)
+        if (delta > 100 * NSEC_PER_MSEC)
                 expires_next = ktime_add_ns(now, 100 * NSEC_PER_MSEC);
         else
                 expires_next = ktime_add(now, delta);
@@ -1495,7 +1495,7 @@ static int update_rmtp(struct hrtimer *timer, struct timespec __user *rmtp)
         ktime_t rem;
 
         rem = hrtimer_expires_remaining(timer);
-        if (rem.tv64 <= 0)
+        if (rem <= 0)
                 return 0;
         rmt = ktime_to_timespec(rem);
 
@@ -1693,7 +1693,7 @@ schedule_hrtimeout_range_clock(ktime_t *expires, u64 delta,
          * Optimize when a zero timeout value is given. It does not
          * matter whether this is an absolute or a relative time.
          */
-        if (expires && !expires->tv64) {
+        if (expires && *expires == 0) {
                 __set_current_state(TASK_RUNNING);
                 return 0;
         }
diff --git a/kernel/time/itimer.c b/kernel/time/itimer.c
index a45afb7277c2..8c89143f9ebf 100644
--- a/kernel/time/itimer.c
+++ b/kernel/time/itimer.c
@@ -34,10 +34,10 @@ static struct timeval itimer_get_remtime(struct hrtimer *timer)
          * then we return 0 - which is correct.
          */
         if (hrtimer_active(timer)) {
-                if (rem.tv64 <= 0)
-                        rem.tv64 = NSEC_PER_USEC;
+                if (rem <= 0)
+                        rem = NSEC_PER_USEC;
         } else
-                rem.tv64 = 0;
+                rem = 0;
 
         return ktime_to_timeval(rem);
 }
@@ -216,12 +216,12 @@ again:
                         goto again;
                 }
                 expires = timeval_to_ktime(value->it_value);
-                if (expires.tv64 != 0) {
+                if (expires != 0) {
                         tsk->signal->it_real_incr =
                                 timeval_to_ktime(value->it_interval);
                         hrtimer_start(timer, expires, HRTIMER_MODE_REL);
                 } else
-                        tsk->signal->it_real_incr.tv64 = 0;
+                        tsk->signal->it_real_incr = 0;
 
                 trace_itimer_state(ITIMER_REAL, value, 0);
                 spin_unlock_irq(&tsk->sighand->siglock);
diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index 6df8927c58a5..edf19cc53140 100644
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -381,7 +381,7 @@ ktime_t ntp_get_next_leap(void)
 
         if ((time_state == TIME_INS) && (time_status & STA_INS))
                 return ktime_set(ntp_next_leap_sec, 0);
-        ret.tv64 = KTIME_MAX;
+        ret = KTIME_MAX;
         return ret;
 }
 
diff --git a/kernel/time/posix-timers.c b/kernel/time/posix-timers.c
index 42d7b9558741..9fe98b3777a2 100644
--- a/kernel/time/posix-timers.c
+++ b/kernel/time/posix-timers.c
@@ -359,7 +359,7 @@ static void schedule_next_timer(struct k_itimer *timr)
 {
         struct hrtimer *timer = &timr->it.real.timer;
 
-        if (timr->it.real.interval.tv64 == 0)
+        if (timr->it.real.interval == 0)
                 return;
 
         timr->it_overrun += (unsigned int) hrtimer_forward(timer,
@@ -449,7 +449,7 @@ static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
         timr = container_of(timer, struct k_itimer, it.real.timer);
         spin_lock_irqsave(&timr->it_lock, flags);
 
-        if (timr->it.real.interval.tv64 != 0)
+        if (timr->it.real.interval != 0)
                 si_private = ++timr->it_requeue_pending;
 
         if (posix_timer_event(timr, si_private)) {
@@ -458,7 +458,7 @@ static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
                  * we will not get a call back to restart it AND
                  * it should be restarted.
                  */
-                if (timr->it.real.interval.tv64 != 0) {
+                if (timr->it.real.interval != 0) {
                         ktime_t now = hrtimer_cb_get_time(timer);
 
                         /*
@@ -487,7 +487,7 @@ static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
                         {
                                 ktime_t kj = ktime_set(0, NSEC_PER_SEC / HZ);
 
-                                if (timr->it.real.interval.tv64 < kj.tv64)
+                                if (timr->it.real.interval < kj)
                                         now = ktime_add(now, kj);
                         }
 #endif
@@ -743,7 +743,7 @@ common_timer_get(struct k_itimer *timr, struct itimerspec *cur_setting)
         iv = timr->it.real.interval;
 
         /* interval timer ? */
-        if (iv.tv64)
+        if (iv)
                 cur_setting->it_interval = ktime_to_timespec(iv);
         else if (!hrtimer_active(timer) &&
                  (timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
@@ -756,13 +756,13 @@ common_timer_get(struct k_itimer *timr, struct itimerspec *cur_setting)
          * timer move the expiry time forward by intervals, so
          * expiry is > now.
          */
-        if (iv.tv64 && (timr->it_requeue_pending & REQUEUE_PENDING ||
-            (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
+        if (iv && (timr->it_requeue_pending & REQUEUE_PENDING ||
+                   (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
                 timr->it_overrun += (unsigned int) hrtimer_forward(timer, now, iv);
 
         remaining = __hrtimer_expires_remaining_adjusted(timer, now);
         /* Return 0 only, when the timer is expired and not pending */
-        if (remaining.tv64 <= 0) {
+        if (remaining <= 0) {
                 /*
                  * A single shot SIGEV_NONE timer must return 0, when
                  * it is expired !
@@ -839,7 +839,7 @@ common_timer_set(struct k_itimer *timr, int flags,
                 common_timer_get(timr, old_setting);
 
         /* disable the timer */
-        timr->it.real.interval.tv64 = 0;
+        timr->it.real.interval = 0;
         /*
          * careful here.  If smp we could be in the "fire" routine which will
          * be spinning as we hold the lock.  But this is ONLY an SMP issue.
@@ -924,7 +924,7 @@ retry:
 
 static int common_timer_del(struct k_itimer *timer)
 {
-        timer->it.real.interval.tv64 = 0;
+        timer->it.real.interval = 0;
 
         if (hrtimer_try_to_cancel(&timer->it.real.timer) < 0)
                 return TIMER_RETRY;
diff --git a/kernel/time/tick-broadcast-hrtimer.c b/kernel/time/tick-broadcast-hrtimer.c
index 690b797f522e..a7bb8f33ae07 100644
--- a/kernel/time/tick-broadcast-hrtimer.c
+++ b/kernel/time/tick-broadcast-hrtimer.c
@@ -97,7 +97,7 @@ static enum hrtimer_restart bc_handler(struct hrtimer *t)
         ce_broadcast_hrtimer.event_handler(&ce_broadcast_hrtimer);
 
         if (clockevent_state_oneshot(&ce_broadcast_hrtimer))
-                if (ce_broadcast_hrtimer.next_event.tv64 != KTIME_MAX)
+                if (ce_broadcast_hrtimer.next_event != KTIME_MAX)
                         return HRTIMER_RESTART;
 
         return HRTIMER_NORESTART;
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index d2a20e83ebae..3109204c87cc 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -604,14 +604,14 @@ static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
         bool bc_local;
 
         raw_spin_lock(&tick_broadcast_lock);
-        dev->next_event.tv64 = KTIME_MAX;
-        next_event.tv64 = KTIME_MAX;
+        dev->next_event = KTIME_MAX;
+        next_event = KTIME_MAX;
         cpumask_clear(tmpmask);
         now = ktime_get();
         /* Find all expired events */
         for_each_cpu(cpu, tick_broadcast_oneshot_mask) {
                 td = &per_cpu(tick_cpu_device, cpu);
-                if (td->evtdev->next_event.tv64 <= now.tv64) {
+                if (td->evtdev->next_event <= now) {
                         cpumask_set_cpu(cpu, tmpmask);
                         /*
                          * Mark the remote cpu in the pending mask, so
@@ -619,8 +619,8 @@ static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
                          * timer in tick_broadcast_oneshot_control().
                          */
                         cpumask_set_cpu(cpu, tick_broadcast_pending_mask);
-                } else if (td->evtdev->next_event.tv64 < next_event.tv64) {
-                        next_event.tv64 = td->evtdev->next_event.tv64;
+                } else if (td->evtdev->next_event < next_event) {
+                        next_event = td->evtdev->next_event;
                         next_cpu = cpu;
                 }
         }
@@ -657,7 +657,7 @@ static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
          * - There are pending events on sleeping CPUs which were not
          * in the event mask
          */
-        if (next_event.tv64 != KTIME_MAX)
+        if (next_event != KTIME_MAX)
                 tick_broadcast_set_event(dev, next_cpu, next_event);
 
         raw_spin_unlock(&tick_broadcast_lock);
@@ -672,7 +672,7 @@ static int broadcast_needs_cpu(struct clock_event_device *bc, int cpu)
 {
         if (!(bc->features & CLOCK_EVT_FEAT_HRTIMER))
                 return 0;
-        if (bc->next_event.tv64 == KTIME_MAX)
+        if (bc->next_event == KTIME_MAX)
                 return 0;
         return bc->bound_on == cpu ? -EBUSY : 0;
 }
@@ -688,7 +688,7 @@ static void broadcast_shutdown_local(struct clock_event_device *bc,
         if (bc->features & CLOCK_EVT_FEAT_HRTIMER) {
                 if (broadcast_needs_cpu(bc, smp_processor_id()))
                         return;
-                if (dev->next_event.tv64 < bc->next_event.tv64)
+                if (dev->next_event < bc->next_event)
                         return;
         }
         clockevents_switch_state(dev, CLOCK_EVT_STATE_SHUTDOWN);
@@ -754,7 +754,7 @@ int __tick_broadcast_oneshot_control(enum tick_broadcast_state state)
                          */
                         if (cpumask_test_cpu(cpu, tick_broadcast_force_mask)) {
                                 ret = -EBUSY;
-                        } else if (dev->next_event.tv64 < bc->next_event.tv64) {
+                        } else if (dev->next_event < bc->next_event) {
                                 tick_broadcast_set_event(bc, cpu, dev->next_event);
                                 /*
                                  * In case of hrtimer broadcasts the
@@ -789,7 +789,7 @@ int __tick_broadcast_oneshot_control(enum tick_broadcast_state state)
                         /*
                          * Bail out if there is no next event.
                          */
-                        if (dev->next_event.tv64 == KTIME_MAX)
+                        if (dev->next_event == KTIME_MAX)
                                 goto out;
                         /*
                          * If the pending bit is not set, then we are
@@ -824,7 +824,7 @@ int __tick_broadcast_oneshot_control(enum tick_broadcast_state state)
                          * nohz fixups.
                          */
                         now = ktime_get();
-                        if (dev->next_event.tv64 <= now.tv64) {
+                        if (dev->next_event <= now) {
                                 cpumask_set_cpu(cpu, tick_broadcast_force_mask);
                                 goto out;
                         }
@@ -897,7 +897,7 @@ void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
                                                        tick_next_period);
                         tick_broadcast_set_event(bc, cpu, tick_next_period);
                 } else
-                        bc->next_event.tv64 = KTIME_MAX;
+                        bc->next_event = KTIME_MAX;
         } else {
                 /*
                  * The first cpu which switches to oneshot mode sets
diff --git a/kernel/time/tick-oneshot.c b/kernel/time/tick-oneshot.c
index b51344652330..6b009c207671 100644
--- a/kernel/time/tick-oneshot.c
+++ b/kernel/time/tick-oneshot.c
@@ -28,7 +28,7 @@ int tick_program_event(ktime_t expires, int force)
 {
         struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev);
 
-        if (unlikely(expires.tv64 == KTIME_MAX)) {
+        if (unlikely(expires == KTIME_MAX)) {
                 /*
                  * We don't need the clock event device any more, stop it.
                  */
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 71496a20e670..2c115fdab397 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -58,21 +58,21 @@ static void tick_do_update_jiffies64(ktime_t now)
          * Do a quick check without holding jiffies_lock:
          */
         delta = ktime_sub(now, last_jiffies_update);
-        if (delta.tv64 < tick_period.tv64)
+        if (delta < tick_period)
                 return;
 
         /* Reevaluate with jiffies_lock held */
         write_seqlock(&jiffies_lock);
 
         delta = ktime_sub(now, last_jiffies_update);
-        if (delta.tv64 >= tick_period.tv64) {
+        if (delta >= tick_period) {
 
                 delta = ktime_sub(delta, tick_period);
                 last_jiffies_update = ktime_add(last_jiffies_update,
                                                 tick_period);
 
                 /* Slow path for long timeouts */
-                if (unlikely(delta.tv64 >= tick_period.tv64)) {
+                if (unlikely(delta >= tick_period)) {
                         s64 incr = ktime_to_ns(tick_period);
 
                         ticks = ktime_divns(delta, incr);
@@ -101,7 +101,7 @@ static ktime_t tick_init_jiffy_update(void)
 
         write_seqlock(&jiffies_lock);
         /* Did we start the jiffies update yet ? */
-        if (last_jiffies_update.tv64 == 0)
+        if (last_jiffies_update == 0)
                 last_jiffies_update = tick_next_period;
         period = last_jiffies_update;
         write_sequnlock(&jiffies_lock);
@@ -669,7 +669,7 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
         /* Read jiffies and the time when jiffies were updated last */
         do {
                 seq = read_seqbegin(&jiffies_lock);
-                basemono = last_jiffies_update.tv64;
+                basemono = last_jiffies_update;
                 basejiff = jiffies;
         } while (read_seqretry(&jiffies_lock, seq));
         ts->last_jiffies = basejiff;
@@ -697,7 +697,7 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
          */
         delta = next_tick - basemono;
         if (delta <= (u64)TICK_NSEC) {
-                tick.tv64 = 0;
+                tick = 0;
 
                 /*
                  * Tell the timer code that the base is not idle, i.e. undo
@@ -764,10 +764,10 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
                 expires = KTIME_MAX;
 
         expires = min_t(u64, expires, next_tick);
-        tick.tv64 = expires;
+        tick = expires;
 
         /* Skip reprogram of event if its not changed */
-        if (ts->tick_stopped && (expires == dev->next_event.tv64))
+        if (ts->tick_stopped && (expires == dev->next_event))
                 goto out;
 
         /*
@@ -864,7 +864,7 @@ static bool can_stop_idle_tick(int cpu, struct tick_sched *ts)
         }
 
         if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE)) {
-                ts->sleep_length = (ktime_t) { .tv64 = NSEC_PER_SEC/HZ };
+                ts->sleep_length = NSEC_PER_SEC / HZ;
                 return false;
         }
 
@@ -914,7 +914,7 @@ static void __tick_nohz_idle_enter(struct tick_sched *ts)
                 ts->idle_calls++;
 
                 expires = tick_nohz_stop_sched_tick(ts, now, cpu);
-                if (expires.tv64 > 0LL) {
+                if (expires > 0LL) {
                         ts->idle_sleeps++;
                         ts->idle_expires = expires;
                 }
@@ -1051,7 +1051,7 @@ static void tick_nohz_handler(struct clock_event_device *dev)
         struct pt_regs *regs = get_irq_regs();
         ktime_t now = ktime_get();
 
-        dev->next_event.tv64 = KTIME_MAX;
+        dev->next_event = KTIME_MAX;
 
         tick_sched_do_timer(now);
         tick_sched_handle(ts, regs);
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index f4152a69277f..db087d7e106d 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -104,7 +104,7 @@ static void tk_set_wall_to_mono(struct timekeeper *tk, struct timespec64 wtm)
          */
         set_normalized_timespec64(&tmp, -tk->wall_to_monotonic.tv_sec,
                                         -tk->wall_to_monotonic.tv_nsec);
-        WARN_ON_ONCE(tk->offs_real.tv64 != timespec64_to_ktime(tmp).tv64);
+        WARN_ON_ONCE(tk->offs_real != timespec64_to_ktime(tmp));
         tk->wall_to_monotonic = wtm;
         set_normalized_timespec64(&tmp, -wtm.tv_sec, -wtm.tv_nsec);
         tk->offs_real = timespec64_to_ktime(tmp);
@@ -571,7 +571,7 @@ EXPORT_SYMBOL_GPL(pvclock_gtod_unregister_notifier);
 static inline void tk_update_leap_state(struct timekeeper *tk)
 {
         tk->next_leap_ktime = ntp_get_next_leap();
-        if (tk->next_leap_ktime.tv64 != KTIME_MAX)
+        if (tk->next_leap_ktime != KTIME_MAX)
                 /* Convert to monotonic time */
                 tk->next_leap_ktime = ktime_sub(tk->next_leap_ktime, tk->offs_real);
 }
@@ -2250,7 +2250,7 @@ ktime_t ktime_get_update_offsets_now(unsigned int *cwsseq, ktime_t *offs_real,
                 }
 
                 /* Handle leapsecond insertion adjustments */
-                if (unlikely(base.tv64 >= tk->next_leap_ktime.tv64))
+                if (unlikely(base >= tk->next_leap_ktime))
                         *offs_real = ktime_sub(tk->offs_real, ktime_set(1, 0));
 
         } while (read_seqcount_retry(&tk_core.seq, seq));
diff --git a/lib/timerqueue.c b/lib/timerqueue.c
index 782ae8ca2c06..adc6ee0a5126 100644
--- a/lib/timerqueue.c
+++ b/lib/timerqueue.c
@@ -48,7 +48,7 @@ bool timerqueue_add(struct timerqueue_head *head, struct timerqueue_node *node)
         while (*p) {
                 parent = *p;
                 ptr = rb_entry(parent, struct timerqueue_node, node);
-                if (node->expires.tv64 < ptr->expires.tv64)
+                if (node->expires < ptr->expires)
                         p = &(*p)->rb_left;
                 else
                         p = &(*p)->rb_right;
@@ -56,7 +56,7 @@ bool timerqueue_add(struct timerqueue_head *head, struct timerqueue_node *node)
         rb_link_node(&node->node, parent, p);
         rb_insert_color(&node->node, &head->head);
 
-        if (!head->next || node->expires.tv64 < head->next->expires.tv64) {
+        if (!head->next || node->expires < head->next->expires) {
                 head->next = node;
                 return true;
         }
diff --git a/net/can/bcm.c b/net/can/bcm.c
index 436a7537e6a9..ab8ba1e16473 100644
--- a/net/can/bcm.c
+++ b/net/can/bcm.c
@@ -199,11 +199,11 @@ static int bcm_proc_show(struct seq_file *m, void *v)
 
                 seq_printf(m, "%c ", (op->flags & RX_CHECK_DLC) ? 'd' : ' ');
 
-                if (op->kt_ival1.tv64)
+                if (op->kt_ival1)
                         seq_printf(m, "timeo=%lld ",
                                    (long long)ktime_to_us(op->kt_ival1));
 
-                if (op->kt_ival2.tv64)
+                if (op->kt_ival2)
                         seq_printf(m, "thr=%lld ",
                                    (long long)ktime_to_us(op->kt_ival2));
 
@@ -226,11 +226,11 @@ static int bcm_proc_show(struct seq_file *m, void *v)
                 else
                         seq_printf(m, "[%u] ", op->nframes);
 
-                if (op->kt_ival1.tv64)
+                if (op->kt_ival1)
                         seq_printf(m, "t1=%lld ",
                                    (long long)ktime_to_us(op->kt_ival1));
 
-                if (op->kt_ival2.tv64)
+                if (op->kt_ival2)
                         seq_printf(m, "t2=%lld ",
                                    (long long)ktime_to_us(op->kt_ival2));
 
@@ -365,11 +365,11 @@ static void bcm_send_to_user(struct bcm_op *op, struct bcm_msg_head *head,
 
 static void bcm_tx_start_timer(struct bcm_op *op)
 {
-        if (op->kt_ival1.tv64 && op->count)
+        if (op->kt_ival1 && op->count)
                 hrtimer_start(&op->timer,
                               ktime_add(ktime_get(), op->kt_ival1),
                               HRTIMER_MODE_ABS);
-        else if (op->kt_ival2.tv64)
+        else if (op->kt_ival2)
                 hrtimer_start(&op->timer,
                               ktime_add(ktime_get(), op->kt_ival2),
                               HRTIMER_MODE_ABS);
@@ -380,7 +380,7 @@ static void bcm_tx_timeout_tsklet(unsigned long data)
         struct bcm_op *op = (struct bcm_op *)data;
         struct bcm_msg_head msg_head;
 
-        if (op->kt_ival1.tv64 && (op->count > 0)) {
+        if (op->kt_ival1 && (op->count > 0)) {
 
                 op->count--;
                 if (!op->count && (op->flags & TX_COUNTEVT)) {
@@ -398,7 +398,7 @@ static void bcm_tx_timeout_tsklet(unsigned long data)
                 }
                 bcm_can_tx(op);
 
-        } else if (op->kt_ival2.tv64)
+        } else if (op->kt_ival2)
                 bcm_can_tx(op);
 
         bcm_tx_start_timer(op);
@@ -459,7 +459,7 @@ static void bcm_rx_update_and_send(struct bcm_op *op,
         lastdata->flags |= (RX_RECV|RX_THR);
 
         /* throttling mode inactive ? */
-        if (!op->kt_ival2.tv64) {
+        if (!op->kt_ival2) {
                 /* send RX_CHANGED to the user immediately */
                 bcm_rx_changed(op, lastdata);
                 return;
@@ -470,7 +470,7 @@ static void bcm_rx_update_and_send(struct bcm_op *op,
                 return;
 
         /* first reception with enabled throttling mode */
-        if (!op->kt_lastmsg.tv64)
+        if (!op->kt_lastmsg)
                 goto rx_changed_settime;
 
         /* got a second frame inside a potential throttle period? */
@@ -537,7 +537,7 @@ static void bcm_rx_starttimer(struct bcm_op *op)
         if (op->flags & RX_NO_AUTOTIMER)
                 return;
 
-        if (op->kt_ival1.tv64)
+        if (op->kt_ival1)
                 hrtimer_start(&op->timer, op->kt_ival1, HRTIMER_MODE_REL);
 }
 
@@ -1005,7 +1005,7 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
                 op->kt_ival2 = bcm_timeval_to_ktime(msg_head->ival2);
 
                 /* disable an active timer due to zero values? */
-                if (!op->kt_ival1.tv64 && !op->kt_ival2.tv64)
+                if (!op->kt_ival1 && !op->kt_ival2)
                         hrtimer_cancel(&op->timer);
         }
 
@@ -1189,7 +1189,7 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
                         op->kt_ival2 = bcm_timeval_to_ktime(msg_head->ival2);
 
                         /* disable an active timer due to zero value? */
-                        if (!op->kt_ival1.tv64)
+                        if (!op->kt_ival1)
                                 hrtimer_cancel(&op->timer);
 
                         /*
@@ -1201,7 +1201,7 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
                         bcm_rx_thr_flush(op, 1);
                 }
 
-                if ((op->flags & STARTTIMER) && op->kt_ival1.tv64)
+                if ((op->flags & STARTTIMER) && op->kt_ival1)
                         hrtimer_start(&op->timer, op->kt_ival1,
                                       HRTIMER_MODE_REL);
         }
diff --git a/net/can/gw.c b/net/can/gw.c
index 455168718c2e..a54ab0c82104 100644
--- a/net/can/gw.c
+++ b/net/can/gw.c
@@ -429,7 +429,7 @@ static void can_can_gw_rcv(struct sk_buff *skb, void *data)
 
         /* clear the skb timestamp if not configured the other way */
         if (!(gwj->flags & CGW_FLAGS_CAN_SRC_TSTAMP))
-                nskb->tstamp.tv64 = 0;
+                nskb->tstamp = 0;
 
         /* send to netdevice */
         if (can_send(nskb, gwj->flags & CGW_FLAGS_CAN_ECHO))
diff --git a/net/core/dev.c b/net/core/dev.c
index 037ffd27fcc2..8db5a0b4b520 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1731,14 +1731,14 @@ EXPORT_SYMBOL(net_disable_timestamp);
 
 static inline void net_timestamp_set(struct sk_buff *skb)
 {
-        skb->tstamp.tv64 = 0;
+        skb->tstamp = 0;
         if (static_key_false(&netstamp_needed))
                 __net_timestamp(skb);
 }
 
 #define net_timestamp_check(COND, SKB)                  \
         if (static_key_false(&netstamp_needed)) {               \
-                if ((COND) && !(SKB)->tstamp.tv64)      \
+                if ((COND) && !(SKB)->tstamp)   \
                         __net_timestamp(SKB);           \
         }                                               \
 
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index e77f40616fea..5a03730fbc1a 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -4368,7 +4368,7 @@ EXPORT_SYMBOL(skb_try_coalesce);
  */
 void skb_scrub_packet(struct sk_buff *skb, bool xnet)
 {
-        skb->tstamp.tv64 = 0;
+        skb->tstamp = 0;
         skb->pkt_type = PACKET_HOST;
         skb->skb_iif = 0;
         skb->ignore_df = 0;
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 31a255b555ad..1d5331a1b1dc 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -1038,7 +1038,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
         skb_shinfo(skb)->gso_size = tcp_skb_mss(skb);
 
         /* Our usage of tstamp should remain private */
-        skb->tstamp.tv64 = 0;
+        skb->tstamp = 0;
 
         /* Cleanup our debris for IP stacks */
         memset(skb->cb, 0, max(sizeof(struct inet_skb_parm),
@@ -3203,7 +3203,7 @@ struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst,
 #endif
 
         /* Do not fool tcpdump (if any), clean our debris */
-        skb->tstamp.tv64 = 0;
+        skb->tstamp = 0;
         return skb;
 }
 EXPORT_SYMBOL(tcp_make_synack);
diff --git a/net/ipv6/exthdrs.c b/net/ipv6/exthdrs.c
index 926818c331e5..e4198502fd98 100644
--- a/net/ipv6/exthdrs.c
+++ b/net/ipv6/exthdrs.c
@@ -232,7 +232,7 @@ static bool ipv6_dest_hao(struct sk_buff *skb, int optoff)
         ipv6h->saddr = hao->addr;
         hao->addr = tmp_addr;
 
-        if (skb->tstamp.tv64 == 0)
+        if (skb->tstamp == 0)
                 __net_timestamp(skb);
 
         return true;
diff --git a/net/ipx/af_ipx.c b/net/ipx/af_ipx.c
index e07f22b0c58a..8a9219ff2e77 100644
--- a/net/ipx/af_ipx.c
+++ b/net/ipx/af_ipx.c
@@ -1809,7 +1809,7 @@ static int ipx_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
         rc = skb_copy_datagram_msg(skb, sizeof(struct ipxhdr), msg, copied);
         if (rc)
                 goto out_free;
-        if (skb->tstamp.tv64)
+        if (skb->tstamp)
                 sk->sk_stamp = skb->tstamp;
 
         if (sipx) {
diff --git a/net/netfilter/nf_conntrack_core.c b/net/netfilter/nf_conntrack_core.c
index 6a0bbfa8e702..3a073cd9fcf4 100644
--- a/net/netfilter/nf_conntrack_core.c
+++ b/net/netfilter/nf_conntrack_core.c
@@ -783,7 +783,7 @@ __nf_conntrack_confirm(struct sk_buff *skb)
         /* set conntrack timestamp, if enabled. */
         tstamp = nf_conn_tstamp_find(ct);
         if (tstamp) {
-                if (skb->tstamp.tv64 == 0)
+                if (skb->tstamp == 0)
                         __net_timestamp(skb);
 
                 tstamp->start = ktime_to_ns(skb->tstamp);
diff --git a/net/netfilter/nfnetlink_log.c b/net/netfilter/nfnetlink_log.c
index 200922bb2036..08247bf7d7b8 100644
--- a/net/netfilter/nfnetlink_log.c
+++ b/net/netfilter/nfnetlink_log.c
@@ -538,7 +538,7 @@ __build_packet_message(struct nfnl_log_net *log,
                         goto nla_put_failure;
         }
 
-        if (skb->tstamp.tv64) {
+        if (skb->tstamp) {
                 struct nfulnl_msg_packet_timestamp ts;
                 struct timespec64 kts = ktime_to_timespec64(skb->tstamp);
                 ts.sec = cpu_to_be64(kts.tv_sec);
diff --git a/net/netfilter/nfnetlink_queue.c b/net/netfilter/nfnetlink_queue.c
index be7627b80400..3ee0b8a000a4 100644
--- a/net/netfilter/nfnetlink_queue.c
+++ b/net/netfilter/nfnetlink_queue.c
@@ -384,7 +384,7 @@ nfqnl_build_packet_message(struct net *net, struct nfqnl_instance *queue,
                 + nla_total_size(sizeof(u_int32_t))     /* skbinfo */
                 + nla_total_size(sizeof(u_int32_t));    /* cap_len */
 
-        if (entskb->tstamp.tv64)
+        if (entskb->tstamp)
                 size += nla_total_size(sizeof(struct nfqnl_msg_packet_timestamp));
 
         size += nfqnl_get_bridge_size(entry);
@@ -555,7 +555,7 @@ nfqnl_build_packet_message(struct net *net, struct nfqnl_instance *queue,
         if (nfqnl_put_bridge(entry, skb) < 0)
                 goto nla_put_failure;
 
-        if (entskb->tstamp.tv64) {
+        if (entskb->tstamp) {
                 struct nfqnl_msg_packet_timestamp ts;
                 struct timespec64 kts = ktime_to_timespec64(entskb->tstamp);
 
diff --git a/net/netfilter/xt_time.c b/net/netfilter/xt_time.c
index 0ae55a36f492..1b01eec1fbda 100644
--- a/net/netfilter/xt_time.c
+++ b/net/netfilter/xt_time.c
@@ -168,7 +168,7 @@ time_mt(const struct sk_buff *skb, struct xt_action_param *par)
          * may happen that the same packet matches both rules if
          * it arrived at the right moment before 13:00.
          */
-        if (skb->tstamp.tv64 == 0)
+        if (skb->tstamp == 0)
                 __net_timestamp((struct sk_buff *)skb);
 
         stamp = ktime_to_ns(skb->tstamp);
diff --git a/net/sched/sch_netem.c b/net/sched/sch_netem.c
index b7e4097bfdab..bcfadfdea8e0 100644
--- a/net/sched/sch_netem.c
+++ b/net/sched/sch_netem.c
@@ -627,7 +627,7 @@ deliver:
                          * from the network (tstamp will be updated).
                          */
                         if (G_TC_FROM(skb->tc_verd) & AT_INGRESS)
-                                skb->tstamp.tv64 = 0;
+                                skb->tstamp = 0;
 #endif
 
                         if (q->qdisc) {
diff --git a/net/socket.c b/net/socket.c
index 5ff26c44db33..8487bf136e5c 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -668,7 +668,7 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
 
         /* Race occurred between timestamp enabling and packet
            receiving.  Fill in the current time for now. */
-        if (need_software_tstamp && skb->tstamp.tv64 == 0)
+        if (need_software_tstamp && skb->tstamp == 0)
                 __net_timestamp(skb);
 
         if (need_software_tstamp) {
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index a3e85ee28b5a..de066acdb34e 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -574,7 +574,7 @@ static int svc_udp_recvfrom(struct svc_rqst *rqstp)
         }
         len = svc_addr_len(svc_addr(rqstp));
         rqstp->rq_addrlen = len;
-        if (skb->tstamp.tv64 == 0) {
+        if (skb->tstamp == 0) {
                 skb->tstamp = ktime_get_real();
                 /* Don't enable netstamp, sunrpc doesn't
                    need that much accuracy */
diff --git a/sound/core/hrtimer.c b/sound/core/hrtimer.c
index e2f27022b363..1ac0c423903e 100644
--- a/sound/core/hrtimer.c
+++ b/sound/core/hrtimer.c
@@ -58,7 +58,7 @@ static enum hrtimer_restart snd_hrtimer_callback(struct hrtimer *hrt)
 
         /* calculate the drift */
         delta = ktime_sub(hrt->base->get_time(), hrtimer_get_expires(hrt));
-        if (delta.tv64 > 0)
+        if (delta > 0)
                 ticks += ktime_divns(delta, ticks * resolution);
 
         snd_timer_interrupt(stime->timer, ticks);