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, bool sig_only);
  52
  53 #ifdef CONFIG_CGROUP_FREEZER
  54 extern bool cgroup_freezing(struct task_struct *task);
  55 #else /* !CONFIG_CGROUP_FREEZER */
  56 static inline bool cgroup_freezing(struct task_struct *task)
  57 {
  58         return false;
  59 }
  60 #endif /* !CONFIG_CGROUP_FREEZER */
  61
  62 /*
  63  * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
  64  * calls wait_for_completion(&vfork) and reset right after it returns from this
  65  * function.  Next, the parent should call try_to_freeze() to freeze itself
  66  * appropriately in case the child has exited before the freezing of tasks is
  67  * complete.  However, we don't want kernel threads to be frozen in unexpected
  68  * places, so we allow them to block freeze_processes() instead or to set
  69  * PF_NOFREEZE if needed and PF_FREEZER_SKIP is only set for userland vfork
  70  * parents.  Fortunately, in the ____call_usermodehelper() case the parent won't
  71  * really block freeze_processes(), since ____call_usermodehelper() (the child)
  72  * does a little before exec/exit and it can't be frozen before waking up the
  73  * parent.
  74  */
  75
  76 /*
  77  * If the current task is a user space one, tell the freezer not to count it as
  78  * freezable.
  79  */
  80 static inline void freezer_do_not_count(void)
  81 {
  82         if (current->mm)
  83                 current->flags |= PF_FREEZER_SKIP;
  84 }
  85
  86 /*
  87  * If the current task is a user space one, tell the freezer to count it as
  88  * freezable again and try to freeze it.
  89  */
  90 static inline void freezer_count(void)
  91 {
  92         if (current->mm) {
  93                 current->flags &= ~PF_FREEZER_SKIP;
  94                 try_to_freeze();
  95         }
  96 }
  97
  98 /*
  99  * Check if the task should be counted as freezable by the freezer
 100  */
 101 static inline int freezer_should_skip(struct task_struct *p)
 102 {
 103         return !!(p->flags & PF_FREEZER_SKIP);
 104 }
 105
 106 /*
 107  * Tell the freezer that the current task should be frozen by it
 108  */
 109 static inline void set_freezable(void)
 110 {
 111         current->flags &= ~PF_NOFREEZE;
 112 }
 113
 114 /*
 115  * Tell the freezer that the current task should be frozen by it and that it
 116  * should send a fake signal to the task to freeze it.
 117  */
 118 static inline void set_freezable_with_signal(void)
 119 {
 120         current->flags &= ~(PF_NOFREEZE | PF_FREEZER_NOSIG);
 121 }
 122
 123 /*
 124  * Freezer-friendly wrappers around wait_event_interruptible(),
 125  * wait_event_killable() and wait_event_interruptible_timeout(), originally
 126  * defined in <linux/wait.h>
 127  */
 128
 129 #define wait_event_freezekillable(wq, condition)                        \
 130 ({                                                                      \
 131         int __retval;                                                   \
 132         freezer_do_not_count();                                         \
 133         __retval = wait_event_killable(wq, (condition));                \
 134         freezer_count();                                                \
 135         __retval;                                                       \
 136 })
 137
 138 #define wait_event_freezable(wq, condition)                             \
 139 ({                                                                      \
 140         int __retval;                                                   \
 141         do {                                                            \
 142                 __retval = wait_event_interruptible(wq,                 \
 143                                 (condition) || freezing(current));      \
 144                 if (__retval && !freezing(current))                     \
 145                         break;                                          \
 146                 else if (!(condition))                                  \
 147                         __retval = -ERESTARTSYS;                        \
 148         } while (try_to_freeze());                                      \
 149         __retval;                                                       \
 150 })
 151
 152
 153 #define wait_event_freezable_timeout(wq, condition, timeout)            \
 154 ({                                                                      \
 155         long __retval = timeout;                                        \
 156         do {                                                            \
 157                 __retval = wait_event_interruptible_timeout(wq,         \
 158                                 (condition) || freezing(current),       \
 159                                 __retval);                              \
 160         } while (try_to_freeze());                                      \
 161         __retval;                                                       \
 162 })
 163 #else /* !CONFIG_FREEZER */
 164 static inline bool frozen(struct task_struct *p) { return false; }
 165 static inline bool freezing(struct task_struct *p) { return false; }
 166
 167 static inline bool __refrigerator(bool check_kthr_stop) { return false; }
 168 static inline int freeze_processes(void) { return -ENOSYS; }
 169 static inline int freeze_kernel_threads(void) { return -ENOSYS; }
 170 static inline void thaw_processes(void) {}
 171
 172 static inline bool try_to_freeze(void) { return false; }
 173
 174 static inline void freezer_do_not_count(void) {}
 175 static inline void freezer_count(void) {}
 176 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
 177 static inline void set_freezable(void) {}
 178 static inline void set_freezable_with_signal(void) {}
 179
 180 #define wait_event_freezable(wq, condition)                             \
 181                 wait_event_interruptible(wq, condition)
 182
 183 #define wait_event_freezable_timeout(wq, condition, timeout)            \
 184                 wait_event_interruptible_timeout(wq, condition, timeout)
 185
 186 #define wait_event_freezekillable(wq, condition)                \
 187                 wait_event_killable(wq, condition)
 188
 189 #endif /* !CONFIG_FREEZER */
 190
 191 #endif  /* FREEZER_H_INCLUDED */