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 */ 202