@@ -273,6 +273,54 @@ do { \
})
#endif
+#ifndef smp_cond_time_check_count
+/*
+ * Limit how often smp_cond_load_relaxed_timewait() evaluates time_expr_ns.
+ * This helps reduce the number of instructions executed while spin-waiting.
+ */
+#define smp_cond_time_check_count 200
+#endif
+
+/**
+ * smp_cond_load_relaxed_timewait() - (Spin) wait for cond with no ordering
+ * guarantees until a timeout expires.
+ * @ptr: pointer to the variable to wait on
+ * @cond: boolean expression to wait for
+ * @time_expr_ns: evaluates to the current time
+ * @time_limit_ns: compared against time_expr_ns
+ *
+ * Equivalent to using READ_ONCE() on the condition variable.
+ *
+ * Note that the time check in time_expr_ns can be synchronous or
+ * asynchronous.
+ * In the generic version the check is synchronous but kept coarse
+ * to minimize instructions executed while spin-waiting.
+ */
+#ifndef __smp_cond_load_relaxed_spinwait
+#define __smp_cond_load_relaxed_spinwait(ptr, cond_expr, time_expr_ns, \
+ time_limit_ns) ({ \
+ typeof(ptr) __PTR = (ptr); \
+ __unqual_scalar_typeof(*ptr) VAL; \
+ unsigned int __count = 0; \
+ for (;;) { \
+ VAL = READ_ONCE(*__PTR); \
+ if (cond_expr) \
+ break; \
+ cpu_relax(); \
+ if (__count++ < smp_cond_time_check_count) \
+ continue; \
+ if ((time_expr_ns) >= (time_limit_ns)) \
+ break; \
+ __count = 0; \
+ } \
+ (typeof(*ptr))VAL; \
+})
+#endif
+
+#ifndef smp_cond_load_relaxed_timewait
+#define smp_cond_load_relaxed_timewait __smp_cond_load_relaxed_spinwait
+#endif
+
/*
* pmem_wmb() ensures that all stores for which the modification
* are written to persistent storage by preceding instructions have
Add smp_cond_load_relaxed_timewait(), a timed variant of smp_cond_load_relaxed(). This is useful for cases where we want to wait on a conditional variable but don't want to wait indefinitely. The timeout is supported by extending the smp_cond_load_relaxed() interface to specify a time-check expression and an associated time-limit. The generic version is implemented as the usual cpu_relax() spin-wait loop with a periodic evaluation of the time-check expression. To minimize the numbers of instructions executed in each iteration of the loop, limit the frequency of the time-check to once every smp_cond_time_check_count. (The inner loop in poll_idle() has a substantially similar structure and constraints as smp_cond_load_relaxed_timewait(), so we reuse the same value for smp_cond_time_check_count.) Architecture specific versions can implement this by waiting on a cacheline to change and an out-of-band mechanism to allow for the time check. Cc: Arnd Bergmann <arnd@arndb.de> Cc: Will Deacon <will@kernel.org> Cc: Catalin Marinas <catalin.marinas@arm.com> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Kumar Kartikeya Dwivedi <memxor@gmail.com> Cc: linux-arch@vger.kernel.org Signed-off-by: Ankur Arora <ankur.a.arora@oracle.com> --- include/asm-generic/barrier.h | 48 +++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+)