Hi
Am 15.09.26 um 21:42 schrieb Maíra Canal:
drm_timeout_abs_to_jiffies() covers the drivers whose wait UAPI takes an
absolute deadline, but there is no equivalent for the drivers that
express a wait as a duration. Drivers such as i915 and v3d convert the
value themselves.
Converting a nanosecond duration to jiffies needs some care.
nsecs_to_jiffies() returns unsigned long, so on 32-bit a large
userspace-supplied timeout overflows its range and is silently truncated.
i915 already handles both cases in a local helper, which v3d has a copy
of. Add the same conversion to the core, so that it is available to any
driver and both copies can be dropped.
Signed-off-by: Maíra Canal <[email protected]>
---
drivers/gpu/drm/drm_timeout.c | 45 +++++++++++++++++++++++++++++++++++++++++++
include/drm/drm_timeout.h | 1 +
2 files changed, 46 insertions(+)
diff --git a/drivers/gpu/drm/drm_timeout.c b/drivers/gpu/drm/drm_timeout.c
index 35e10293e0a1..ee545475429c 100644
--- a/drivers/gpu/drm/drm_timeout.c
+++ b/drivers/gpu/drm/drm_timeout.c
@@ -9,6 +9,7 @@
#include <linux/export.h>
#include <linux/jiffies.h>
#include <linux/ktime.h>
+#include <linux/math64.h>
#include <linux/sched.h>
#include <drm/drm_timeout.h>
@@ -48,3 +49,47 @@ signed long drm_timeout_abs_to_jiffies(int64_t timeout_nsec)
return timeout_jiffies64 + 1;
}
EXPORT_SYMBOL(drm_timeout_abs_to_jiffies);
+
+/**
+ * drm_timeout_rel_to_jiffies - calculate jiffies timeout from relative value
+ * @timeout_nsec: relative timeout in ns, 0 for poll
+ *
+ * Calculate the timeout in jiffies from a relative timeout in ns, for drivers
+ * whose UAPI expresses a wait as a duration rather than as a deadline.
+ *
+ * The result is clamped to MAX_JIFFY_OFFSET. That keeps it positive once it is
+ * converted to the signed long taken by dma_fence_wait_timeout() and friends,
+ * which matters on 32-bit, and keeps it distinct from MAX_SCHEDULE_TIMEOUT so
+ * that a finite wait is never understood as an infinite one.
+ *
+ * It's strongly discouraged to use relative timeouts in uAPIs, as they do not
+ * survive a restarted ioctl. A signal-interrupted ioctl is re-entered with the
+ * same arguments, so the duration starts counting from zero again. New uAPIs
+ * should take an absolute deadline and use drm_timeout_abs_to_jiffies().
+ *
+ * Returns:
+ * 0 if @timeout_nsec is 0. Otherwise the equivalent number of jiffies and
+ * clamped to MAX_JIFFY_OFFSET.
+ */
+unsigned long drm_timeout_rel_to_jiffies(u64 timeout_nsec)
+{
+ u64 secs;
+ u32 rem;
+
+ /* Make 0 timeout means poll, as for the absolute variant. */
+ if (timeout_nsec == 0)
+ return 0;
+
+ /*
+ * As nsecs_to_jiffies64() does not guard against overflow, split
+ * the timeout into whole seconds and nanoseconds. This way
+ * nsecs_to_jiffies64() is always handed a value below a second.
+ */
+ secs = div_u64_rem(timeout_nsec, NSEC_PER_SEC, &rem);
+ if (secs >= MAX_JIFFY_OFFSET / HZ)
+ return MAX_JIFFY_OFFSET;
+
+ return min_t(u64, MAX_JIFFY_OFFSET,
+ secs_to_jiffies(secs) + nsecs_to_jiffies64(rem) + 1);
The timeout is controled by user space, right? Can these additions
overflow? I see that secs is tested against MAX_JIFFY_OFFSET, but is
that sufficient?
BTW there was this NSEC % HZ test in the original code? What was it good
for? It is no longer useful?
Best regards
Thomas
+}
+EXPORT_SYMBOL(drm_timeout_rel_to_jiffies);
diff --git a/include/drm/drm_timeout.h b/include/drm/drm_timeout.h
index cd9621c52062..6ee222a3e97c 100644
--- a/include/drm/drm_timeout.h
+++ b/include/drm/drm_timeout.h
@@ -12,5 +12,6 @@
#include <linux/types.h>
signed long drm_timeout_abs_to_jiffies(s64 timeout_nsec);
+unsigned long drm_timeout_rel_to_jiffies(u64 timeout_nsec);
#endif
--
--
Thomas Zimmermann
Graphics Driver Developer
SUSE Software Solutions Germany GmbH
Frankenstr. 146, 90461 Nürnberg, Germany, www.suse.com
GF: Stefan Gaiser, Jochen Jaser, Abhinav Puri, (HRB 36809, AG Nürnberg)
