include/linux/rcuwait.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _LINUX_RCUWAIT_H_
   3 #define _LINUX_RCUWAIT_H_
   4
   5 #include <linux/rcupdate.h>
   6 #include <linux/sched/signal.h>
   7
   8 /*
   9  * rcuwait provides a way of blocking and waking up a single
  10  * task in an rcu-safe manner.
  11  *
  12  * The only time @task is non-nil is when a user is blocked (or
  13  * checking if it needs to) on a condition, and reset as soon as we
  14  * know that the condition has succeeded and are awoken.
  15  */
  16 struct rcuwait {
  17         struct task_struct __rcu *task;
  18 };
  19
  20 #define __RCUWAIT_INITIALIZER(name)             \
  21         { .task = NULL, }
  22
  23 static inline void rcuwait_init(struct rcuwait *w)
  24 {
  25         w->task = NULL;
  26 }
  27
  28 /*
  29  * Note: this provides no serialization and, just as with waitqueues,
  30  * requires care to estimate as to whether or not the wait is active.
  31  */
  32 static inline int rcuwait_active(struct rcuwait *w)
  33 {
  34         return !!rcu_access_pointer(w->task);
  35 }
  36
  37 extern int rcuwait_wake_up(struct rcuwait *w);
  38
  39 /*
  40  * The caller is responsible for locking around rcuwait_wait_event(),
  41  * and [prepare_to/finish]_rcuwait() such that writes to @task are
  42  * properly serialized.
  43  */
  44
  45 static inline void prepare_to_rcuwait(struct rcuwait *w)
  46 {
  47         rcu_assign_pointer(w->task, current);
  48 }
  49
  50 static inline void finish_rcuwait(struct rcuwait *w)
  51 {
  52         rcu_assign_pointer(w->task, NULL);
  53         __set_current_state(TASK_RUNNING);
  54 }
  55
  56 #define rcuwait_wait_event(w, condition, state)                         \
  57 ({                                                                      \
  58         int __ret = 0;                                                  \
  59         prepare_to_rcuwait(w);                                          \
  60         for (;;) {                                                      \
  61                 /*                                                      \
  62                  * Implicit barrier (A) pairs with (B) in               \
  63                  * rcuwait_wake_up().                                   \
  64                  */                                                     \
  65                 set_current_state(state);                               \
  66                 if (condition)                                          \
  67                         break;                                          \
  68                                                                         \
  69                 if (signal_pending_state(state, current)) {             \
  70                         __ret = -EINTR;                                 \
  71                         break;                                          \
  72                 }                                                       \
  73                                                                         \
  74                 schedule();                                             \
  75         }                                                               \
  76         finish_rcuwait(w);                                              \
  77         __ret;                                                          \
  78 })
  79
  80 #endif /* _LINUX_RCUWAIT_H_ */