[PATCH] W1: Sync with w1/ds9490 tree.
[linux-2.6.git] / 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
16 /* 
17  * Timeout for stopping processes
18  */
19 #define TIMEOUT (6 * HZ)
20
21
22 static inline int freezeable(struct task_struct * p)
23 {
24         if ((p == current) || 
25             (p->flags & PF_NOFREEZE) ||
26             (p->exit_state == EXIT_ZOMBIE) ||
27             (p->exit_state == EXIT_DEAD) ||
28             (p->state == TASK_STOPPED) ||
29             (p->state == TASK_TRACED))
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 /* 0 = success, else # of processes that we failed to stop */
58 int freeze_processes(void)
59 {
60         int todo;
61         unsigned long start_time;
62         struct task_struct *g, *p;
63         unsigned long flags;
64
65         printk( "Stopping tasks: " );
66         start_time = jiffies;
67         do {
68                 todo = 0;
69                 read_lock(&tasklist_lock);
70                 do_each_thread(g, p) {
71                         if (!freezeable(p))
72                                 continue;
73                         if (frozen(p))
74                                 continue;
75
76                         freeze(p);
77                         spin_lock_irqsave(&p->sighand->siglock, flags);
78                         signal_wake_up(p, 0);
79                         spin_unlock_irqrestore(&p->sighand->siglock, flags);
80                         todo++;
81                 } while_each_thread(g, p);
82                 read_unlock(&tasklist_lock);
83                 yield();                        /* Yield is okay here */
84                 if (todo && time_after(jiffies, start_time + TIMEOUT)) {
85                         printk( "\n" );
86                         printk(KERN_ERR " stopping tasks failed (%d tasks remaining)\n", todo );
87                         break;
88                 }
89         } while(todo);
90
91         /* This does not unfreeze processes that are already frozen
92          * (we have slightly ugly calling convention in that respect,
93          * and caller must call thaw_processes() if something fails),
94          * but it cleans up leftover PF_FREEZE requests.
95          */
96         if (todo) {
97                 read_lock(&tasklist_lock);
98                 do_each_thread(g, p)
99                         if (freezing(p)) {
100                                 pr_debug("  clean up: %s\n", p->comm);
101                                 p->flags &= ~PF_FREEZE;
102                                 spin_lock_irqsave(&p->sighand->siglock, flags);
103                                 recalc_sigpending_tsk(p);
104                                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
105                         }
106                 while_each_thread(g, p);
107                 read_unlock(&tasklist_lock);
108                 return todo;
109         }
110
111         printk( "|\n" );
112         BUG_ON(in_atomic());
113         return 0;
114 }
115
116 void thaw_processes(void)
117 {
118         struct task_struct *g, *p;
119
120         printk( "Restarting tasks..." );
121         read_lock(&tasklist_lock);
122         do_each_thread(g, p) {
123                 if (!freezeable(p))
124                         continue;
125                 if (!thaw_process(p))
126                         printk(KERN_INFO " Strange, %s not stopped\n", p->comm );
127         } while_each_thread(g, p);
128
129         read_unlock(&tasklist_lock);
130         schedule();
131         printk( " done\n" );
132 }
133
134 EXPORT_SYMBOL(refrigerator);