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 (!wakeup) { 93 read_lock(&tasklist_lock); 94 for_each_process_thread(g, p) { 95 if (p != current && !freezer_should_skip(p) 96 && freezing(p) && !frozen(p)) 97 sched_show_task(p); 98 } 99 read_unlock(&tasklist_lock); 100 } 101 } else { 102 pr_cont("(elapsed %d.%03d seconds) ", elapsed_msecs / 1000, 103 elapsed_msecs % 1000); 104 } 105 106 return todo ? -EBUSY : 0; 107 } 108 109 /** 110 * freeze_processes - Signal user space processes to enter the refrigerator. 111 * The current thread will not be frozen. The same process that calls 112 * freeze_processes must later call thaw_processes. 113 * 114 * On success, returns 0. On failure, -errno and system is fully thawed. 115 */ 116 int freeze_processes(void) 117 { 118 int error; 119 120 error = __usermodehelper_disable(UMH_FREEZING); 121 if (error) 122 return error; 123 124 /* Make sure this task doesn't get frozen */ 125 current->flags |= PF_SUSPEND_TASK; 126 127 if (!pm_freezing) 128 atomic_inc(&system_freezing_cnt); 129 130 pm_wakeup_clear(); 131 pr_info("Freezing user space processes ... "); 132 pm_freezing = true; 133 error = try_to_freeze_tasks(true); 134 if (!error) { 135 __usermodehelper_set_disable_depth(UMH_DISABLED); 136 pr_cont("done."); 137 } 138 pr_cont("\n"); 139 BUG_ON(in_atomic()); 140 141 /* 142 * Now that the whole userspace is frozen we need to disbale 143 * the OOM killer to disallow any further interference with 144 * killable tasks. 145 */ 146 if (!error && !oom_killer_disable()) 147 error = -EBUSY; 148 149 if (error) 150 thaw_processes(); 151 return error; 152 } 153 154 /** 155 * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator. 156 * 157 * On success, returns 0. On failure, -errno and only the kernel threads are 158 * thawed, so as to give a chance to the caller to do additional cleanups 159 * (if any) before thawing the userspace tasks. So, it is the responsibility 160 * of the caller to thaw the userspace tasks, when the time is right. 161 */ 162 int freeze_kernel_threads(void) 163 { 164 int error; 165 166 pr_info("Freezing remaining freezable tasks ... "); 167 168 pm_nosig_freezing = true; 169 error = try_to_freeze_tasks(false); 170 if (!error) 171 pr_cont("done."); 172 173 pr_cont("\n"); 174 BUG_ON(in_atomic()); 175 176 if (error) 177 thaw_kernel_threads(); 178 return error; 179 } 180 181 void thaw_processes(void) 182 { 183 struct task_struct *g, *p; 184 struct task_struct *curr = current; 185 186 trace_suspend_resume(TPS("thaw_processes"), 0, true); 187 if (pm_freezing) 188 atomic_dec(&system_freezing_cnt); 189 pm_freezing = false; 190 pm_nosig_freezing = false; 191 192 oom_killer_enable(); 193 194 pr_info("Restarting tasks ... "); 195 196 __usermodehelper_set_disable_depth(UMH_FREEZING); 197 thaw_workqueues(); 198 199 read_lock(&tasklist_lock); 200 for_each_process_thread(g, p) { 201 /* No other threads should have PF_SUSPEND_TASK set */ 202 WARN_ON((p != curr) && (p->flags & PF_SUSPEND_TASK)); 203 __thaw_task(p); 204 } 205 read_unlock(&tasklist_lock); 206 207 WARN_ON(!(curr->flags & PF_SUSPEND_TASK)); 208 curr->flags &= ~PF_SUSPEND_TASK; 209 210 usermodehelper_enable(); 211 212 schedule(); 213 pr_cont("done.\n"); 214 trace_suspend_resume(TPS("thaw_processes"), 0, false); 215 } 216 217 void thaw_kernel_threads(void) 218 { 219 struct task_struct *g, *p; 220 221 pm_nosig_freezing = false; 222 pr_info("Restarting kernel threads ... "); 223 224 thaw_workqueues(); 225 226 read_lock(&tasklist_lock); 227 for_each_process_thread(g, p) { 228 if (p->flags & (PF_KTHREAD | PF_WQ_WORKER)) 229 __thaw_task(p); 230 } 231 read_unlock(&tasklist_lock); 232 233 schedule(); 234 pr_cont("done.\n"); 235 } 236