78d92dc6a1edc8119ae616bf184e83ae26ec27e8
[linux-2.6.git] / 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
16 /* 
17  * Timeout for stopping processes
18  */
19 #define TIMEOUT (6 * HZ)
20
21
22 static inline int freezeable(struct task_struct * p)
23 {
24         if ((p == current) || 
25             (p->flags & PF_NOFREEZE) ||
26             (p->exit_state == EXIT_ZOMBIE) ||
27             (p->exit_state == EXIT_DEAD) ||
28             (p->state == TASK_STOPPED) ||
29             (p->state == TASK_TRACED))
30                 return 0;
31         return 1;
32 }
33
34 /* Refrigerator is place where frozen processes are stored :-). */
35 void refrigerator(unsigned long flag)
36 {
37         /* Hmm, should we be allowed to suspend when there are realtime
38            processes around? */
39         long save;
40         save = current->state;
41         current->state = TASK_UNINTERRUPTIBLE;
42         pr_debug("%s entered refrigerator\n", current->comm);
43         printk("=");
44         current->flags &= ~PF_FREEZE;
45
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         current->flags |= PF_FROZEN;
51         while (current->flags & PF_FROZEN)
52                 schedule();
53         pr_debug("%s left refrigerator\n", current->comm);
54         current->state = save;
55 }
56
57 /* 0 = success, else # of processes that we failed to stop */
58 int freeze_processes(void)
59 {
60        int todo;
61        unsigned long start_time;
62         struct task_struct *g, *p;
63         
64         printk( "Stopping tasks: " );
65         start_time = jiffies;
66         do {
67                 todo = 0;
68                 read_lock(&tasklist_lock);
69                 do_each_thread(g, p) {
70                         unsigned long flags;
71                         if (!freezeable(p))
72                                 continue;
73                         if ((p->flags & PF_FROZEN) ||
74                             (p->state == TASK_TRACED) ||
75                             (p->state == TASK_STOPPED))
76                                 continue;
77
78                         /* FIXME: smp problem here: we may not access other process' flags
79                            without locking */
80                         p->flags |= PF_FREEZE;
81                         spin_lock_irqsave(&p->sighand->siglock, flags);
82                         signal_wake_up(p, 0);
83                         spin_unlock_irqrestore(&p->sighand->siglock, flags);
84                         todo++;
85                 } while_each_thread(g, p);
86                 read_unlock(&tasklist_lock);
87                 yield();                        /* Yield is okay here */
88                 if (time_after(jiffies, start_time + TIMEOUT)) {
89                         printk( "\n" );
90                         printk(KERN_ERR " stopping tasks failed (%d tasks remaining)\n", todo );
91                         return todo;
92                 }
93         } while(todo);
94         
95         printk( "|\n" );
96         BUG_ON(in_atomic());
97         return 0;
98 }
99
100 void thaw_processes(void)
101 {
102         struct task_struct *g, *p;
103
104         printk( "Restarting tasks..." );
105         read_lock(&tasklist_lock);
106         do_each_thread(g, p) {
107                 if (!freezeable(p))
108                         continue;
109                 if (p->flags & PF_FROZEN) {
110                         p->flags &= ~PF_FROZEN;
111                         wake_up_process(p);
112                 } else
113                         printk(KERN_INFO " Strange, %s not stopped\n", p->comm );
114         } while_each_thread(g, p);
115
116         read_unlock(&tasklist_lock);
117         schedule();
118         printk( " done\n" );
119 }
120
121 EXPORT_SYMBOL(refrigerator);