kernel/power/process.c

   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 scheduler lock, it's
  57                          * guaranteed that TASK_STOPPED/TRACED -> TASK_RUNNING
  58                          * transition can't race with task state testing here.
  59                          */
  60                         if (!task_is_stopped_or_traced(p) &&
  61                             !freezer_should_skip(p))
  62                                 todo++;
  63                 } while_each_thread(g, p);
  64                 read_unlock(&tasklist_lock);
  65
  66                 if (!user_only) {
  67                         wq_busy = freeze_workqueues_busy();
  68                         todo += wq_busy;
  69                 }
  70
  71                 if (!todo || time_after(jiffies, end_time))
  72                         break;
  73
  74                 if (pm_wakeup_pending()) {
  75                         wakeup = true;
  76                         break;
  77                 }
  78
  79                 /*
  80                  * We need to retry, but first give the freezing tasks some
  81                  * time to enter the regrigerator.
  82                  */
  83                 msleep(10);
  84         }
  85
  86         do_gettimeofday(&end);
  87         elapsed_csecs64 = timeval_to_ns(&end) - timeval_to_ns(&start);
  88         do_div(elapsed_csecs64, NSEC_PER_SEC / 100);
  89         elapsed_csecs = elapsed_csecs64;
  90
  91         if (todo) {
  92                 printk("\n");
  93                 printk(KERN_ERR "Freezing of tasks %s after %d.%02d seconds "
  94                        "(%d tasks refusing to freeze, wq_busy=%d):\n",
  95                        wakeup ? "aborted" : "failed",
  96                        elapsed_csecs / 100, elapsed_csecs % 100,
  97                        todo - wq_busy, wq_busy);
  98
  99                 if (!wakeup) {
 100                         read_lock(&tasklist_lock);
 101                         do_each_thread(g, p) {
 102                                 if (p != current && !freezer_should_skip(p)
 103                                     && freezing(p) && !frozen(p))
 104                                         sched_show_task(p);
 105                         } while_each_thread(g, p);
 106                         read_unlock(&tasklist_lock);
 107                 }
 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 only the kernel threads are
 147  * thawed, so as to give a chance to the caller to do additional cleanups
 148  * (if any) before thawing the userspace tasks. So, it is the responsibility
 149  * of the caller to thaw the userspace tasks, when the time is right.
 150  */
 151 int freeze_kernel_threads(void)
 152 {
 153         int error;
 154
 155         printk("Freezing remaining freezable tasks ... ");
 156         pm_nosig_freezing = true;
 157         error = try_to_freeze_tasks(false);
 158         if (!error)
 159                 printk("done.");
 160
 161         printk("\n");
 162         BUG_ON(in_atomic());
 163
 164         if (error)
 165                 thaw_kernel_threads();
 166         return error;
 167 }
 168
 169 void thaw_processes(void)
 170 {
 171         struct task_struct *g, *p;
 172
 173         if (pm_freezing)
 174                 atomic_dec(&system_freezing_cnt);
 175         pm_freezing = false;
 176         pm_nosig_freezing = false;
 177
 178         oom_killer_enable();
 179
 180         printk("Restarting tasks ... ");
 181
 182         thaw_workqueues();
 183
 184         read_lock(&tasklist_lock);
 185         do_each_thread(g, p) {
 186                 __thaw_task(p);
 187         } while_each_thread(g, p);
 188         read_unlock(&tasklist_lock);
 189
 190         schedule();
 191         printk("done.\n");
 192 }
 193
 194 void thaw_kernel_threads(void)
 195 {
 196         struct task_struct *g, *p;
 197
 198         pm_nosig_freezing = false;
 199         printk("Restarting kernel threads ... ");
 200
 201         thaw_workqueues();
 202
 203         read_lock(&tasklist_lock);
 204         do_each_thread(g, p) {
 205                 if (p->flags & (PF_KTHREAD | PF_WQ_WORKER))
 206                         __thaw_task(p);
 207         } while_each_thread(g, p);
 208         read_unlock(&tasklist_lock);
 209
 210         schedule();
 211         printk("done.\n");
 212 }