include/linux/freezer.h

   1 /* Freezer declarations */
   2
   3 #ifndef FREEZER_H_INCLUDED
   4 #define FREEZER_H_INCLUDED
   5
   6 #include <linux/debug_locks.h>
   7 #include <linux/sched.h>
   8 #include <linux/wait.h>
   9 #include <linux/atomic.h>
  10
  11 #ifdef CONFIG_FREEZER
  12 extern atomic_t system_freezing_cnt;    /* nr of freezing conds in effect */
  13 extern bool pm_freezing;                /* PM freezing in effect */
  14 extern bool pm_nosig_freezing;          /* PM nosig freezing in effect */
  15
  16 /*
  17  * Timeout for stopping processes
  18  */
  19 extern unsigned int freeze_timeout_msecs;
  20
  21 /*
  22  * Check if a process has been frozen
  23  */
  24 static inline bool frozen(struct task_struct *p)
  25 {
  26         return p->flags & PF_FROZEN;
  27 }
  28
  29 extern bool freezing_slow_path(struct task_struct *p);
  30
  31 /*
  32  * Check if there is a request to freeze a process
  33  */
  34 static inline bool freezing(struct task_struct *p)
  35 {
  36         if (likely(!atomic_read(&system_freezing_cnt)))
  37                 return false;
  38         return freezing_slow_path(p);
  39 }
  40
  41 /* Takes and releases task alloc lock using task_lock() */
  42 extern void __thaw_task(struct task_struct *t);
  43
  44 extern bool __refrigerator(bool check_kthr_stop);
  45 extern int freeze_processes(void);
  46 extern int freeze_kernel_threads(void);
  47 extern void thaw_processes(void);
  48 extern void thaw_kernel_threads(void);
  49
  50 static inline bool try_to_freeze(void)
  51 {
  52         if (!(current->flags & PF_NOFREEZE))
  53                 debug_check_no_locks_held();
  54         might_sleep();
  55         if (likely(!freezing(current)))
  56                 return false;
  57         return __refrigerator(false);
  58 }
  59
  60 extern bool freeze_task(struct task_struct *p);
  61 extern bool set_freezable(void);
  62
  63 #ifdef CONFIG_CGROUP_FREEZER
  64 extern bool cgroup_freezing(struct task_struct *task);
  65 #else /* !CONFIG_CGROUP_FREEZER */
  66 static inline bool cgroup_freezing(struct task_struct *task)
  67 {
  68         return false;
  69 }
  70 #endif /* !CONFIG_CGROUP_FREEZER */
  71
  72 /*
  73  * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
  74  * calls wait_for_completion(&vfork) and reset right after it returns from this
  75  * function.  Next, the parent should call try_to_freeze() to freeze itself
  76  * appropriately in case the child has exited before the freezing of tasks is
  77  * complete.  However, we don't want kernel threads to be frozen in unexpected
  78  * places, so we allow them to block freeze_processes() instead or to set
  79  * PF_NOFREEZE if needed. Fortunately, in the ____call_usermodehelper() case the
  80  * parent won't really block freeze_processes(), since ____call_usermodehelper()
  81  * (the child) does a little before exec/exit and it can't be frozen before
  82  * waking up the parent.
  83  */
  84
  85
  86 /**
  87  * freezer_do_not_count - tell freezer to ignore %current
  88  *
  89  * Tell freezers to ignore the current task when determining whether the
  90  * target frozen state is reached.  IOW, the current task will be
  91  * considered frozen enough by freezers.
  92  *
  93  * The caller shouldn't do anything which isn't allowed for a frozen task
  94  * until freezer_cont() is called.  Usually, freezer[_do_not]_count() pair
  95  * wrap a scheduling operation and nothing much else.
  96  */
  97 static inline void freezer_do_not_count(void)
  98 {
  99         current->flags |= PF_FREEZER_SKIP;
 100 }
 101
 102 /**
 103  * freezer_count - tell freezer to stop ignoring %current
 104  *
 105  * Undo freezer_do_not_count().  It tells freezers that %current should be
 106  * considered again and tries to freeze if freezing condition is already in
 107  * effect.
 108  */
 109 static inline void freezer_count(void)
 110 {
 111         current->flags &= ~PF_FREEZER_SKIP;
 112         /*
 113          * If freezing is in progress, the following paired with smp_mb()
 114          * in freezer_should_skip() ensures that either we see %true
 115          * freezing() or freezer_should_skip() sees !PF_FREEZER_SKIP.
 116          */
 117         smp_mb();
 118         try_to_freeze();
 119 }
 120
 121 /**
 122  * freezer_should_skip - whether to skip a task when determining frozen
 123  *                       state is reached
 124  * @p: task in quesion
 125  *
 126  * This function is used by freezers after establishing %true freezing() to
 127  * test whether a task should be skipped when determining the target frozen
 128  * state is reached.  IOW, if this function returns %true, @p is considered
 129  * frozen enough.
 130  */
 131 static inline bool freezer_should_skip(struct task_struct *p)
 132 {
 133         /*
 134          * The following smp_mb() paired with the one in freezer_count()
 135          * ensures that either freezer_count() sees %true freezing() or we
 136          * see cleared %PF_FREEZER_SKIP and return %false.  This makes it
 137          * impossible for a task to slip frozen state testing after
 138          * clearing %PF_FREEZER_SKIP.
 139          */
 140         smp_mb();
 141         return p->flags & PF_FREEZER_SKIP;
 142 }
 143
 144 /*
 145  * These macros are intended to be used whenever you want allow a sleeping
 146  * task to be frozen. Note that neither return any clear indication of
 147  * whether a freeze event happened while in this function.
 148  */
 149
 150 /* Like schedule(), but should not block the freezer. */
 151 #define freezable_schedule()                                            \
 152 ({                                                                      \
 153         freezer_do_not_count();                                         \
 154         schedule();                                                     \
 155         freezer_count();                                                \
 156 })
 157
 158 /* Like schedule_timeout_killable(), but should not block the freezer. */
 159 #define freezable_schedule_timeout_killable(timeout)                    \
 160 ({                                                                      \
 161         long __retval;                                                  \
 162         freezer_do_not_count();                                         \
 163         __retval = schedule_timeout_killable(timeout);                  \
 164         freezer_count();                                                \
 165         __retval;                                                       \
 166 })
 167
 168 /*
 169  * Freezer-friendly wrappers around wait_event_interruptible(),
 170  * wait_event_killable() and wait_event_interruptible_timeout(), originally
 171  * defined in <linux/wait.h>
 172  */
 173
 174 #define wait_event_freezekillable(wq, condition)                        \
 175 ({                                                                      \
 176         int __retval;                                                   \
 177         freezer_do_not_count();                                         \
 178         __retval = wait_event_killable(wq, (condition));                \
 179         freezer_count();                                                \
 180         __retval;                                                       \
 181 })
 182
 183 #define wait_event_freezable(wq, condition)                             \
 184 ({                                                                      \
 185         int __retval;                                                   \
 186         for (;;) {                                                      \
 187                 __retval = wait_event_interruptible(wq,                 \
 188                                 (condition) || freezing(current));      \
 189                 if (__retval || (condition))                            \
 190                         break;                                          \
 191                 try_to_freeze();                                        \
 192         }                                                               \
 193         __retval;                                                       \
 194 })
 195
 196 #define wait_event_freezable_timeout(wq, condition, timeout)            \
 197 ({                                                                      \
 198         long __retval = timeout;                                        \
 199         for (;;) {                                                      \
 200                 __retval = wait_event_interruptible_timeout(wq,         \
 201                                 (condition) || freezing(current),       \
 202                                 __retval);                              \
 203                 if (__retval <= 0 || (condition))                       \
 204                         break;                                          \
 205                 try_to_freeze();                                        \
 206         }                                                               \
 207         __retval;                                                       \
 208 })
 209
 210 #else /* !CONFIG_FREEZER */
 211 static inline bool frozen(struct task_struct *p) { return false; }
 212 static inline bool freezing(struct task_struct *p) { return false; }
 213 static inline void __thaw_task(struct task_struct *t) {}
 214
 215 static inline bool __refrigerator(bool check_kthr_stop) { return false; }
 216 static inline int freeze_processes(void) { return -ENOSYS; }
 217 static inline int freeze_kernel_threads(void) { return -ENOSYS; }
 218 static inline void thaw_processes(void) {}
 219 static inline void thaw_kernel_threads(void) {}
 220
 221 static inline bool try_to_freeze_nowarn(void) { return false; }
 222 static inline bool try_to_freeze(void) { return false; }
 223
 224 static inline void freezer_do_not_count(void) {}
 225 static inline void freezer_count(void) {}
 226 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
 227 static inline void set_freezable(void) {}
 228
 229 #define freezable_schedule()  schedule()
 230
 231 #define freezable_schedule_timeout_killable(timeout)                    \
 232         schedule_timeout_killable(timeout)
 233
 234 #define wait_event_freezable(wq, condition)                             \
 235                 wait_event_interruptible(wq, condition)
 236
 237 #define wait_event_freezable_timeout(wq, condition, timeout)            \
 238                 wait_event_interruptible_timeout(wq, condition, timeout)
 239
 240 #define wait_event_freezekillable(wq, condition)                \
 241                 wait_event_killable(wq, condition)
 242
 243 #endif /* !CONFIG_FREEZER */
 244
 245 #endif  /* FREEZER_H_INCLUDED */