[PATCH] Cleanup patch for process freezing
[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(void)
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
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                 schedule();
52         pr_debug("%s left refrigerator\n", current->comm);
53         current->state = save;
54 }
55
56 /* 0 = success, else # of processes that we failed to stop */
57 int freeze_processes(void)
58 {
59         int todo;
60         unsigned long start_time;
61         struct task_struct *g, *p;
62
63         printk( "Stopping tasks: " );
64         start_time = jiffies;
65         do {
66                 todo = 0;
67                 read_lock(&tasklist_lock);
68                 do_each_thread(g, p) {
69                         unsigned long flags;
70                         if (!freezeable(p))
71                                 continue;
72                         if ((frozen(p)) ||
73                             (p->state == TASK_TRACED) ||
74                             (p->state == TASK_STOPPED))
75                                 continue;
76
77                         freeze(p);
78                         spin_lock_irqsave(&p->sighand->siglock, flags);
79                         signal_wake_up(p, 0);
80                         spin_unlock_irqrestore(&p->sighand->siglock, flags);
81                         todo++;
82                 } while_each_thread(g, p);
83                 read_unlock(&tasklist_lock);
84                 yield();                        /* Yield is okay here */
85                 if (time_after(jiffies, start_time + TIMEOUT)) {
86                         printk( "\n" );
87                         printk(KERN_ERR " stopping tasks failed (%d tasks remaining)\n", todo );
88                         return todo;
89                 }
90         } while(todo);
91
92         printk( "|\n" );
93         BUG_ON(in_atomic());
94         return 0;
95 }
96
97 void thaw_processes(void)
98 {
99         struct task_struct *g, *p;
100
101         printk( "Restarting tasks..." );
102         read_lock(&tasklist_lock);
103         do_each_thread(g, p) {
104                 if (!freezeable(p))
105                         continue;
106                 if (!thaw_process(p))
107                         printk(KERN_INFO " Strange, %s not stopped\n", p->comm );
108         } while_each_thread(g, p);
109
110         read_unlock(&tasklist_lock);
111         schedule();
112         printk( " done\n" );
113 }
114
115 EXPORT_SYMBOL(refrigerator);