2 * kernel/freezer.c - Function to freeze a process
4 * Originally from kernel/power/process.c
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>
14 /* total number of freezing conditions in effect */
15 atomic_t system_freezing_cnt
= ATOMIC_INIT(0);
16 EXPORT_SYMBOL(system_freezing_cnt
);
18 /* indicate whether PM freezing is in effect, protected by pm_mutex */
20 bool pm_nosig_freezing
;
22 /* protects freezing and frozen transitions */
23 static DEFINE_SPINLOCK(freezer_lock
);
26 * freezing_slow_path - slow path for testing whether a task needs to be frozen
27 * @p: task to be tested
29 * This function is called by freezing() if system_freezing_cnt isn't zero
30 * and tests whether @p needs to enter and stay in frozen state. Can be
31 * called under any context. The freezers are responsible for ensuring the
32 * target tasks see the updated state.
34 bool freezing_slow_path(struct task_struct
*p
)
36 if (p
->flags
& PF_NOFREEZE
)
39 if (pm_nosig_freezing
|| cgroup_freezing(p
))
42 if (pm_freezing
&& !(p
->flags
& PF_FREEZER_NOSIG
))
47 EXPORT_SYMBOL(freezing_slow_path
);
49 /* Refrigerator is place where frozen processes are stored :-). */
50 bool __refrigerator(bool check_kthr_stop
)
52 /* Hmm, should we be allowed to suspend when there are realtime
54 bool was_frozen
= false;
55 long save
= current
->state
;
57 pr_debug("%s entered refrigerator\n", current
->comm
);
60 set_current_state(TASK_UNINTERRUPTIBLE
);
62 spin_lock_irq(&freezer_lock
);
63 current
->flags
|= PF_FROZEN
;
64 if (!freezing(current
) ||
65 (check_kthr_stop
&& kthread_should_stop()))
66 current
->flags
&= ~PF_FROZEN
;
67 spin_unlock_irq(&freezer_lock
);
69 if (!(current
->flags
& PF_FROZEN
))
75 spin_lock_irq(¤t
->sighand
->siglock
);
76 recalc_sigpending(); /* We sent fake signal, clean it up */
77 spin_unlock_irq(¤t
->sighand
->siglock
);
79 pr_debug("%s left refrigerator\n", current
->comm
);
82 * Restore saved task state before returning. The mb'd version
83 * needs to be used; otherwise, it might silently break
84 * synchronization which depends on ordered task state change.
86 set_current_state(save
);
90 EXPORT_SYMBOL(__refrigerator
);
92 static void fake_signal_wake_up(struct task_struct
*p
)
96 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
98 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
102 * freeze_task - send a freeze request to given task
103 * @p: task to send the request to
104 * @sig_only: if set, the request will only be sent if the task has the
105 * PF_FREEZER_NOSIG flag unset
106 * Return value: 'false', if @sig_only is set and the task has
107 * PF_FREEZER_NOSIG set or the task is frozen, 'true', otherwise
109 * The freeze request is sent by setting the tasks's TIF_FREEZE flag and
110 * either sending a fake signal to it or waking it up, depending on whether
111 * or not it has PF_FREEZER_NOSIG set. If @sig_only is set and the task
112 * has PF_FREEZER_NOSIG set (ie. it is a typical kernel thread), its
113 * TIF_FREEZE flag will not be set.
115 bool freeze_task(struct task_struct
*p
, bool sig_only
)
119 spin_lock_irqsave(&freezer_lock
, flags
);
120 if (!freezing(p
) || frozen(p
)) {
121 spin_unlock_irqrestore(&freezer_lock
, flags
);
125 if (!(p
->flags
& PF_FREEZER_NOSIG
)) {
126 fake_signal_wake_up(p
);
128 * fake_signal_wake_up() goes through p's scheduler
129 * lock and guarantees that TASK_STOPPED/TRACED ->
130 * TASK_RUNNING transition can't race with task state
131 * testing in try_to_freeze_tasks().
134 wake_up_state(p
, TASK_INTERRUPTIBLE
);
137 spin_unlock_irqrestore(&freezer_lock
, flags
);
141 void __thaw_task(struct task_struct
*p
)
146 * Clear freezing and kick @p if FROZEN. Clearing is guaranteed to
147 * be visible to @p as waking up implies wmb. Waking up inside
148 * freezer_lock also prevents wakeups from leaking outside
151 * If !FROZEN, @p hasn't reached refrigerator, recalc sigpending to
152 * avoid leaving dangling TIF_SIGPENDING behind.
154 spin_lock_irqsave(&freezer_lock
, flags
);
158 spin_lock(&p
->sighand
->siglock
);
159 recalc_sigpending_and_wake(p
);
160 spin_unlock(&p
->sighand
->siglock
);
162 spin_unlock_irqrestore(&freezer_lock
, flags
);
166 * __set_freezable - make %current freezable
167 * @with_signal: do we want %TIF_SIGPENDING for notification too?
169 * Mark %current freezable and enter refrigerator if necessary.
171 bool __set_freezable(bool with_signal
)
176 * Modify flags while holding freezer_lock. This ensures the
177 * freezer notices that we aren't frozen yet or the freezing
178 * condition is visible to try_to_freeze() below.
180 spin_lock_irq(&freezer_lock
);
181 current
->flags
&= ~PF_NOFREEZE
;
183 current
->flags
&= ~PF_FREEZER_NOSIG
;
184 spin_unlock_irq(&freezer_lock
);
186 return try_to_freeze();
188 EXPORT_SYMBOL(__set_freezable
);