ia64/linux-2.6.18-xen.hg

view kernel/power/process.c @ 562:66faefe721eb

pvSCSI backend driver

Signed-off-by: Tomonari Horikoshi <t.horikoshi@jp.fujitsu.com>
Signed-off-by: Jun Kamada <kama@jp.fujitsu.com>
author Keir Fraser <keir.fraser@citrix.com>
date Mon Jun 02 09:58:27 2008 +0100 (2008-06-02)
parents 831230e53067
children
line source
1 /*
2 * drivers/power/process.c - Functions for starting/stopping processes on
3 * suspend transitions.
4 *
5 * Originally from swsusp.
6 */
9 #undef DEBUG
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>
17 /*
18 * Timeout for stopping processes
19 */
20 #define TIMEOUT (20 * HZ)
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 }
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("=");
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);
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 }
57 static inline void freeze_process(struct task_struct *p)
58 {
59 unsigned long flags;
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 }
69 static void cancel_freezing(struct task_struct *p)
70 {
71 unsigned long flags;
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 }
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;
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);
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 }
151 printk( "|\n" );
152 BUG_ON(in_atomic());
153 return 0;
154 }
156 void thaw_processes(void)
157 {
158 struct task_struct *g, *p;
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);
169 read_unlock(&tasklist_lock);
170 schedule();
171 printk( " done\n" );
172 }
174 EXPORT_SYMBOL(refrigerator);