kernel/freezer.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * kernel/freezer.c - Function to freeze a process
   4  *
   5  * Originally from kernel/power/process.c
   6  */
   7
   8 #include <linux/interrupt.h>
   9 #include <linux/suspend.h>
  10 #include <linux/export.h>
  11 #include <linux/syscalls.h>
  12 #include <linux/freezer.h>
  13 #include <linux/kthread.h>
  14
  15 /* total number of freezing conditions in effect */
  16 DEFINE_STATIC_KEY_FALSE(freezer_active);
  17 EXPORT_SYMBOL(freezer_active);
  18
  19 /*
  20  * indicate whether PM freezing is in effect, protected by
  21  * system_transition_mutex
  22  */
  23 bool pm_freezing;
  24 bool pm_nosig_freezing;
  25
  26 /* protects freezing and frozen transitions */
  27 static DEFINE_SPINLOCK(freezer_lock);
  28
  29 /**
  30  * freezing_slow_path - slow path for testing whether a task needs to be frozen
  31  * @p: task to be tested
  32  *
  33  * This function is called by freezing() if freezer_active isn't zero
  34  * and tests whether @p needs to enter and stay in frozen state.  Can be
  35  * called under any context.  The freezers are responsible for ensuring the
  36  * target tasks see the updated state.
  37  */
  38 bool freezing_slow_path(struct task_struct *p)
  39 {
  40         if (p->flags & (PF_NOFREEZE | PF_SUSPEND_TASK))
  41                 return false;
  42
  43         if (test_tsk_thread_flag(p, TIF_MEMDIE))
  44                 return false;
  45
  46         if (pm_nosig_freezing || cgroup_freezing(p))
  47                 return true;
  48
  49         if (pm_freezing && !(p->flags & PF_KTHREAD))
  50                 return true;
  51
  52         return false;
  53 }
  54 EXPORT_SYMBOL(freezing_slow_path);
  55
  56 bool frozen(struct task_struct *p)
  57 {
  58         return READ_ONCE(p->__state) & TASK_FROZEN;
  59 }
  60
  61 /* Refrigerator is place where frozen processes are stored :-). */
  62 bool __refrigerator(bool check_kthr_stop)
  63 {
  64         unsigned int state = get_current_state();
  65         bool was_frozen = false;
  66
  67         pr_debug("%s entered refrigerator\n", current->comm);
  68
  69         WARN_ON_ONCE(state && !(state & TASK_NORMAL));
  70
  71         for (;;) {
  72                 bool freeze;
  73
  74                 raw_spin_lock_irq(&current->pi_lock);
  75                 set_current_state(TASK_FROZEN);
  76                 /* unstale saved_state so that __thaw_task() will wake us up */
  77                 current->saved_state = TASK_RUNNING;
  78                 raw_spin_unlock_irq(&current->pi_lock);
  79
  80                 spin_lock_irq(&freezer_lock);
  81                 freeze = freezing(current) && !(check_kthr_stop && kthread_should_stop());
  82                 spin_unlock_irq(&freezer_lock);
  83
  84                 if (!freeze)
  85                         break;
  86
  87                 was_frozen = true;
  88                 schedule();
  89         }
  90         __set_current_state(TASK_RUNNING);
  91
  92         pr_debug("%s left refrigerator\n", current->comm);
  93
  94         return was_frozen;
  95 }
  96 EXPORT_SYMBOL(__refrigerator);
  97
  98 static void fake_signal_wake_up(struct task_struct *p)
  99 {
 100         unsigned long flags;
 101
 102         if (lock_task_sighand(p, &flags)) {
 103                 signal_wake_up(p, 0);
 104                 unlock_task_sighand(p, &flags);
 105         }
 106 }
 107
 108 static int __set_task_frozen(struct task_struct *p, void *arg)
 109 {
 110         unsigned int state = READ_ONCE(p->__state);
 111
 112         if (p->on_rq)
 113                 return 0;
 114
 115         if (p != current && task_curr(p))
 116                 return 0;
 117
 118         if (!(state & (TASK_FREEZABLE | __TASK_STOPPED | __TASK_TRACED)))
 119                 return 0;
 120
 121         /*
 122          * Only TASK_NORMAL can be augmented with TASK_FREEZABLE, since they
 123          * can suffer spurious wakeups.
 124          */
 125         if (state & TASK_FREEZABLE)
 126                 WARN_ON_ONCE(!(state & TASK_NORMAL));
 127
 128 #ifdef CONFIG_LOCKDEP
 129         /*
 130          * It's dangerous to freeze with locks held; there be dragons there.
 131          */
 132         if (!(state & __TASK_FREEZABLE_UNSAFE))
 133                 WARN_ON_ONCE(debug_locks && p->lockdep_depth);
 134 #endif
 135
 136         p->saved_state = p->__state;
 137         WRITE_ONCE(p->__state, TASK_FROZEN);
 138         return TASK_FROZEN;
 139 }
 140
 141 static bool __freeze_task(struct task_struct *p)
 142 {
 143         /* TASK_FREEZABLE|TASK_STOPPED|TASK_TRACED -> TASK_FROZEN */
 144         return task_call_func(p, __set_task_frozen, NULL);
 145 }
 146
 147 /**
 148  * freeze_task - send a freeze request to given task
 149  * @p: task to send the request to
 150  *
 151  * If @p is freezing, the freeze request is sent either by sending a fake
 152  * signal (if it's not a kernel thread) or waking it up (if it's a kernel
 153  * thread).
 154  *
 155  * RETURNS:
 156  * %false, if @p is not freezing or already frozen; %true, otherwise
 157  */
 158 bool freeze_task(struct task_struct *p)
 159 {
 160         unsigned long flags;
 161
 162         spin_lock_irqsave(&freezer_lock, flags);
 163         if (!freezing(p) || frozen(p) || __freeze_task(p)) {
 164                 spin_unlock_irqrestore(&freezer_lock, flags);
 165                 return false;
 166         }
 167
 168         if (!(p->flags & PF_KTHREAD))
 169                 fake_signal_wake_up(p);
 170         else
 171                 wake_up_state(p, TASK_NORMAL);
 172
 173         spin_unlock_irqrestore(&freezer_lock, flags);
 174         return true;
 175 }
 176
 177 /*
 178  * Restore the saved_state before the task entered freezer. For typical task
 179  * in the __refrigerator(), saved_state == TASK_RUNNING so nothing happens
 180  * here. For tasks which were TASK_NORMAL | TASK_FREEZABLE, their initial state
 181  * is restored unless they got an expected wakeup (see ttwu_state_match()).
 182  * Returns 1 if the task state was restored.
 183  */
 184 static int __restore_freezer_state(struct task_struct *p, void *arg)
 185 {
 186         unsigned int state = p->saved_state;
 187
 188         if (state != TASK_RUNNING) {
 189                 WRITE_ONCE(p->__state, state);
 190                 return 1;
 191         }
 192
 193         return 0;
 194 }
 195
 196 void __thaw_task(struct task_struct *p)
 197 {
 198         unsigned long flags;
 199
 200         spin_lock_irqsave(&freezer_lock, flags);
 201         if (WARN_ON_ONCE(freezing(p)))
 202                 goto unlock;
 203
 204         if (task_call_func(p, __restore_freezer_state, NULL))
 205                 goto unlock;
 206
 207         wake_up_state(p, TASK_FROZEN);
 208 unlock:
 209         spin_unlock_irqrestore(&freezer_lock, flags);
 210 }
 211
 212 /**
 213  * set_freezable - make %current freezable
 214  *
 215  * Mark %current freezable and enter refrigerator if necessary.
 216  */
 217 bool set_freezable(void)
 218 {
 219         might_sleep();
 220
 221         /*
 222          * Modify flags while holding freezer_lock.  This ensures the
 223          * freezer notices that we aren't frozen yet or the freezing
 224          * condition is visible to try_to_freeze() below.
 225          */
 226         spin_lock_irq(&freezer_lock);
 227         current->flags &= ~PF_NOFREEZE;
 228         spin_unlock_irq(&freezer_lock);
 229
 230         return try_to_freeze();
 231 }
 232 EXPORT_SYMBOL(set_freezable);