include/linux/freezer.h

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