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 sig_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 (!sig_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, sig_only))
  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 (!sig_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 - tell processes to enter the refrigerator
 118  */
 119 int freeze_processes(void)
 120 {
 121         int error;
 122
 123         if (!pm_freezing)
 124                 atomic_inc(&system_freezing_cnt);
 125
 126         printk("Freezing user space processes ... ");
 127         pm_freezing = true;
 128         error = try_to_freeze_tasks(true);
 129         if (error)
 130                 goto Exit;
 131         printk("done.\n");
 132
 133         printk("Freezing remaining freezable tasks ... ");
 134         pm_nosig_freezing = true;
 135         error = try_to_freeze_tasks(false);
 136         if (error)
 137                 goto Exit;
 138         printk("done.");
 139
 140         oom_killer_disable();
 141  Exit:
 142         if (error)
 143                 thaw_processes();
 144         BUG_ON(in_atomic());
 145         printk("\n");
 146
 147         return error;
 148 }
 149
 150 void thaw_processes(void)
 151 {
 152         struct task_struct *g, *p;
 153
 154         if (pm_freezing)
 155                 atomic_dec(&system_freezing_cnt);
 156         pm_freezing = false;
 157         pm_nosig_freezing = false;
 158
 159         oom_killer_enable();
 160
 161         printk("Restarting tasks ... ");
 162
 163         thaw_workqueues();
 164
 165         read_lock(&tasklist_lock);
 166         do_each_thread(g, p) {
 167                 __thaw_task(p);
 168         } while_each_thread(g, p);
 169         read_unlock(&tasklist_lock);
 170
 171         schedule();
 172         printk("done.\n");
 173 }
 174