Merge branch 'upstream' of git://git.kernel.org/pub/scm/linux/kernel/git/linville...
[linux-2.6] / 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);