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 /* total number of freezing conditions in effect */
15 atomic_t system_freezing_cnt = ATOMIC_INIT(0);
16 EXPORT_SYMBOL(system_freezing_cnt);
17
18 /* indicate whether PM freezing is in effect, protected by pm_mutex */
19 bool pm_freezing;
20 bool pm_nosig_freezing;
21
22 /* protects freezing and frozen transitions */
23 static DEFINE_SPINLOCK(freezer_lock);
24
25 /**
26 * freezing_slow_path - slow path for testing whether a task needs to be frozen
27 * @p: task to be tested
28 *
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.
33 */
freezing_slow_path(struct task_struct * p)34 bool freezing_slow_path(struct task_struct *p)
35 {
36 if (p->flags & PF_NOFREEZE)
37 return false;
38
39 if (pm_nosig_freezing || cgroup_freezing(p))
40 return true;
41
42 if (pm_freezing && !(p->flags & PF_KTHREAD))
43 return true;
44
45 return false;
46 }
47 EXPORT_SYMBOL(freezing_slow_path);
48
49 /* Refrigerator is place where frozen processes are stored :-). */
__refrigerator(bool check_kthr_stop)50 bool __refrigerator(bool check_kthr_stop)
51 {
52 /* Hmm, should we be allowed to suspend when there are realtime
53 processes around? */
54 bool was_frozen = false;
55 long save = current->state;
56
57 pr_debug("%s entered refrigerator\n", current->comm);
58
59 for (;;) {
60 set_current_state(TASK_UNINTERRUPTIBLE);
61
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);
68
69 if (!(current->flags & PF_FROZEN))
70 break;
71 was_frozen = true;
72 schedule();
73 }
74
75 pr_debug("%s left refrigerator\n", current->comm);
76
77 /*
78 * Restore saved task state before returning. The mb'd version
79 * needs to be used; otherwise, it might silently break
80 * synchronization which depends on ordered task state change.
81 */
82 set_current_state(save);
83
84 return was_frozen;
85 }
86 EXPORT_SYMBOL(__refrigerator);
87
fake_signal_wake_up(struct task_struct * p)88 static void fake_signal_wake_up(struct task_struct *p)
89 {
90 unsigned long flags;
91
92 if (lock_task_sighand(p, &flags)) {
93 signal_wake_up(p, 0);
94 unlock_task_sighand(p, &flags);
95 }
96 }
97
98 /**
99 * freeze_task - send a freeze request to given task
100 * @p: task to send the request to
101 *
102 * If @p is freezing, the freeze request is sent either by sending a fake
103 * signal (if it's not a kernel thread) or waking it up (if it's a kernel
104 * thread).
105 *
106 * RETURNS:
107 * %false, if @p is not freezing or already frozen; %true, otherwise
108 */
freeze_task(struct task_struct * p)109 bool freeze_task(struct task_struct *p)
110 {
111 unsigned long flags;
112
113 /*
114 * This check can race with freezer_do_not_count, but worst case that
115 * will result in an extra wakeup being sent to the task. It does not
116 * race with freezer_count(), the barriers in freezer_count() and
117 * freezer_should_skip() ensure that either freezer_count() sees
118 * freezing == true in try_to_freeze() and freezes, or
119 * freezer_should_skip() sees !PF_FREEZE_SKIP and freezes the task
120 * normally.
121 */
122 if (freezer_should_skip(p))
123 return false;
124
125 spin_lock_irqsave(&freezer_lock, flags);
126 if (!freezing(p) || frozen(p)) {
127 spin_unlock_irqrestore(&freezer_lock, flags);
128 return false;
129 }
130
131 if (!(p->flags & PF_KTHREAD))
132 fake_signal_wake_up(p);
133 else
134 wake_up_state(p, TASK_INTERRUPTIBLE);
135
136 spin_unlock_irqrestore(&freezer_lock, flags);
137 return true;
138 }
139
__thaw_task(struct task_struct * p)140 void __thaw_task(struct task_struct *p)
141 {
142 unsigned long flags;
143
144 /*
145 * Clear freezing and kick @p if FROZEN. Clearing is guaranteed to
146 * be visible to @p as waking up implies wmb. Waking up inside
147 * freezer_lock also prevents wakeups from leaking outside
148 * refrigerator.
149 */
150 spin_lock_irqsave(&freezer_lock, flags);
151 if (frozen(p))
152 wake_up_process(p);
153 spin_unlock_irqrestore(&freezer_lock, flags);
154 }
155
156 /**
157 * set_freezable - make %current freezable
158 *
159 * Mark %current freezable and enter refrigerator if necessary.
160 */
set_freezable(void)161 bool set_freezable(void)
162 {
163 might_sleep();
164
165 /*
166 * Modify flags while holding freezer_lock. This ensures the
167 * freezer notices that we aren't frozen yet or the freezing
168 * condition is visible to try_to_freeze() below.
169 */
170 spin_lock_irq(&freezer_lock);
171 current->flags &= ~PF_NOFREEZE;
172 spin_unlock_irq(&freezer_lock);
173
174 return try_to_freeze();
175 }
176 EXPORT_SYMBOL(set_freezable);
177