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  * Check if a process has been frozen
  17  */
  18 static inline bool frozen(struct task_struct *p)
  19 {
  20         return p->flags & PF_FROZEN;
  21 }
  22
  23 extern bool freezing_slow_path(struct task_struct *p);
  24
  25 /*
  26  * Check if there is a request to freeze a process
  27  */
  28 static inline bool freezing(struct task_struct *p)
  29 {
  30         if (likely(!atomic_read(&system_freezing_cnt)))
  31                 return false;
  32         return freezing_slow_path(p);
  33 }
  34
  35 /* Takes and releases task alloc lock using task_lock() */
  36 extern void __thaw_task(struct task_struct *t);
  37
  38 extern bool __refrigerator(bool check_kthr_stop);
  39 extern int freeze_processes(void);
  40 extern int freeze_kernel_threads(void);
  41 extern void thaw_processes(void);
  42
  43 static inline bool try_to_freeze(void)
  44 {
  45         might_sleep();
  46         if (likely(!freezing(current)))
  47                 return false;
  48         return __refrigerator(false);
  49 }
  50
  51 extern bool freeze_task(struct task_struct *p);
  52 extern bool set_freezable(void);
  53
  54 #ifdef CONFIG_CGROUP_FREEZER
  55 extern bool cgroup_freezing(struct task_struct *task);
  56 #else /* !CONFIG_CGROUP_FREEZER */
  57 static inline bool cgroup_freezing(struct task_struct *task)
  58 {
  59         return false;
  60 }
  61 #endif /* !CONFIG_CGROUP_FREEZER */
  62
  63 /*
  64  * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
  65  * calls wait_for_completion(&vfork) and reset right after it returns from this
  66  * function.  Next, the parent should call try_to_freeze() to freeze itself
  67  * appropriately in case the child has exited before the freezing of tasks is
  68  * complete.  However, we don't want kernel threads to be frozen in unexpected
  69  * places, so we allow them to block freeze_processes() instead or to set
  70  * PF_NOFREEZE if needed. Fortunately, in the ____call_usermodehelper() case the
  71  * parent won't really block freeze_processes(), since ____call_usermodehelper()
  72  * (the child) does a little before exec/exit and it can't be frozen before
  73  * waking up the parent.
  74  */
  75
  76
  77 /* Tell the freezer not to count the current task as freezable. */
  78 static inline void freezer_do_not_count(void)
  79 {
  80         current->flags |= PF_FREEZER_SKIP;
  81 }
  82
  83 /*
  84  * Tell the freezer to count the current task as freezable again and try to
  85  * freeze it.
  86  */
  87 static inline void freezer_count(void)
  88 {
  89         current->flags &= ~PF_FREEZER_SKIP;
  90         try_to_freeze();
  91 }
  92
  93 /*
  94  * Check if the task should be counted as freezable by the freezer
  95  */
  96 static inline int freezer_should_skip(struct task_struct *p)
  97 {
  98         return !!(p->flags & PF_FREEZER_SKIP);
  99 }
 100
 101 /*
 102  * These macros are intended to be used whenever you want allow a task that's
 103  * sleeping in TASK_UNINTERRUPTIBLE or TASK_KILLABLE state to be frozen. Note
 104  * that neither return any clear indication of whether a freeze event happened
 105  * while in this function.
 106  */
 107
 108 /* Like schedule(), but should not block the freezer. */
 109 #define freezable_schedule()                                            \
 110 ({                                                                      \
 111         freezer_do_not_count();                                         \
 112         schedule();                                                     \
 113         freezer_count();                                                \
 114 })
 115
 116 /* Like schedule_timeout_killable(), but should not block the freezer. */
 117 #define freezable_schedule_timeout_killable(timeout)                    \
 118 ({                                                                      \
 119         long __retval;                                                  \
 120         freezer_do_not_count();                                         \
 121         __retval = schedule_timeout_killable(timeout);                  \
 122         freezer_count();                                                \
 123         __retval;                                                       \
 124 })
 125
 126 /*
 127  * Freezer-friendly wrappers around wait_event_interruptible(),
 128  * wait_event_killable() and wait_event_interruptible_timeout(), originally
 129  * defined in <linux/wait.h>
 130  */
 131
 132 #define wait_event_freezekillable(wq, condition)                        \
 133 ({                                                                      \
 134         int __retval;                                                   \
 135         freezer_do_not_count();                                         \
 136         __retval = wait_event_killable(wq, (condition));                \
 137         freezer_count();                                                \
 138         __retval;                                                       \
 139 })
 140
 141 #define wait_event_freezable(wq, condition)                             \
 142 ({                                                                      \
 143         int __retval;                                                   \
 144         for (;;) {                                                      \
 145                 __retval = wait_event_interruptible(wq,                 \
 146                                 (condition) || freezing(current));      \
 147                 if (__retval || (condition))                            \
 148                         break;                                          \
 149                 try_to_freeze();                                        \
 150         }                                                               \
 151         __retval;                                                       \
 152 })
 153
 154 #define wait_event_freezable_timeout(wq, condition, timeout)            \
 155 ({                                                                      \
 156         long __retval = timeout;                                        \
 157         for (;;) {                                                      \
 158                 __retval = wait_event_interruptible_timeout(wq,         \
 159                                 (condition) || freezing(current),       \
 160                                 __retval);                              \
 161                 if (__retval <= 0 || (condition))                       \
 162                         break;                                          \
 163                 try_to_freeze();                                        \
 164         }                                                               \
 165         __retval;                                                       \
 166 })
 167
 168 #else /* !CONFIG_FREEZER */
 169 static inline bool frozen(struct task_struct *p) { return false; }
 170 static inline bool freezing(struct task_struct *p) { return false; }
 171 static inline void __thaw_task(struct task_struct *t) {}
 172
 173 static inline bool __refrigerator(bool check_kthr_stop) { return false; }
 174 static inline int freeze_processes(void) { return -ENOSYS; }
 175 static inline int freeze_kernel_threads(void) { return -ENOSYS; }
 176 static inline void thaw_processes(void) {}
 177
 178 static inline bool try_to_freeze(void) { return false; }
 179
 180 static inline void freezer_do_not_count(void) {}
 181 static inline void freezer_count(void) {}
 182 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
 183 static inline void set_freezable(void) {}
 184
 185 #define freezable_schedule()  schedule()
 186
 187 #define freezable_schedule_timeout_killable(timeout)                    \
 188         schedule_timeout_killable(timeout)
 189
 190 #define wait_event_freezable(wq, condition)                             \
 191                 wait_event_interruptible(wq, condition)
 192
 193 #define wait_event_freezable_timeout(wq, condition, timeout)            \
 194                 wait_event_interruptible_timeout(wq, condition, timeout)
 195
 196 #define wait_event_freezekillable(wq, condition)                \
 197                 wait_event_killable(wq, condition)
 198
 199 #endif /* !CONFIG_FREEZER */
 200
 201 #endif  /* FREEZER_H_INCLUDED */