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 20 /* 21 * Timeout for stopping processes 22 */ 23 #define TIMEOUT (20 * HZ) 24 25 static int try_to_freeze_tasks(bool user_only) 26 { 27 struct task_struct *g, *p; 28 unsigned long end_time; 29 unsigned int todo; 30 bool wq_busy = false; 31 struct timeval start, end; 32 u64 elapsed_csecs64; 33 unsigned int elapsed_csecs; 34 bool wakeup = false; 35 36 do_gettimeofday(&start); 37 38 end_time = jiffies + TIMEOUT; 39 40 if (!user_only) 41 freeze_workqueues_begin(); 42 43 while (true) { 44 todo = 0; 45 read_lock(&tasklist_lock); 46 do_each_thread(g, p) { 47 if (p == current || !freeze_task(p)) 48 continue; 49 50 /* 51 * Now that we've done set_freeze_flag, don't 52 * perturb a task in TASK_STOPPED or TASK_TRACED. 53 * It is "frozen enough". If the task does wake 54 * up, it will immediately call try_to_freeze. 55 * 56 * Because freeze_task() goes through p's 57 * scheduler lock after setting TIF_FREEZE, it's 58 * guaranteed that either we see TASK_RUNNING or 59 * try_to_stop() after schedule() in ptrace/signal 60 * stop sees TIF_FREEZE. 61 */ 62 if (!task_is_stopped_or_traced(p) && 63 !freezer_should_skip(p)) 64 todo++; 65 } while_each_thread(g, p); 66 read_unlock(&tasklist_lock); 67 68 if (!user_only) { 69 wq_busy = freeze_workqueues_busy(); 70 todo += wq_busy; 71 } 72 73 if (!todo || time_after(jiffies, end_time)) 74 break; 75 76 if (pm_wakeup_pending()) { 77 wakeup = true; 78 break; 79 } 80 81 /* 82 * We need to retry, but first give the freezing tasks some 83 * time to enter the regrigerator. 84 */ 85 msleep(10); 86 } 87 88 do_gettimeofday(&end); 89 elapsed_csecs64 = timeval_to_ns(&end) - timeval_to_ns(&start); 90 do_div(elapsed_csecs64, NSEC_PER_SEC / 100); 91 elapsed_csecs = elapsed_csecs64; 92 93 if (todo) { 94 printk("\n"); 95 printk(KERN_ERR "Freezing of tasks %s after %d.%02d seconds " 96 "(%d tasks refusing to freeze, wq_busy=%d):\n", 97 wakeup ? "aborted" : "failed", 98 elapsed_csecs / 100, elapsed_csecs % 100, 99 todo - wq_busy, wq_busy); 100 101 read_lock(&tasklist_lock); 102 do_each_thread(g, p) { 103 if (!wakeup && !freezer_should_skip(p) && 104 p != current && freezing(p) && !frozen(p)) 105 sched_show_task(p); 106 } while_each_thread(g, p); 107 read_unlock(&tasklist_lock); 108 } else { 109 printk("(elapsed %d.%02d seconds) ", elapsed_csecs / 100, 110 elapsed_csecs % 100); 111 } 112 113 return todo ? -EBUSY : 0; 114 } 115 116 /** 117 * freeze_processes - Signal user space processes to enter the refrigerator. 118 * 119 * On success, returns 0. On failure, -errno and system is fully thawed. 120 */ 121 int freeze_processes(void) 122 { 123 int error; 124 125 if (!pm_freezing) 126 atomic_inc(&system_freezing_cnt); 127 128 printk("Freezing user space processes ... "); 129 pm_freezing = true; 130 error = try_to_freeze_tasks(true); 131 if (!error) { 132 printk("done."); 133 oom_killer_disable(); 134 } 135 printk("\n"); 136 BUG_ON(in_atomic()); 137 138 if (error) 139 thaw_processes(); 140 return error; 141 } 142 143 /** 144 * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator. 145 * 146 * On success, returns 0. On failure, -errno and system is fully thawed. 147 */ 148 int freeze_kernel_threads(void) 149 { 150 int error; 151 152 printk("Freezing remaining freezable tasks ... "); 153 pm_nosig_freezing = true; 154 error = try_to_freeze_tasks(false); 155 if (!error) 156 printk("done."); 157 158 printk("\n"); 159 BUG_ON(in_atomic()); 160 161 if (error) 162 thaw_processes(); 163 return error; 164 } 165 166 void thaw_processes(void) 167 { 168 struct task_struct *g, *p; 169 170 if (pm_freezing) 171 atomic_dec(&system_freezing_cnt); 172 pm_freezing = false; 173 pm_nosig_freezing = false; 174 175 oom_killer_enable(); 176 177 printk("Restarting tasks ... "); 178 179 thaw_workqueues(); 180 181 read_lock(&tasklist_lock); 182 do_each_thread(g, p) { 183 __thaw_task(p); 184 } while_each_thread(g, p); 185 read_unlock(&tasklist_lock); 186 187 schedule(); 188 printk("done.\n"); 189 } 190 191