freezer.c 4.45 KB
Newer Older
1 2 3 4 5 6 7 8
/*
 * kernel/freezer.c - Function to freeze a process
 *
 * Originally from kernel/power/process.c
 */

#include <linux/interrupt.h>
#include <linux/suspend.h>
9
#include <linux/export.h>
10 11
#include <linux/syscalls.h>
#include <linux/freezer.h>
12
#include <linux/kthread.h>
13

14 15 16 17 18 19 20 21
/* total number of freezing conditions in effect */
atomic_t system_freezing_cnt = ATOMIC_INIT(0);
EXPORT_SYMBOL(system_freezing_cnt);

/* indicate whether PM freezing is in effect, protected by pm_mutex */
bool pm_freezing;
bool pm_nosig_freezing;

22 23
/* protects freezing and frozen transitions */
static DEFINE_SPINLOCK(freezer_lock);
24

25 26 27 28 29 30 31 32 33 34 35
/**
 * freezing_slow_path - slow path for testing whether a task needs to be frozen
 * @p: task to be tested
 *
 * This function is called by freezing() if system_freezing_cnt isn't zero
 * and tests whether @p needs to enter and stay in frozen state.  Can be
 * called under any context.  The freezers are responsible for ensuring the
 * target tasks see the updated state.
 */
bool freezing_slow_path(struct task_struct *p)
{
36
	if (p->flags & (PF_NOFREEZE | PF_SUSPEND_TASK))
37 38 39 40 41
		return false;

	if (pm_nosig_freezing || cgroup_freezing(p))
		return true;

42
	if (pm_freezing && !(p->flags & PF_KTHREAD))
43 44 45 46 47 48
		return true;

	return false;
}
EXPORT_SYMBOL(freezing_slow_path);

49
/* Refrigerator is place where frozen processes are stored :-). */
50
bool __refrigerator(bool check_kthr_stop)
51 52 53
{
	/* Hmm, should we be allowed to suspend when there are realtime
	   processes around? */
54
	bool was_frozen = false;
55
	long save = current->state;
56 57 58 59 60

	pr_debug("%s entered refrigerator\n", current->comm);

	for (;;) {
		set_current_state(TASK_UNINTERRUPTIBLE);
61 62 63

		spin_lock_irq(&freezer_lock);
		current->flags |= PF_FROZEN;
64
		if (!freezing(current) ||
65
		    (check_kthr_stop && kthread_should_stop()))
66 67 68 69
			current->flags &= ~PF_FROZEN;
		spin_unlock_irq(&freezer_lock);

		if (!(current->flags & PF_FROZEN))
70
			break;
71
		was_frozen = true;
72 73
		schedule();
	}
74

75
	pr_debug("%s left refrigerator\n", current->comm);
76 77 78 79 80 81 82

	/*
	 * Restore saved task state before returning.  The mb'd version
	 * needs to be used; otherwise, it might silently break
	 * synchronization which depends on ordered task state change.
	 */
	set_current_state(save);
83 84

	return was_frozen;
85
}
86
EXPORT_SYMBOL(__refrigerator);
87 88 89 90 91

static void fake_signal_wake_up(struct task_struct *p)
{
	unsigned long flags;

92 93 94 95
	if (lock_task_sighand(p, &flags)) {
		signal_wake_up(p, 0);
		unlock_task_sighand(p, &flags);
	}
96 97 98
}

/**
99 100
 * freeze_task - send a freeze request to given task
 * @p: task to send the request to
101
 *
102 103 104
 * If @p is freezing, the freeze request is sent either by sending a fake
 * signal (if it's not a kernel thread) or waking it up (if it's a kernel
 * thread).
105 106 107
 *
 * RETURNS:
 * %false, if @p is not freezing or already frozen; %true, otherwise
108
 */
109
bool freeze_task(struct task_struct *p)
110
{
111 112
	unsigned long flags;

113 114 115 116 117 118 119 120 121 122 123 124
	/*
	 * This check can race with freezer_do_not_count, but worst case that
	 * will result in an extra wakeup being sent to the task.  It does not
	 * race with freezer_count(), the barriers in freezer_count() and
	 * freezer_should_skip() ensure that either freezer_count() sees
	 * freezing == true in try_to_freeze() and freezes, or
	 * freezer_should_skip() sees !PF_FREEZE_SKIP and freezes the task
	 * normally.
	 */
	if (freezer_should_skip(p))
		return false;

125
	spin_lock_irqsave(&freezer_lock, flags);
126 127 128 129
	if (!freezing(p) || frozen(p)) {
		spin_unlock_irqrestore(&freezer_lock, flags);
		return false;
	}
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
}

140
void __thaw_task(struct task_struct *p)
141
{
142
	unsigned long flags;
143

144 145 146 147 148 149
	/*
	 * Clear freezing and kick @p if FROZEN.  Clearing is guaranteed to
	 * be visible to @p as waking up implies wmb.  Waking up inside
	 * freezer_lock also prevents wakeups from leaking outside
	 * refrigerator.
	 */
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 160
 *
 * Mark %current freezable and enter refrigerator if necessary.
 */
161
bool set_freezable(void)
162 163 164 165 166 167 168 169 170 171 172 173 174 175
{
	might_sleep();

	/*
	 * Modify flags while holding freezer_lock.  This ensures the
	 * freezer notices that we aren't frozen yet or the freezing
	 * condition is visible to try_to_freeze() below.
	 */
	spin_lock_irq(&freezer_lock);
	current->flags &= ~PF_NOFREEZE;
	spin_unlock_irq(&freezer_lock);

	return try_to_freeze();
}
176
EXPORT_SYMBOL(set_freezable);