freezer: kill PF_FREEZING
[linux-2.6.git] / kernel / freezer.c
1 /*
2  * kernel/freezer.c - Function to freeze a process
3  *
4  * Originally from kernel/power/process.c
5  */
6
7 #include <linux/interrupt.h>
8 #include <linux/suspend.h>
9 #include <linux/export.h>
10 #include <linux/syscalls.h>
11 #include <linux/freezer.h>
12 #include <linux/kthread.h>
13
14 /* protects freezing and frozen transitions */
15 static DEFINE_SPINLOCK(freezer_lock);
16
17 /* Refrigerator is place where frozen processes are stored :-). */
18 bool __refrigerator(bool check_kthr_stop)
19 {
20         /* Hmm, should we be allowed to suspend when there are realtime
21            processes around? */
22         bool was_frozen = false;
23         long save;
24
25         /*
26          * Enter FROZEN.  If NOFREEZE, schedule immediate thawing by
27          * clearing freezing.
28          */
29         spin_lock_irq(&freezer_lock);
30 repeat:
31         if (!freezing(current)) {
32                 spin_unlock_irq(&freezer_lock);
33                 return was_frozen;
34         }
35         if (current->flags & PF_NOFREEZE)
36                 clear_freeze_flag(current);
37         current->flags |= PF_FROZEN;
38         spin_unlock_irq(&freezer_lock);
39
40         save = current->state;
41         pr_debug("%s entered refrigerator\n", current->comm);
42
43         spin_lock_irq(&current->sighand->siglock);
44         recalc_sigpending(); /* We sent fake signal, clean it up */
45         spin_unlock_irq(&current->sighand->siglock);
46
47         for (;;) {
48                 set_current_state(TASK_UNINTERRUPTIBLE);
49                 if (!freezing(current) ||
50                     (check_kthr_stop && kthread_should_stop()))
51                         break;
52                 was_frozen = true;
53                 schedule();
54         }
55
56         /* leave FROZEN */
57         spin_lock_irq(&freezer_lock);
58         if (freezing(current))
59                 goto repeat;
60         current->flags &= ~PF_FROZEN;
61         spin_unlock_irq(&freezer_lock);
62
63         pr_debug("%s left refrigerator\n", current->comm);
64
65         /*
66          * Restore saved task state before returning.  The mb'd version
67          * needs to be used; otherwise, it might silently break
68          * synchronization which depends on ordered task state change.
69          */
70         set_current_state(save);
71
72         return was_frozen;
73 }
74 EXPORT_SYMBOL(__refrigerator);
75
76 static void fake_signal_wake_up(struct task_struct *p)
77 {
78         unsigned long flags;
79
80         spin_lock_irqsave(&p->sighand->siglock, flags);
81         signal_wake_up(p, 0);
82         spin_unlock_irqrestore(&p->sighand->siglock, flags);
83 }
84
85 /**
86  *      freeze_task - send a freeze request to given task
87  *      @p: task to send the request to
88  *      @sig_only: if set, the request will only be sent if the task has the
89  *              PF_FREEZER_NOSIG flag unset
90  *      Return value: 'false', if @sig_only is set and the task has
91  *              PF_FREEZER_NOSIG set or the task is frozen, 'true', otherwise
92  *
93  *      The freeze request is sent by setting the tasks's TIF_FREEZE flag and
94  *      either sending a fake signal to it or waking it up, depending on whether
95  *      or not it has PF_FREEZER_NOSIG set.  If @sig_only is set and the task
96  *      has PF_FREEZER_NOSIG set (ie. it is a typical kernel thread), its
97  *      TIF_FREEZE flag will not be set.
98  */
99 bool freeze_task(struct task_struct *p, bool sig_only)
100 {
101         unsigned long flags;
102         bool ret = false;
103
104         spin_lock_irqsave(&freezer_lock, flags);
105
106         if ((p->flags & PF_NOFREEZE) ||
107             (sig_only && !should_send_signal(p)))
108                 goto out_unlock;
109
110         if (frozen(p))
111                 goto out_unlock;
112
113         set_freeze_flag(p);
114
115         if (should_send_signal(p)) {
116                 fake_signal_wake_up(p);
117                 /*
118                  * fake_signal_wake_up() goes through p's scheduler
119                  * lock and guarantees that TASK_STOPPED/TRACED ->
120                  * TASK_RUNNING transition can't race with task state
121                  * testing in try_to_freeze_tasks().
122                  */
123         } else {
124                 wake_up_state(p, TASK_INTERRUPTIBLE);
125         }
126         ret = true;
127 out_unlock:
128         spin_unlock_irqrestore(&freezer_lock, flags);
129         return ret;
130 }
131
132 void cancel_freezing(struct task_struct *p)
133 {
134         unsigned long flags;
135
136         spin_lock_irqsave(&freezer_lock, flags);
137         if (freezing(p)) {
138                 pr_debug("  clean up: %s\n", p->comm);
139                 clear_freeze_flag(p);
140                 spin_lock(&p->sighand->siglock);
141                 recalc_sigpending_and_wake(p);
142                 spin_unlock(&p->sighand->siglock);
143         }
144         spin_unlock_irqrestore(&freezer_lock, flags);
145 }
146
147 void __thaw_task(struct task_struct *p)
148 {
149         unsigned long flags;
150
151         /*
152          * Clear freezing and kick @p if FROZEN.  Clearing is guaranteed to
153          * be visible to @p as waking up implies wmb.  Waking up inside
154          * freezer_lock also prevents wakeups from leaking outside
155          * refrigerator.
156          */
157         spin_lock_irqsave(&freezer_lock, flags);
158         clear_freeze_flag(p);
159         if (frozen(p))
160                 wake_up_process(p);
161         spin_unlock_irqrestore(&freezer_lock, flags);
162 }