Merge branch 'master' into upstream
[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                 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         pr_debug("%s entered refrigerator\n", current->comm);
42         printk("=");
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 && frozen(p->parent)) {
101                                 cancel_freezing(p);
102                                 continue;
103                         }
104                         if (p->mm && !(p->flags & PF_BORROWED_MM)) {
105                                 /* The task is a user-space one.
106                                  * Freeze it unless there's a vfork completion
107                                  * pending
108                                  */
109                                 if (!p->vfork_done)
110                                         freeze_process(p);
111                                 nr_user++;
112                         } else {
113                                 /* Freeze only if the user space is frozen */
114                                 if (user_frozen)
115                                         freeze_process(p);
116                                 todo++;
117                         }
118                 } while_each_thread(g, p);
119                 read_unlock(&tasklist_lock);
120                 todo += nr_user;
121                 if (!user_frozen && !nr_user) {
122                         sys_sync();
123                         start_time = jiffies;
124                 }
125                 user_frozen = !nr_user;
126                 yield();                        /* Yield is okay here */
127                 if (todo && time_after(jiffies, start_time + TIMEOUT))
128                         break;
129         } while(todo);
130
131         /* This does not unfreeze processes that are already frozen
132          * (we have slightly ugly calling convention in that respect,
133          * and caller must call thaw_processes() if something fails),
134          * but it cleans up leftover PF_FREEZE requests.
135          */
136         if (todo) {
137                 printk( "\n" );
138                 printk(KERN_ERR " stopping tasks timed out "
139                         "after %d seconds (%d tasks remaining):\n",
140                         TIMEOUT / HZ, todo);
141                 read_lock(&tasklist_lock);
142                 do_each_thread(g, p) {
143                         if (freezeable(p) && !frozen(p))
144                                 printk(KERN_ERR "  %s\n", p->comm);
145                         cancel_freezing(p);
146                 } while_each_thread(g, p);
147                 read_unlock(&tasklist_lock);
148                 return todo;
149         }
150
151         printk( "|\n" );
152         BUG_ON(in_atomic());
153         return 0;
154 }
155
156 void thaw_processes(void)
157 {
158         struct task_struct *g, *p;
159
160         printk( "Restarting tasks..." );
161         read_lock(&tasklist_lock);
162         do_each_thread(g, p) {
163                 if (!freezeable(p))
164                         continue;
165                 if (!thaw_process(p))
166                         printk(KERN_INFO " Strange, %s not stopped\n", p->comm );
167         } while_each_thread(g, p);
168
169         read_unlock(&tasklist_lock);
170         schedule();
171         printk( " done\n" );
172 }
173
174 EXPORT_SYMBOL(refrigerator);