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