once: make helper generic for calling functions once

[linux-drm-fsl-dcu.git] / include / linux / once.h

diff --git a/include/linux/once.h b/include/linux/once.h
index 2a83b538dd6ac23b87bc93e57fbfef4ff7aafab1..285f12cb40e6a3d6d21db8fbaca418c133a93d97 100644 (file)
--- a/include/linux/once.h
+++ b/include/linux/once.h
@@ -4,21 +4,54 @@
 #include <linux/types.h>
 #include <linux/jump_label.h>
 
-bool __get_random_once(void *buf, int nbytes, bool *done,
-                      struct static_key *once_key);
+bool __do_once_start(bool *done, unsigned long *flags);
+void __do_once_done(bool *done, struct static_key *once_key,
+                   unsigned long *flags);
 
-#define get_random_once(buf, nbytes)                                   \
-       ({                                                              \
-               bool ___ret = false;                                    \
-               static bool ___done = false;                            \
-               static struct static_key ___once_key =                  \
-                       STATIC_KEY_INIT_TRUE;                           \
-               if (static_key_true(&___once_key))                      \
-                       ___ret = __get_random_once((buf),               \
-                                                  (nbytes),            \
-                                                  &___done,            \
-                                                  &___once_key);       \
-               ___ret;                                                 \
+/* Call a function exactly once. The idea of DO_ONCE() is to perform
+ * a function call such as initialization of random seeds, etc, only
+ * once, where DO_ONCE() can live in the fast-path. After @func has
+ * been called with the passed arguments, the static key will patch
+ * out the condition into a nop. DO_ONCE() guarantees type safety of
+ * arguments!
+ *
+ * Not that the following is not equivalent ...
+ *
+ *   DO_ONCE(func, arg);
+ *   DO_ONCE(func, arg);
+ *
+ * ... to this version:
+ *
+ *   void foo(void)
+ *   {
+ *     DO_ONCE(func, arg);
+ *   }
+ *
+ *   foo();
+ *   foo();
+ *
+ * In case the one-time invocation could be triggered from multiple
+ * places, then a common helper function must be defined, so that only
+ * a single static key will be placed there!
+ */
+#define DO_ONCE(func, ...)                                                  \
+       ({                                                                   \
+               bool ___ret = false;                                         \
+               static bool ___done = false;                                 \
+               static struct static_key ___once_key = STATIC_KEY_INIT_TRUE; \
+               if (static_key_true(&___once_key)) {                         \
+                       unsigned long ___flags;                              \
+                       ___ret = __do_once_start(&___done, &___flags);       \
+                       if (unlikely(___ret)) {                              \
+                               func(__VA_ARGS__);                           \
+                               __do_once_done(&___done, &___once_key,       \
+                                              &___flags);                   \
+                       }                                                    \
+               }                                                            \
+               ___ret;                                                      \
        })
 
+#define get_random_once(buf, nbytes)                                        \
+       DO_ONCE(get_random_bytes, (buf), (nbytes))
+
 #endif /* _LINUX_ONCE_H */