git.oblomov.eu Git - linux-2.6/blob - 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 #include <linux/freezer.h>
  17
  18 /*
  19  * Timeout for stopping processes
  20  */
  21 #define TIMEOUT (20 * HZ)
  22
  23
  24 static inline int freezeable(struct task_struct * p)
  25 {
  26         if ((p == current) ||
  27             (p->flags & PF_NOFREEZE) ||
  28             (p->exit_state == EXIT_ZOMBIE) ||
  29             (p->exit_state == EXIT_DEAD) ||
  30             (p->state == TASK_STOPPED))
  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
  44         frozen_process(current);
  45         spin_lock_irq(&current->sighand->siglock);
  46         recalc_sigpending(); /* We sent fake signal, clean it up */
  47         spin_unlock_irq(&current->sighand->siglock);
  48
  49         while (frozen(current)) {
  50                 current->state = TASK_UNINTERRUPTIBLE;
  51                 schedule();
  52         }
  53         pr_debug("%s left refrigerator\n", current->comm);
  54         current->state = save;
  55 }
  56
  57 static inline void freeze_process(struct task_struct *p)
  58 {
  59         unsigned long flags;
  60
  61         if (!freezing(p)) {
  62                 freeze(p);
  63                 spin_lock_irqsave(&p->sighand->siglock, flags);
  64                 signal_wake_up(p, 0);
  65                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
  66         }
  67 }
  68
  69 static void cancel_freezing(struct task_struct *p)
  70 {
  71         unsigned long flags;
  72
  73         if (freezing(p)) {
  74                 pr_debug("  clean up: %s\n", p->comm);
  75                 do_not_freeze(p);
  76                 spin_lock_irqsave(&p->sighand->siglock, flags);
  77                 recalc_sigpending_tsk(p);
  78                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
  79         }
  80 }
  81
  82 /* 0 = success, else # of processes that we failed to stop */
  83 int freeze_processes(void)
  84 {
  85         int todo, nr_user, user_frozen;
  86         unsigned long start_time;
  87         struct task_struct *g, *p;
  88
  89         printk("Stopping tasks... ");
  90         start_time = jiffies;
  91         user_frozen = 0;
  92         do {
  93                 nr_user = todo = 0;
  94                 read_lock(&tasklist_lock);
  95                 do_each_thread(g, p) {
  96                         if (!freezeable(p))
  97                                 continue;
  98                         if (frozen(p))
  99                                 continue;
 100                         if (p->state == TASK_TRACED &&
 101                             (frozen(p->parent) ||
 102                              p->parent->state == TASK_STOPPED)) {
 103                                 cancel_freezing(p);
 104                                 continue;
 105                         }
 106                         if (p->mm && !(p->flags & PF_BORROWED_MM)) {
 107                                 /* The task is a user-space one.
 108                                  * Freeze it unless there's a vfork completion
 109                                  * pending
 110                                  */
 111                                 if (!p->vfork_done)
 112                                         freeze_process(p);
 113                                 nr_user++;
 114                         } else {
 115                                 /* Freeze only if the user space is frozen */
 116                                 if (user_frozen)
 117                                         freeze_process(p);
 118                                 todo++;
 119                         }
 120                 } while_each_thread(g, p);
 121                 read_unlock(&tasklist_lock);
 122                 todo += nr_user;
 123                 if (!user_frozen && !nr_user) {
 124                         sys_sync();
 125                         start_time = jiffies;
 126                 }
 127                 user_frozen = !nr_user;
 128                 yield();                        /* Yield is okay here */
 129                 if (todo && time_after(jiffies, start_time + TIMEOUT))
 130                         break;
 131         } while(todo);
 132
 133         /* This does not unfreeze processes that are already frozen
 134          * (we have slightly ugly calling convention in that respect,
 135          * and caller must call thaw_processes() if something fails),
 136          * but it cleans up leftover PF_FREEZE requests.
 137          */
 138         if (todo) {
 139                 printk("\n");
 140                 printk(KERN_ERR "Stopping tasks timed out "
 141                         "after %d seconds (%d tasks remaining):\n",
 142                         TIMEOUT / HZ, todo);
 143                 read_lock(&tasklist_lock);
 144                 do_each_thread(g, p) {
 145                         if (freezeable(p) && !frozen(p))
 146                                 printk(KERN_ERR " %s\n", p->comm);
 147                         cancel_freezing(p);
 148                 } while_each_thread(g, p);
 149                 read_unlock(&tasklist_lock);
 150                 return todo;
 151         }
 152
 153         printk("done.\n");
 154         BUG_ON(in_atomic());
 155         return 0;
 156 }
 157
 158 void thaw_some_processes(int all)
 159 {
 160         struct task_struct *g, *p;
 161         int pass = 0; /* Pass 0 = Kernel space, 1 = Userspace */
 162
 163         printk("Restarting tasks... ");
 164         read_lock(&tasklist_lock);
 165         do {
 166                 do_each_thread(g, p) {
 167                         /*
 168                          * is_user = 0 if kernel thread or borrowed mm,
 169                          * 1 otherwise.
 170                          */
 171                         int is_user = !!(p->mm && !(p->flags & PF_BORROWED_MM));
 172                         if (!freezeable(p) || (is_user != pass))
 173                                 continue;
 174                         if (!thaw_process(p))
 175                                 printk(KERN_INFO
 176                                         "Strange, %s not stopped\n", p->comm);
 177                 } while_each_thread(g, p);
 178
 179                 pass++;
 180         } while (pass < 2 && all);
 181
 182         read_unlock(&tasklist_lock);
 183         schedule();
 184         printk("done.\n");
 185 }
 186
 187 EXPORT_SYMBOL(refrigerator);