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 21 /* 22 * Timeout for stopping processes 23 */ 24 unsigned int __read_mostly freeze_timeout_msecs = 20 * MSEC_PER_SEC; 25 26 static int try_to_freeze_tasks(bool user_only) 27 { 28 struct task_struct *g, *p; 29 unsigned long end_time; 30 unsigned int todo; 31 bool wq_busy = false; 32 struct timeval start, end; 33 u64 elapsed_msecs64; 34 unsigned int elapsed_msecs; 35 bool wakeup = false; 36 int sleep_usecs = USEC_PER_MSEC; 37 38 do_gettimeofday(&start); 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 do_each_thread(g, p) { 49 if (p == current || !freeze_task(p)) 50 continue; 51 52 if (!freezer_should_skip(p)) 53 todo++; 54 } while_each_thread(g, p); 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 do_gettimeofday(&end); 81 elapsed_msecs64 = timeval_to_ns(&end) - timeval_to_ns(&start); 82 do_div(elapsed_msecs64, NSEC_PER_MSEC); 83 elapsed_msecs = elapsed_msecs64; 84 85 if (todo) { 86 printk("\n"); 87 printk(KERN_ERR "Freezing of tasks %s after %d.%03d seconds " 88 "(%d tasks refusing to freeze, wq_busy=%d):\n", 89 wakeup ? "aborted" : "failed", 90 elapsed_msecs / 1000, elapsed_msecs % 1000, 91 todo - wq_busy, wq_busy); 92 93 if (!wakeup) { 94 read_lock(&tasklist_lock); 95 do_each_thread(g, p) { 96 if (p != current && !freezer_should_skip(p) 97 && freezing(p) && !frozen(p)) 98 sched_show_task(p); 99 } while_each_thread(g, p); 100 read_unlock(&tasklist_lock); 101 } 102 } else { 103 printk("(elapsed %d.%03d seconds) ", elapsed_msecs / 1000, 104 elapsed_msecs % 1000); 105 } 106 107 return todo ? -EBUSY : 0; 108 } 109 110 /** 111 * freeze_processes - Signal user space processes to enter the refrigerator. 112 * The current thread will not be frozen. The same process that calls 113 * freeze_processes must later call thaw_processes. 114 * 115 * On success, returns 0. On failure, -errno and system is fully thawed. 116 */ 117 int freeze_processes(void) 118 { 119 int error; 120 121 error = __usermodehelper_disable(UMH_FREEZING); 122 if (error) 123 return error; 124 125 /* Make sure this task doesn't get frozen */ 126 current->flags |= PF_SUSPEND_TASK; 127 128 if (!pm_freezing) 129 atomic_inc(&system_freezing_cnt); 130 131 printk("Freezing user space processes ... "); 132 pm_freezing = true; 133 error = try_to_freeze_tasks(true); 134 if (!error) { 135 printk("done."); 136 __usermodehelper_set_disable_depth(UMH_DISABLED); 137 oom_killer_disable(); 138 } 139 printk("\n"); 140 BUG_ON(in_atomic()); 141 142 if (error) 143 thaw_processes(); 144 return error; 145 } 146 147 /** 148 * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator. 149 * 150 * On success, returns 0. On failure, -errno and only the kernel threads are 151 * thawed, so as to give a chance to the caller to do additional cleanups 152 * (if any) before thawing the userspace tasks. So, it is the responsibility 153 * of the caller to thaw the userspace tasks, when the time is right. 154 */ 155 int freeze_kernel_threads(void) 156 { 157 int error; 158 159 printk("Freezing remaining freezable tasks ... "); 160 pm_nosig_freezing = true; 161 error = try_to_freeze_tasks(false); 162 if (!error) 163 printk("done."); 164 165 printk("\n"); 166 BUG_ON(in_atomic()); 167 168 if (error) 169 thaw_kernel_threads(); 170 return error; 171 } 172 173 void thaw_processes(void) 174 { 175 struct task_struct *g, *p; 176 struct task_struct *curr = current; 177 178 if (pm_freezing) 179 atomic_dec(&system_freezing_cnt); 180 pm_freezing = false; 181 pm_nosig_freezing = false; 182 183 oom_killer_enable(); 184 185 printk("Restarting tasks ... "); 186 187 thaw_workqueues(); 188 189 read_lock(&tasklist_lock); 190 do_each_thread(g, p) { 191 /* No other threads should have PF_SUSPEND_TASK set */ 192 WARN_ON((p != curr) && (p->flags & PF_SUSPEND_TASK)); 193 __thaw_task(p); 194 } while_each_thread(g, p); 195 read_unlock(&tasklist_lock); 196 197 WARN_ON(!(curr->flags & PF_SUSPEND_TASK)); 198 curr->flags &= ~PF_SUSPEND_TASK; 199 200 usermodehelper_enable(); 201 202 schedule(); 203 printk("done.\n"); 204 } 205 206 void thaw_kernel_threads(void) 207 { 208 struct task_struct *g, *p; 209 210 pm_nosig_freezing = false; 211 printk("Restarting kernel threads ... "); 212 213 thaw_workqueues(); 214 215 read_lock(&tasklist_lock); 216 do_each_thread(g, p) { 217 if (p->flags & (PF_KTHREAD | PF_WQ_WORKER)) 218 __thaw_task(p); 219 } while_each_thread(g, p); 220 read_unlock(&tasklist_lock); 221 222 schedule(); 223 printk("done.\n"); 224 } 225