drm: vblank: use ktime_t instead of timeval

The drm vblank handling uses 'timeval' to store timestamps in either
monotonic or wall-clock time base. In either case, it reads the current
time as a ktime_t in get_drm_timestamp() and converts it from there.

This is a bit suspicious, as users of 'timeval' often suffer from
the time_t overflow in y2038. I have gone through this code and
found that it is unlikely to cause problems here:

- The user space ABI does not use time_t or timeval, but uses
  'u32' and 'long' as the types. This means at least that rebuilding
  user programs against a new libc with 64-bit time_t does not
  change the ABI.

- As of commit c61eef726a78 ("drm: add support for monotonic vblank
  timestamps") in linux-3.8, the monotonic timestamp is the default
  and can only get reverted to wall-clock through a module-parameter.

- With the default monotonic timestamps, there is no problem at all.

- The drm_wait_vblank_ioctl() interface is alway safe on 64-bit
  architectures, on 32-bit it might overflow the 'long' timestamps
  in 2038 with wall-clock timestamps.

- The event handling uses 'u32' seconds, which overflow in 2106
  on both 32-bit and 64-bit machines, when wall-clock timestamps
  are used.

- The effect of overflowing either of the two is only temporary
  (during the overflow, and is likely to keep working again
  afterwards. It is likely the same problem as observing a
  'settimeofday()' call, which was the reason for moving to the
  monotonic timestamps in the first place.

Overall, this seems good enough, so my patch removes the use of
'timeval' from the vblank handling altogether and uses ktime_t
consistently, except for the part where we copy the data to user
space structures in the existing format.

Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Reviewed-by: Keith Packard <keithp@keithp.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>

3 files changed, 71 insertions, 60 deletions

diff --git a/drivers/gpu/drm/drm_vblank.c b/drivers/gpu/drm/drm_vblank.c
index 70f2b9593edc..c605c3ad6b6e 100644
--- a/drivers/gpu/drm/drm_vblank.c
+++ b/drivers/gpu/drm/drm_vblank.c
@@ -78,7 +78,7 @@
 
 static bool
 drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe,
-                          struct timeval *tvblank, bool in_vblank_irq);
+                          ktime_t *tvblank, bool in_vblank_irq);
 
 static unsigned int drm_timestamp_precision = 20;  /* Default to 20 usecs. */
 
@@ -99,7 +99,7 @@ MODULE_PARM_DESC(timestamp_monotonic, "Use monotonic timestamps");
 
 static void store_vblank(struct drm_device *dev, unsigned int pipe,
                          u32 vblank_count_inc,
-                         struct timeval *t_vblank, u32 last)
+                         ktime_t t_vblank, u32 last)
 {
         struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
 
@@ -108,7 +108,7 @@ static void store_vblank(struct drm_device *dev, unsigned int pipe,
         vblank->last = last;
 
         write_seqlock(&vblank->seqlock);
-        vblank->time = *t_vblank;
+        vblank->time = t_vblank;
         vblank->count += vblank_count_inc;
         write_sequnlock(&vblank->seqlock);
 }
@@ -151,7 +151,7 @@ static void drm_reset_vblank_timestamp(struct drm_device *dev, unsigned int pipe
 {
         u32 cur_vblank;
         bool rc;
-        struct timeval t_vblank;
+        ktime_t t_vblank;
         int count = DRM_TIMESTAMP_MAXRETRIES;
 
         spin_lock(&dev->vblank_time_lock);
@@ -171,13 +171,13 @@ static void drm_reset_vblank_timestamp(struct drm_device *dev, unsigned int pipe
          * interrupt and assign 0 for now, to mark the vblanktimestamp as invalid.
          */
         if (!rc)
-                t_vblank = (struct timeval) {0, 0};
+                t_vblank = 0;
 
         /*
          * +1 to make sure user will never see the same
          * vblank counter value before and after a modeset
          */
-        store_vblank(dev, pipe, 1, &t_vblank, cur_vblank);
+        store_vblank(dev, pipe, 1, t_vblank, cur_vblank);
 
         spin_unlock(&dev->vblank_time_lock);
 }
@@ -200,7 +200,7 @@ static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe,
         struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
         u32 cur_vblank, diff;
         bool rc;
-        struct timeval t_vblank;
+        ktime_t t_vblank;
         int count = DRM_TIMESTAMP_MAXRETRIES;
         int framedur_ns = vblank->framedur_ns;
 
@@ -225,11 +225,7 @@ static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe,
                 /* trust the hw counter when it's around */
                 diff = (cur_vblank - vblank->last) & dev->max_vblank_count;
         } else if (rc && framedur_ns) {
-                const struct timeval *t_old;
-                u64 diff_ns;
-
-                t_old = &vblank->time;
-                diff_ns = timeval_to_ns(&t_vblank) - timeval_to_ns(t_old);
+                u64 diff_ns = ktime_to_ns(ktime_sub(t_vblank, vblank->time));
 
                 /*
                  * Figure out how many vblanks we've missed based
@@ -278,9 +274,9 @@ static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe,
          * for now, to mark the vblanktimestamp as invalid.
          */
         if (!rc && !in_vblank_irq)
-                t_vblank = (struct timeval) {0, 0};
+                t_vblank = 0;
 
-        store_vblank(dev, pipe, diff, &t_vblank, cur_vblank);
+        store_vblank(dev, pipe, diff, t_vblank, cur_vblank);
 }
 
 static u32 drm_vblank_count(struct drm_device *dev, unsigned int pipe)
@@ -556,7 +552,7 @@ EXPORT_SYMBOL(drm_calc_timestamping_constants);
  * @pipe: index of CRTC whose vblank timestamp to retrieve
  * @max_error: Desired maximum allowable error in timestamps (nanosecs)
  *             On return contains true maximum error of timestamp
- * @vblank_time: Pointer to struct timeval which should receive the timestamp
+ * @vblank_time: Pointer to time which should receive the timestamp
  * @in_vblank_irq:
  *     True when called from drm_crtc_handle_vblank().  Some drivers
  *     need to apply some workarounds for gpu-specific vblank irq quirks
@@ -584,10 +580,10 @@ EXPORT_SYMBOL(drm_calc_timestamping_constants);
 bool drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
                                            unsigned int pipe,
                                            int *max_error,
-                                           struct timeval *vblank_time,
+                                           ktime_t *vblank_time,
                                            bool in_vblank_irq)
 {
-        struct timeval tv_etime;
+        struct timespec64 ts_etime, ts_vblank_time;
         ktime_t stime, etime;
         bool vbl_status;
         struct drm_crtc *crtc;
@@ -680,29 +676,27 @@ bool drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
                 etime = ktime_mono_to_real(etime);
 
         /* save this only for debugging purposes */
-        tv_etime = ktime_to_timeval(etime);
+        ts_etime = ktime_to_timespec64(etime);
+        ts_vblank_time = ktime_to_timespec64(*vblank_time);
         /* Subtract time delta from raw timestamp to get final
          * vblank_time timestamp for end of vblank.
          */
         etime = ktime_sub_ns(etime, delta_ns);
-        *vblank_time = ktime_to_timeval(etime);
+        *vblank_time = etime;
 
-        DRM_DEBUG_VBL("crtc %u : v p(%d,%d)@ %ld.%ld -> %ld.%ld [e %d us, %d rep]\n",
+        DRM_DEBUG_VBL("crtc %u : v p(%d,%d)@ %lld.%06ld -> %lld.%06ld [e %d us, %d rep]\n",
                       pipe, hpos, vpos,
-                      (long)tv_etime.tv_sec, (long)tv_etime.tv_usec,
-                      (long)vblank_time->tv_sec, (long)vblank_time->tv_usec,
-                      duration_ns/1000, i);
+                      (u64)ts_etime.tv_sec, ts_etime.tv_nsec / 1000,
+                      (u64)ts_vblank_time.tv_sec, ts_vblank_time.tv_nsec / 1000,
+                      duration_ns / 1000, i);
 
         return true;
 }
 EXPORT_SYMBOL(drm_calc_vbltimestamp_from_scanoutpos);
 
-static struct timeval get_drm_timestamp(void)
+static ktime_t get_drm_timestamp(void)
 {
-        ktime_t now;
-
-        now = drm_timestamp_monotonic ? ktime_get() : ktime_get_real();
-        return ktime_to_timeval(now);
+        return drm_timestamp_monotonic ? ktime_get() : ktime_get_real();
 }
 
 /**
@@ -710,7 +704,7 @@ static struct timeval get_drm_timestamp(void)
  *                             vblank interval
  * @dev: DRM device
  * @pipe: index of CRTC whose vblank timestamp to retrieve