[PATCH] swsusp: Support i386 systems with PAE or without PSE
[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 #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 && 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("done.\n");
152         BUG_ON(in_atomic());
153         return 0;
154 }
155
156 void thaw_some_processes(int all)
157 {
158         struct task_struct *g, *p;
159         int pass = 0; /* Pass 0 = Kernel space, 1 = Userspace */
160
161         printk("Restarting tasks... ");
162         read_lock(&tasklist_lock);
163         do {
164                 do_each_thread(g, p) {
165                         /*
166                          * is_user = 0 if kernel thread or borrowed mm,
167                          * 1 otherwise.
168                          */
169                         int is_user = !!(p->mm && !(p->flags & PF_BORROWED_MM));
170                         if (!freezeable(p) || (is_user != pass))
171                                 continue;
172                         if (!thaw_process(p))
173                                 printk(KERN_INFO
174                                         "Strange, %s not stopped\n", p->comm);
175                 } while_each_thread(g, p);
176
177                 pass++;
178         } while (pass < 2 && all);
179
180         read_unlock(&tasklist_lock);
181         schedule();
182         printk("done.\n");
183 }
184
185 EXPORT_SYMBOL(refrigerator);