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