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
   9 #ifdef CONFIG_FREEZER
  10 /*
  11  * Check if a process has been frozen
  12  */
  13 static inline int frozen(struct task_struct *p)
  14 {
  15         return p->flags & PF_FROZEN;
  16 }
  17
  18 /*
  19  * Check if there is a request to freeze a process
  20  */
  21 static inline int freezing(struct task_struct *p)
  22 {
  23         return test_tsk_thread_flag(p, TIF_FREEZE);
  24 }
  25
  26 /*
  27  * Request that a process be frozen
  28  */
  29 static inline void set_freeze_flag(struct task_struct *p)
  30 {
  31         set_tsk_thread_flag(p, TIF_FREEZE);
  32 }
  33
  34 /*
  35  * Sometimes we may need to cancel the previous 'freeze' request
  36  */
  37 static inline void clear_freeze_flag(struct task_struct *p)
  38 {
  39         clear_tsk_thread_flag(p, TIF_FREEZE);
  40 }
  41
  42 static inline bool should_send_signal(struct task_struct *p)
  43 {
  44         return !(p->flags & PF_FREEZER_NOSIG);
  45 }
  46
  47 /*
  48  * Wake up a frozen process
  49  *
  50  * task_lock() is taken to prevent the race with refrigerator() which may
  51  * occur if the freezing of tasks fails.  Namely, without the lock, if the
  52  * freezing of tasks failed, thaw_tasks() might have run before a task in
  53  * refrigerator() could call frozen_process(), in which case the task would be
  54  * frozen and no one would thaw it.
  55  */
  56 static inline int thaw_process(struct task_struct *p)
  57 {
  58         task_lock(p);
  59         if (frozen(p)) {
  60                 p->flags &= ~PF_FROZEN;
  61                 task_unlock(p);
  62                 wake_up_process(p);
  63                 return 1;
  64         }
  65         clear_freeze_flag(p);
  66         task_unlock(p);
  67         return 0;
  68 }
  69
  70 extern void refrigerator(void);
  71 extern int freeze_processes(void);
  72 extern void thaw_processes(void);
  73
  74 static inline int try_to_freeze(void)
  75 {
  76         if (freezing(current)) {
  77                 refrigerator();
  78                 return 1;
  79         } else
  80                 return 0;
  81 }
  82
  83 extern bool freeze_task(struct task_struct *p, bool sig_only);
  84 extern void cancel_freezing(struct task_struct *p);
  85
  86 /*
  87  * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
  88  * calls wait_for_completion(&vfork) and reset right after it returns from this
  89  * function.  Next, the parent should call try_to_freeze() to freeze itself
  90  * appropriately in case the child has exited before the freezing of tasks is
  91  * complete.  However, we don't want kernel threads to be frozen in unexpected
  92  * places, so we allow them to block freeze_processes() instead or to set
  93  * PF_NOFREEZE if needed and PF_FREEZER_SKIP is only set for userland vfork
  94  * parents.  Fortunately, in the ____call_usermodehelper() case the parent won't
  95  * really block freeze_processes(), since ____call_usermodehelper() (the child)
  96  * does a little before exec/exit and it can't be frozen before waking up the
  97  * parent.
  98  */
  99
 100 /*
 101  * If the current task is a user space one, tell the freezer not to count it as
 102  * freezable.
 103  */
 104 static inline void freezer_do_not_count(void)
 105 {
 106         if (current->mm)
 107                 current->flags |= PF_FREEZER_SKIP;
 108 }
 109
 110 /*
 111  * If the current task is a user space one, tell the freezer to count it as
 112  * freezable again and try to freeze it.
 113  */
 114 static inline void freezer_count(void)
 115 {
 116         if (current->mm) {
 117                 current->flags &= ~PF_FREEZER_SKIP;
 118                 try_to_freeze();
 119         }
 120 }
 121
 122 /*
 123  * Check if the task should be counted as freezeable by the freezer
 124  */
 125 static inline int freezer_should_skip(struct task_struct *p)
 126 {
 127         return !!(p->flags & PF_FREEZER_SKIP);
 128 }
 129
 130 /*
 131  * Tell the freezer that the current task should be frozen by it
 132  */
 133 static inline void set_freezable(void)
 134 {
 135         current->flags &= ~PF_NOFREEZE;
 136 }
 137
 138 /*
 139  * Tell the freezer that the current task should be frozen by it and that it
 140  * should send a fake signal to the task to freeze it.
 141  */
 142 static inline void set_freezable_with_signal(void)
 143 {
 144         current->flags &= ~(PF_NOFREEZE | PF_FREEZER_NOSIG);
 145 }
 146
 147 /*
 148  * Freezer-friendly wrappers around wait_event_interruptible() and
 149  * wait_event_interruptible_timeout(), originally defined in <linux/wait.h>
 150  */
 151
 152 #define wait_event_freezable(wq, condition)                             \
 153 ({                                                                      \
 154         int __retval;                                                   \
 155         do {                                                            \
 156                 __retval = wait_event_interruptible(wq,                 \
 157                                 (condition) || freezing(current));      \
 158                 if (__retval && !freezing(current))                     \
 159                         break;                                          \
 160                 else if (!(condition))                                  \
 161                         __retval = -ERESTARTSYS;                        \
 162         } while (try_to_freeze());                                      \
 163         __retval;                                                       \
 164 })
 165
 166
 167 #define wait_event_freezable_timeout(wq, condition, timeout)            \
 168 ({                                                                      \
 169         long __retval = timeout;                                        \
 170         do {                                                            \
 171                 __retval = wait_event_interruptible_timeout(wq,         \
 172                                 (condition) || freezing(current),       \
 173                                 __retval);                              \
 174         } while (try_to_freeze());                                      \
 175         __retval;                                                       \
 176 })
 177 #else /* !CONFIG_FREEZER */
 178 static inline int frozen(struct task_struct *p) { return 0; }
 179 static inline int freezing(struct task_struct *p) { return 0; }
 180 static inline void set_freeze_flag(struct task_struct *p) {}
 181 static inline void clear_freeze_flag(struct task_struct *p) {}
 182 static inline int thaw_process(struct task_struct *p) { return 1; }
 183
 184 static inline void refrigerator(void) {}
 185 static inline int freeze_processes(void) { BUG(); return 0; }
 186 static inline void thaw_processes(void) {}
 187
 188 static inline int try_to_freeze(void) { return 0; }
 189
 190 static inline void freezer_do_not_count(void) {}
 191 static inline void freezer_count(void) {}
 192 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
 193 static inline void set_freezable(void) {}
 194 static inline void set_freezable_with_signal(void) {}
 195
 196 #define wait_event_freezable(wq, condition)                             \
 197                 wait_event_interruptible(wq, condition)
 198
 199 #define wait_event_freezable_timeout(wq, condition, timeout)            \
 200                 wait_event_interruptible_timeout(wq, condition, timeout)
 201
 202 #endif /* !CONFIG_FREEZER */
 203
 204 #endif  /* FREEZER_H_INCLUDED */