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/smp_lock.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/suspend.h>
  14 #include <linux/module.h>
  15 #include <linux/syscalls.h>
  16
  17 /*
  18  * Timeout for stopping processes
  19  */
  20 #define TIMEOUT (20 * HZ)
  21
  22
  23 static inline int freezeable(struct task_struct * p)
  24 {
  25         if ((p == current) ||
  26             (p->flags & PF_NOFREEZE) ||
  27             (p->exit_state == EXIT_ZOMBIE) ||
  28             (p->exit_state == EXIT_DEAD) ||
  29             (p->state == TASK_STOPPED) ||
  30             (p->state == TASK_TRACED))
  31                 return 0;
  32         return 1;
  33 }
  34
  35 /* Refrigerator is place where frozen processes are stored :-). */
  36 void refrigerator(void)
  37 {
  38         /* Hmm, should we be allowed to suspend when there are realtime
  39            processes around? */
  40         long save;
  41         save = current->state;
  42         pr_debug("%s entered refrigerator\n", current->comm);
  43         printk("=");
  44
  45         frozen_process(current);
  46         spin_lock_irq(&current->sighand->siglock);
  47         recalc_sigpending(); /* We sent fake signal, clean it up */
  48         spin_unlock_irq(&current->sighand->siglock);
  49
  50         while (frozen(current)) {
  51                 current->state = TASK_UNINTERRUPTIBLE;
  52                 schedule();
  53         }
  54         pr_debug("%s left refrigerator\n", current->comm);
  55         current->state = save;
  56 }
  57
  58 static inline void freeze_process(struct task_struct *p)
  59 {
  60         unsigned long flags;
  61
  62         if (!freezing(p)) {
  63                 freeze(p);
  64                 spin_lock_irqsave(&p->sighand->siglock, flags);
  65                 signal_wake_up(p, 0);
  66                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
  67         }
  68 }
  69
  70 /* 0 = success, else # of processes that we failed to stop */
  71 int freeze_processes(void)
  72 {
  73         int todo, nr_user, user_frozen;
  74         unsigned long start_time;
  75         struct task_struct *g, *p;
  76         unsigned long flags;
  77
  78         printk( "Stopping tasks: " );
  79         start_time = jiffies;
  80         user_frozen = 0;
  81         do {
  82                 nr_user = todo = 0;
  83                 read_lock(&tasklist_lock);
  84                 do_each_thread(g, p) {
  85                         if (!freezeable(p))
  86                                 continue;
  87                         if (frozen(p))
  88                                 continue;
  89                         if (p->mm && !(p->flags & PF_BORROWED_MM)) {
  90                                 /* The task is a user-space one.
  91                                  * Freeze it unless there's a vfork completion
  92                                  * pending
  93                                  */
  94                                 if (!p->vfork_done)
  95                                         freeze_process(p);
  96                                 nr_user++;
  97                         } else {
  98                                 /* Freeze only if the user space is frozen */
  99                                 if (user_frozen)
 100                                         freeze_process(p);
 101                                 todo++;
 102                         }
 103                 } while_each_thread(g, p);
 104                 read_unlock(&tasklist_lock);
 105                 todo += nr_user;
 106                 if (!user_frozen && !nr_user) {
 107                         sys_sync();
 108                         start_time = jiffies;
 109                 }
 110                 user_frozen = !nr_user;
 111                 yield();                        /* Yield is okay here */
 112                 if (todo && time_after(jiffies, start_time + TIMEOUT))
 113                         break;
 114         } while(todo);
 115
 116         /* This does not unfreeze processes that are already frozen
 117          * (we have slightly ugly calling convention in that respect,
 118          * and caller must call thaw_processes() if something fails),
 119          * but it cleans up leftover PF_FREEZE requests.
 120          */
 121         if (todo) {
 122                 printk( "\n" );
 123                 printk(KERN_ERR " stopping tasks timed out "
 124                         "after %d seconds (%d tasks remaining):\n",
 125                         TIMEOUT / HZ, todo);
 126                 read_lock(&tasklist_lock);
 127                 do_each_thread(g, p) {
 128                         if (freezeable(p) && !frozen(p))
 129                                 printk(KERN_ERR "  %s\n", p->comm);
 130                         if (freezing(p)) {
 131                                 pr_debug("  clean up: %s\n", p->comm);
 132                                 p->flags &= ~PF_FREEZE;
 133                                 spin_lock_irqsave(&p->sighand->siglock, flags);
 134                                 recalc_sigpending_tsk(p);
 135                                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
 136                         }
 137                 } while_each_thread(g, p);
 138                 read_unlock(&tasklist_lock);
 139                 return todo;
 140         }
 141
 142         printk( "|\n" );
 143         BUG_ON(in_atomic());
 144         return 0;
 145 }
 146
 147 void thaw_processes(void)
 148 {
 149         struct task_struct *g, *p;
 150
 151         printk( "Restarting tasks..." );
 152         read_lock(&tasklist_lock);
 153         do_each_thread(g, p) {
 154                 if (!freezeable(p))
 155                         continue;
 156                 if (!thaw_process(p))
 157                         printk(KERN_INFO " Strange, %s not stopped\n", p->comm );
 158         } while_each_thread(g, p);
 159
 160         read_unlock(&tasklist_lock);
 161         schedule();
 162         printk( " done\n" );
 163 }
 164
 165 EXPORT_SYMBOL(refrigerator);