LXR linux/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 */
  16atomic_t system_freezing_cnt = ATOMIC_INIT(0);
  17EXPORT_SYMBOL(system_freezing_cnt);
  18
  19/* indicate whether PM freezing is in effect, protected by
  20 * system_transition_mutex
  21 */
  22bool pm_freezing;
  23bool pm_nosig_freezing;
  24
  25/* protects freezing and frozen transitions */
  26static DEFINE_SPINLOCK(freezer_lock);
  27
  28/**
  29 * freezing_slow_path - slow path for testing whether a task needs to be frozen
  30 * @p: task to be tested
  31 *
  32 * This function is called by freezing() if system_freezing_cnt isn't zero
  33 * and tests whether @p needs to enter and stay in frozen state.  Can be
  34 * called under any context.  The freezers are responsible for ensuring the
  35 * target tasks see the updated state.
  36 */
  37bool freezing_slow_path(struct task_struct *p)
  38{
  39        if (p->flags & (PF_NOFREEZE | PF_SUSPEND_TASK))
  40                return false;
  41
  42        if (test_tsk_thread_flag(p, TIF_MEMDIE))
  43                return false;
  44
  45        if (pm_nosig_freezing || cgroup_freezing(p))
  46                return true;
  47
  48        if (pm_freezing && !(p->flags & PF_KTHREAD))
  49                return true;
  50
  51        return false;
  52}
  53EXPORT_SYMBOL(freezing_slow_path);
  54
  55/* Refrigerator is place where frozen processes are stored :-). */
  56bool __refrigerator(bool check_kthr_stop)
  57{
  58        /* Hmm, should we be allowed to suspend when there are realtime
  59           processes around? */
  60        bool was_frozen = false;
  61        unsigned int save = get_current_state();
  62
  63        pr_debug("%s entered refrigerator\n", current->comm);
  64
  65        for (;;) {
  66                set_current_state(TASK_UNINTERRUPTIBLE);
  67
  68                spin_lock_irq(&freezer_lock);
  69                current->flags |= PF_FROZEN;
  70                if (!freezing(current) ||
  71                    (check_kthr_stop && kthread_should_stop()))
  72                        current->flags &= ~PF_FROZEN;
  73                spin_unlock_irq(&freezer_lock);
  74
  75                if (!(current->flags & PF_FROZEN))
  76                        break;
  77                was_frozen = true;
  78                schedule();
  79        }
  80
  81        pr_debug("%s left refrigerator\n", current->comm);
  82
  83        /*
  84         * Restore saved task state before returning.  The mb'd version
  85         * needs to be used; otherwise, it might silently break
  86         * synchronization which depends on ordered task state change.
  87         */
  88        set_current_state(save);
  89
  90        return was_frozen;
  91}
  92EXPORT_SYMBOL(__refrigerator);
  93
  94static void fake_signal_wake_up(struct task_struct *p)
  95{
  96        unsigned long flags;
  97
  98        if (lock_task_sighand(p, &flags)) {
  99                signal_wake_up(p, 0);
 100                unlock_task_sighand(p, &flags);
 101        }
 102}
 103
 104/**
 105 * freeze_task - send a freeze request to given task
 106 * @p: task to send the request to
 107 *
 108 * If @p is freezing, the freeze request is sent either by sending a fake
 109 * signal (if it's not a kernel thread) or waking it up (if it's a kernel
 110 * thread).
 111 *
 112 * RETURNS:
 113 * %false, if @p is not freezing or already frozen; %true, otherwise
 114 */
 115bool freeze_task(struct task_struct *p)
 116{
 117        unsigned long flags;
 118
 119        /*
 120         * This check can race with freezer_do_not_count, but worst case that
 121         * will result in an extra wakeup being sent to the task.  It does not
 122         * race with freezer_count(), the barriers in freezer_count() and
 123         * freezer_should_skip() ensure that either freezer_count() sees
 124         * freezing == true in try_to_freeze() and freezes, or
 125         * freezer_should_skip() sees !PF_FREEZE_SKIP and freezes the task
 126         * normally.
 127         */
 128        if (freezer_should_skip(p))
 129                return false;
 130
 131        spin_lock_irqsave(&freezer_lock, flags);
 132        if (!freezing(p) || frozen(p)) {
 133                spin_unlock_irqrestore(&freezer_lock, flags);
 134                return false;
 135        }
 136
 137        if (!(p->flags & PF_KTHREAD))
 138                fake_signal_wake_up(p);
 139        else
 140                wake_up_state(p, TASK_INTERRUPTIBLE);
 141
 142        spin_unlock_irqrestore(&freezer_lock, flags);
 143        return true;
 144}
 145
 146void __thaw_task(struct task_struct *p)
 147{
 148        unsigned long flags;
 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 */
 161bool 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}
 176EXPORT_SYMBOL(set_freezable);
 177