1 /* 2 * drivers/power/process.c - Functions for starting/stopping processes on 3 * suspend transitions. 4 * 5 * Originally from swsusp. 6 */ 7 8 9 #undef DEBUG 10 11 #include <linux/interrupt.h> 12 #include <linux/oom.h> 13 #include <linux/suspend.h> 14 #include <linux/module.h> 15 #include <linux/syscalls.h> 16 #include <linux/freezer.h> 17 #include <linux/delay.h> 18 #include <linux/workqueue.h> 19 #include <linux/kmod.h> 20 #include <trace/events/power.h> 21 22 /* 23 * Timeout for stopping processes 24 */ 25 unsigned int __read_mostly freeze_timeout_msecs = 20 * MSEC_PER_SEC; 26 27 static int try_to_freeze_tasks(bool user_only) 28 { 29 struct task_struct *g, *p; 30 unsigned long end_time; 31 unsigned int todo; 32 bool wq_busy = false; 33 ktime_t start, end, elapsed; 34 unsigned int elapsed_msecs; 35 bool wakeup = false; 36 int sleep_usecs = USEC_PER_MSEC; 37 38 start = ktime_get_boottime(); 39 40 end_time = jiffies + msecs_to_jiffies(freeze_timeout_msecs); 41 42 if (!user_only) 43 freeze_workqueues_begin(); 44 45 while (true) { 46 todo = 0; 47 read_lock(&tasklist_lock); 48 for_each_process_thread(g, p) { 49 if (p == current || !freeze_task(p)) 50 continue; 51 52 if (!freezer_should_skip(p)) 53 todo++; 54 } 55 read_unlock(&tasklist_lock); 56 57 if (!user_only) { 58 wq_busy = freeze_workqueues_busy(); 59 todo += wq_busy; 60 } 61 62 if (!todo || time_after(jiffies, end_time)) 63 break; 64 65 if (pm_wakeup_pending()) { 66 wakeup = true; 67 break; 68 } 69 70 /* 71 * We need to retry, but first give the freezing tasks some 72 * time to enter the refrigerator. Start with an initial 73 * 1 ms sleep followed by exponential backoff until 8 ms. 74 */ 75 usleep_range(sleep_usecs / 2, sleep_usecs); 76 if (sleep_usecs < 8 * USEC_PER_MSEC) 77 sleep_usecs *= 2; 78 } 79 80 end = ktime_get_boottime(); 81 elapsed = ktime_sub(end, start); 82 elapsed_msecs = ktime_to_ms(elapsed); 83 84 if (todo) { 85 pr_cont("\n"); 86 pr_err("Freezing of tasks %s after %d.%03d seconds " 87 "(%d tasks refusing to freeze, wq_busy=%d):\n", 88 wakeup ? "aborted" : "failed", 89 elapsed_msecs / 1000, elapsed_msecs % 1000, 90 todo - wq_busy, wq_busy); 91 92 if (wq_busy) 93 show_workqueue_state(); 94 95 if (!wakeup) { 96 read_lock(&tasklist_lock); 97 for_each_process_thread(g, p) { 98 if (p != current && !freezer_should_skip(p) 99 && freezing(p) && !frozen(p)) 100 sched_show_task(p); 101 } 102 read_unlock(&tasklist_lock); 103 } 104 } else { 105 pr_cont("(elapsed %d.%03d seconds) ", elapsed_msecs / 1000, 106 elapsed_msecs % 1000); 107 } 108 109 return todo ? -EBUSY : 0; 110 } 111 112 /** 113 * freeze_processes - Signal user space processes to enter the refrigerator. 114 * The current thread will not be frozen. The same process that calls 115 * freeze_processes must later call thaw_processes. 116 * 117 * On success, returns 0. On failure, -errno and system is fully thawed. 118 */ 119 int freeze_processes(void) 120 { 121 int error; 122 123 error = __usermodehelper_disable(UMH_FREEZING); 124 if (error) 125 return error; 126 127 /* Make sure this task doesn't get frozen */ 128 current->flags |= PF_SUSPEND_TASK; 129 130 if (!pm_freezing) 131 atomic_inc(&system_freezing_cnt); 132 133 pm_wakeup_clear(); 134 pr_info("Freezing user space processes ... "); 135 pm_freezing = true; 136 error = try_to_freeze_tasks(true); 137 if (!error) { 138 __usermodehelper_set_disable_depth(UMH_DISABLED); 139 pr_cont("done."); 140 } 141 pr_cont("\n"); 142 BUG_ON(in_atomic()); 143 144 /* 145 * Now that the whole userspace is frozen we need to disbale 146 * the OOM killer to disallow any further interference with 147 * killable tasks. There is no guarantee oom victims will 148 * ever reach a point they go away we have to wait with a timeout. 149 */ 150 if (!error && !oom_killer_disable(msecs_to_jiffies(freeze_timeout_msecs))) 151 error = -EBUSY; 152 153 if (error) 154 thaw_processes(); 155 return error; 156 } 157 158 /** 159 * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator. 160 * 161 * On success, returns 0. On failure, -errno and only the kernel threads are 162 * thawed, so as to give a chance to the caller to do additional cleanups 163 * (if any) before thawing the userspace tasks. So, it is the responsibility 164 * of the caller to thaw the userspace tasks, when the time is right. 165 */ 166 int freeze_kernel_threads(void) 167 { 168 int error; 169 170 pr_info("Freezing remaining freezable tasks ... "); 171 172 pm_nosig_freezing = true; 173 error = try_to_freeze_tasks(false); 174 if (!error) 175 pr_cont("done."); 176 177 pr_cont("\n"); 178 BUG_ON(in_atomic()); 179 180 if (error) 181 thaw_kernel_threads(); 182 return error; 183 } 184 185 void thaw_processes(void) 186 { 187 struct task_struct *g, *p; 188 struct task_struct *curr = current; 189 190 trace_suspend_resume(TPS("thaw_processes"), 0, true); 191 if (pm_freezing) 192 atomic_dec(&system_freezing_cnt); 193 pm_freezing = false; 194 pm_nosig_freezing = false; 195 196 oom_killer_enable(); 197 198 pr_info("Restarting tasks ... "); 199 200 __usermodehelper_set_disable_depth(UMH_FREEZING); 201 thaw_workqueues(); 202 203 read_lock(&tasklist_lock); 204 for_each_process_thread(g, p) { 205 /* No other threads should have PF_SUSPEND_TASK set */ 206 WARN_ON((p != curr) && (p->flags & PF_SUSPEND_TASK)); 207 __thaw_task(p); 208 } 209 read_unlock(&tasklist_lock); 210 211 WARN_ON(!(curr->flags & PF_SUSPEND_TASK)); 212 curr->flags &= ~PF_SUSPEND_TASK; 213 214 usermodehelper_enable(); 215 216 schedule(); 217 pr_cont("done.\n"); 218 trace_suspend_resume(TPS("thaw_processes"), 0, false); 219 } 220 221 void thaw_kernel_threads(void) 222 { 223 struct task_struct *g, *p; 224 225 pm_nosig_freezing = false; 226 pr_info("Restarting kernel threads ... "); 227 228 thaw_workqueues(); 229 230 read_lock(&tasklist_lock); 231 for_each_process_thread(g, p) { 232 if (p->flags & (PF_KTHREAD | PF_WQ_WORKER)) 233 __thaw_task(p); 234 } 235 read_unlock(&tasklist_lock); 236 237 schedule(); 238 pr_cont("done.\n"); 239 } 240