projects/linux·blob v2.6.18 · refs

174 lines · 3.9 KiB

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
23static 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 :-). */
35void 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
57static 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
69static 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 */
83int 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
156void 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
174EXPORT_SYMBOL(refrigerator);