Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 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> |
Paul Gortmaker | 9984de1 | 2011-05-23 14:51:41 -0400 | [diff] [blame] | 9 | #include <linux/export.h> |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 10 | #include <linux/syscalls.h> |
| 11 | #include <linux/freezer.h> |
Tejun Heo | 8a32c44 | 2011-11-21 12:32:23 -0800 | [diff] [blame] | 12 | #include <linux/kthread.h> |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 13 | |
Tejun Heo | a320122 | 2011-11-21 12:32:25 -0800 | [diff] [blame] | 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 | |
Tejun Heo | 0c9af09 | 2011-11-21 12:32:24 -0800 | [diff] [blame] | 22 | /* protects freezing and frozen transitions */ |
| 23 | static DEFINE_SPINLOCK(freezer_lock); |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 24 | |
Tejun Heo | a320122 | 2011-11-21 12:32:25 -0800 | [diff] [blame] | 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 | */ |
| 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 | |
Tejun Heo | 34b087e | 2011-11-23 09:28:17 -0800 | [diff] [blame] | 42 | if (pm_freezing && !(p->flags & PF_KTHREAD)) |
Tejun Heo | a320122 | 2011-11-21 12:32:25 -0800 | [diff] [blame] | 43 | return true; |
| 44 | |
| 45 | return false; |
| 46 | } |
| 47 | EXPORT_SYMBOL(freezing_slow_path); |
| 48 | |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 49 | /* Refrigerator is place where frozen processes are stored :-). */ |
Tejun Heo | 8a32c44 | 2011-11-21 12:32:23 -0800 | [diff] [blame] | 50 | bool __refrigerator(bool check_kthr_stop) |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 51 | { |
| 52 | /* Hmm, should we be allowed to suspend when there are realtime |
| 53 | processes around? */ |
Tejun Heo | a0acae0 | 2011-11-21 12:32:22 -0800 | [diff] [blame] | 54 | bool was_frozen = false; |
Tejun Heo | 5ece3ea | 2011-11-21 12:32:26 -0800 | [diff] [blame] | 55 | long save = current->state; |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 56 | |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 57 | pr_debug("%s entered refrigerator\n", current->comm); |
| 58 | |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 59 | for (;;) { |
| 60 | set_current_state(TASK_UNINTERRUPTIBLE); |
Tejun Heo | 5ece3ea | 2011-11-21 12:32:26 -0800 | [diff] [blame] | 61 | |
| 62 | spin_lock_irq(&freezer_lock); |
| 63 | current->flags |= PF_FROZEN; |
Tejun Heo | 6907483 | 2011-11-21 12:32:24 -0800 | [diff] [blame] | 64 | if (!freezing(current) || |
Tejun Heo | 8a32c44 | 2011-11-21 12:32:23 -0800 | [diff] [blame] | 65 | (check_kthr_stop && kthread_should_stop())) |
Tejun Heo | 5ece3ea | 2011-11-21 12:32:26 -0800 | [diff] [blame] | 66 | current->flags &= ~PF_FROZEN; |
| 67 | spin_unlock_irq(&freezer_lock); |
| 68 | |
| 69 | if (!(current->flags & PF_FROZEN)) |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 70 | break; |
Tejun Heo | a0acae0 | 2011-11-21 12:32:22 -0800 | [diff] [blame] | 71 | was_frozen = true; |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 72 | schedule(); |
| 73 | } |
Thomas Gleixner | 6301cb9 | 2009-07-17 14:15:47 +0200 | [diff] [blame] | 74 | |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 75 | pr_debug("%s left refrigerator\n", current->comm); |
Tejun Heo | 50fb4f7 | 2011-11-21 12:32:22 -0800 | [diff] [blame] | 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); |
Tejun Heo | a0acae0 | 2011-11-21 12:32:22 -0800 | [diff] [blame] | 83 | |
| 84 | return was_frozen; |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 85 | } |
Tejun Heo | a0acae0 | 2011-11-21 12:32:22 -0800 | [diff] [blame] | 86 | EXPORT_SYMBOL(__refrigerator); |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 87 | |
| 88 | static void fake_signal_wake_up(struct task_struct *p) |
| 89 | { |
| 90 | unsigned long flags; |
| 91 | |
Tejun Heo | 37ad8ac | 2011-11-21 12:32:26 -0800 | [diff] [blame] | 92 | if (lock_task_sighand(p, &flags)) { |
| 93 | signal_wake_up(p, 0); |
| 94 | unlock_task_sighand(p, &flags); |
| 95 | } |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 96 | } |
| 97 | |
| 98 | /** |
Tejun Heo | 839e340 | 2011-11-21 12:32:26 -0800 | [diff] [blame] | 99 | * freeze_task - send a freeze request to given task |
| 100 | * @p: task to send the request to |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 101 | * |
Tejun Heo | 839e340 | 2011-11-21 12:32:26 -0800 | [diff] [blame] | 102 | * If @p is freezing, the freeze request is sent by setting %TIF_FREEZE |
| 103 | * flag and either sending a fake signal to it or waking it up, depending |
| 104 | * on whether it has %PF_FREEZER_NOSIG set. |
| 105 | * |
| 106 | * RETURNS: |
| 107 | * %false, if @p is not freezing or already frozen; %true, otherwise |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 108 | */ |
Tejun Heo | 839e340 | 2011-11-21 12:32:26 -0800 | [diff] [blame] | 109 | bool freeze_task(struct task_struct *p) |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 110 | { |
Tejun Heo | 0c9af09 | 2011-11-21 12:32:24 -0800 | [diff] [blame] | 111 | unsigned long flags; |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 112 | |
Tejun Heo | 0c9af09 | 2011-11-21 12:32:24 -0800 | [diff] [blame] | 113 | spin_lock_irqsave(&freezer_lock, flags); |
Tejun Heo | a320122 | 2011-11-21 12:32:25 -0800 | [diff] [blame] | 114 | if (!freezing(p) || frozen(p)) { |
| 115 | spin_unlock_irqrestore(&freezer_lock, flags); |
| 116 | return false; |
| 117 | } |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 118 | |
Tejun Heo | 34b087e | 2011-11-23 09:28:17 -0800 | [diff] [blame] | 119 | if (!(p->flags & PF_KTHREAD)) { |
Tejun Heo | 8cfe400 | 2010-11-26 23:07:27 +0100 | [diff] [blame] | 120 | fake_signal_wake_up(p); |
| 121 | /* |
| 122 | * fake_signal_wake_up() goes through p's scheduler |
| 123 | * lock and guarantees that TASK_STOPPED/TRACED -> |
| 124 | * TASK_RUNNING transition can't race with task state |
| 125 | * testing in try_to_freeze_tasks(). |
| 126 | */ |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 127 | } else { |
| 128 | wake_up_state(p, TASK_INTERRUPTIBLE); |
| 129 | } |
Tejun Heo | a320122 | 2011-11-21 12:32:25 -0800 | [diff] [blame] | 130 | |
Tejun Heo | 0c9af09 | 2011-11-21 12:32:24 -0800 | [diff] [blame] | 131 | spin_unlock_irqrestore(&freezer_lock, flags); |
Tejun Heo | a320122 | 2011-11-21 12:32:25 -0800 | [diff] [blame] | 132 | return true; |
Matt Helsley | 8174f15 | 2008-10-18 20:27:19 -0700 | [diff] [blame] | 133 | } |
| 134 | |
Tejun Heo | a5be2d0 | 2011-11-21 12:32:23 -0800 | [diff] [blame] | 135 | void __thaw_task(struct task_struct *p) |
Matt Helsley | dc52ddc | 2008-10-18 20:27:21 -0700 | [diff] [blame] | 136 | { |
Tejun Heo | 0c9af09 | 2011-11-21 12:32:24 -0800 | [diff] [blame] | 137 | unsigned long flags; |
Tejun Heo | a5be2d0 | 2011-11-21 12:32:23 -0800 | [diff] [blame] | 138 | |
Tejun Heo | 6907483 | 2011-11-21 12:32:24 -0800 | [diff] [blame] | 139 | /* |
| 140 | * Clear freezing and kick @p if FROZEN. Clearing is guaranteed to |
| 141 | * be visible to @p as waking up implies wmb. Waking up inside |
| 142 | * freezer_lock also prevents wakeups from leaking outside |
| 143 | * refrigerator. |
| 144 | */ |
Tejun Heo | 0c9af09 | 2011-11-21 12:32:24 -0800 | [diff] [blame] | 145 | spin_lock_irqsave(&freezer_lock, flags); |
Tejun Heo | 34b087e | 2011-11-23 09:28:17 -0800 | [diff] [blame] | 146 | if (frozen(p)) |
Tejun Heo | a5be2d0 | 2011-11-21 12:32:23 -0800 | [diff] [blame] | 147 | wake_up_process(p); |
Tejun Heo | 0c9af09 | 2011-11-21 12:32:24 -0800 | [diff] [blame] | 148 | spin_unlock_irqrestore(&freezer_lock, flags); |
Matt Helsley | dc52ddc | 2008-10-18 20:27:21 -0700 | [diff] [blame] | 149 | } |
Tejun Heo | 96ee6d8 | 2011-11-21 12:32:25 -0800 | [diff] [blame] | 150 | |
| 151 | /** |
Tejun Heo | 34b087e | 2011-11-23 09:28:17 -0800 | [diff] [blame] | 152 | * set_freezable - make %current freezable |
Tejun Heo | 96ee6d8 | 2011-11-21 12:32:25 -0800 | [diff] [blame] | 153 | * |
| 154 | * Mark %current freezable and enter refrigerator if necessary. |
| 155 | */ |
Tejun Heo | 34b087e | 2011-11-23 09:28:17 -0800 | [diff] [blame] | 156 | bool set_freezable(void) |
Tejun Heo | 96ee6d8 | 2011-11-21 12:32:25 -0800 | [diff] [blame] | 157 | { |
| 158 | might_sleep(); |
| 159 | |
| 160 | /* |
| 161 | * Modify flags while holding freezer_lock. This ensures the |
| 162 | * freezer notices that we aren't frozen yet or the freezing |
| 163 | * condition is visible to try_to_freeze() below. |
| 164 | */ |
| 165 | spin_lock_irq(&freezer_lock); |
| 166 | current->flags &= ~PF_NOFREEZE; |
Tejun Heo | 96ee6d8 | 2011-11-21 12:32:25 -0800 | [diff] [blame] | 167 | spin_unlock_irq(&freezer_lock); |
| 168 | |
| 169 | return try_to_freeze(); |
| 170 | } |
Tejun Heo | 34b087e | 2011-11-23 09:28:17 -0800 | [diff] [blame] | 171 | EXPORT_SYMBOL(set_freezable); |