text: /* SPDX-License-Identifier: GPL-2.0 */
  /* Freezer declarations */
  
  #ifndef FREEZER_H_INCLUDED
  #define FREEZER_H_INCLUDED
  
  #include <linux/debug_locks.h>
  #include <linux/sched.h>
  #include <linux/wait.h>
  #include <linux/atomic.h>
  
  #ifdef CONFIG_FREEZER
  extern atomic_t system_freezing_cnt;	/* nr of freezing conds in effect */
  extern bool pm_freezing;		/* PM freezing in effect */
  extern bool pm_nosig_freezing;		/* PM nosig freezing in effect */
  
  /*
   * Timeout for stopping processes
   */
  extern unsigned int freeze_timeout_msecs;
  
  /*
   * Check if a process has been frozen
   */
  static inline bool frozen(struct task_struct *p)
  {
  	return p->flags & PF_FROZEN;
  }
  
  extern bool freezing_slow_path(struct task_struct *p);
  
  /*
   * Check if there is a request to freeze a process
   */
  static inline bool freezing(struct task_struct *p)
  {
  	if (likely(!atomic_read(&system_freezing_cnt)))
  		return false;
  	return freezing_slow_path(p);
  }
  
  /* Takes and releases task alloc lock using task_lock() */
  extern void __thaw_task(struct task_struct *t);
  
  extern bool __refrigerator(bool check_kthr_stop);
  extern int freeze_processes(void);
  extern int freeze_kernel_threads(void);
  extern void thaw_processes(void);
  extern void thaw_kernel_threads(void);
  
  /*
   * DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION
   * If try_to_freeze causes a lockdep warning it means the caller may deadlock
   */
  static inline bool try_to_freeze_unsafe(void)
  {
  	might_sleep();
  	if (likely(!freezing(current)))
  		return false;
  	return __refrigerator(false);
  }
  
  static inline bool try_to_freeze(void)
  {
  	if (!(current->flags & PF_NOFREEZE))
  		debug_check_no_locks_held();
  	return try_to_freeze_unsafe();
  }
  
  extern bool freeze_task(struct task_struct *p);
  extern bool set_freezable(void);
  
  #ifdef CONFIG_CGROUP_FREEZER
  extern bool cgroup_freezing(struct task_struct *task);
  #else /* !CONFIG_CGROUP_FREEZER */
  static inline bool cgroup_freezing(struct task_struct *task)
  {
  	return false;
  }
  #endif /* !CONFIG_CGROUP_FREEZER */
  
  /*
   * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
   * calls wait_for_completion(&vfork) and reset right after it returns from this
   * function.  Next, the parent should call try_to_freeze() to freeze itself
   * appropriately in case the child has exited before the freezing of tasks is
   * complete.  However, we don't want kernel threads to be frozen in unexpected
   * places, so we allow them to block freeze_processes() instead or to set
   * PF_NOFREEZE if needed. Fortunately, in the ____call_usermodehelper() case the
   * parent won't really block freeze_processes(), since ____call_usermodehelper()
   * (the child) does a little before exec/exit and it can't be frozen before
   * waking up the parent.
   */
  
  
  /**
   * freezer_do_not_count - tell freezer to ignore %current
   *
   * Tell freezers to ignore the current task when determining whether the
   * target frozen state is reached.  IOW, the current task will be
   * considered frozen enough by freezers.
   *
   * The caller shouldn't do anything which isn't allowed for a frozen task
   * until freezer_cont() is called.  Usually, freezer[_do_not]_count() pair
   * wrap a scheduling operation and nothing much else.
   */
  static inline void freezer_do_not_count(void)
  {
  	current->flags |= PF_FREEZER_SKIP;
  }
  
  /**
   * freezer_count - tell freezer to stop ignoring %current
   *
   * Undo freezer_do_not_count().  It tells freezers that %current should be
   * considered again and tries to freeze if freezing condition is already in
   * effect.
   */
  static inline void freezer_count(void)
  {
  	current->flags &= ~PF_FREEZER_SKIP;
  	/*
  	 * If freezing is in progress, the following paired with smp_mb()
  	 * in freezer_should_skip() ensures that either we see %true
  	 * freezing() or freezer_should_skip() sees !PF_FREEZER_SKIP.
  	 */
  	smp_mb();
  	try_to_freeze();
  }
  
  /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
  static inline void freezer_count_unsafe(void)
  {
  	current->flags &= ~PF_FREEZER_SKIP;
  	smp_mb();
  	try_to_freeze_unsafe();
  }
  
  /**
   * freezer_should_skip - whether to skip a task when determining frozen
   *			 state is reached
   * @p: task in quesion
   *
   * This function is used by freezers after establishing %true freezing() to
   * test whether a task should be skipped when determining the target frozen
   * state is reached.  IOW, if this function returns %true, @p is considered
   * frozen enough.
   */
  static inline bool freezer_should_skip(struct task_struct *p)
  {
  	/*
  	 * The following smp_mb() paired with the one in freezer_count()
  	 * ensures that either freezer_count() sees %true freezing() or we
  	 * see cleared %PF_FREEZER_SKIP and return %false.  This makes it
  	 * impossible for a task to slip frozen state testing after
  	 * clearing %PF_FREEZER_SKIP.
  	 */
  	smp_mb();
  	return p->flags & PF_FREEZER_SKIP;
  }
  
  /*
   * These functions are intended to be used whenever you want allow a sleeping
   * task to be frozen. Note that neither return any clear indication of
   * whether a freeze event happened while in this function.
   */
  
  /* Like schedule(), but should not block the freezer. */
  static inline void freezable_schedule(void)
  {
  	freezer_do_not_count();
  	schedule();
  	freezer_count();
  }
  
  /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
  static inline void freezable_schedule_unsafe(void)
  {
  	freezer_do_not_count();
  	schedule();
  	freezer_count_unsafe();
  }
  
  /*
   * Like schedule_timeout(), but should not block the freezer.  Do not
   * call this with locks held.
   */
  static inline long freezable_schedule_timeout(long timeout)
  {
  	long __retval;
  	freezer_do_not_count();
  	__retval = schedule_timeout(timeout);
  	freezer_count();
  	return __retval;
  }
  
  /*
   * Like schedule_timeout_interruptible(), but should not block the freezer.  Do not
   * call this with locks held.
   */
  static inline long freezable_schedule_timeout_interruptible(long timeout)
  {
  	long __retval;
  	freezer_do_not_count();
  	__retval = schedule_timeout_interruptible(timeout);
  	freezer_count();
  	return __retval;
  }
  
  /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
  static inline long freezable_schedule_timeout_interruptible_unsafe(long timeout)
  {
  	long __retval;
  
  	freezer_do_not_count();
  	__retval = schedule_timeout_interruptible(timeout);
  	freezer_count_unsafe();
  	return __retval;
  }
  
  /* Like schedule_timeout_killable(), but should not block the freezer. */
  static inline long freezable_schedule_timeout_killable(long timeout)
  {
  	long __retval;
  	freezer_do_not_count();
  	__retval = schedule_timeout_killable(timeout);
  	freezer_count();
  	return __retval;
  }
  
  /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
  static inline long freezable_schedule_timeout_killable_unsafe(long timeout)
  {
  	long __retval;
  	freezer_do_not_count();
  	__retval = schedule_timeout_killable(timeout);
  	freezer_count_unsafe();
  	return __retval;
  }
  
  /*
   * Like schedule_hrtimeout_range(), but should not block the freezer.  Do not
   * call this with locks held.
   */
  static inline int freezable_schedule_hrtimeout_range(ktime_t *expires,
  		u64 delta, const enum hrtimer_mode mode)
  {
  	int __retval;
  	freezer_do_not_count();
  	__retval = schedule_hrtimeout_range(expires, delta, mode);
  	freezer_count();
  	return __retval;
  }
  
  /*
   * Freezer-friendly wrappers around wait_event_interruptible(),
   * wait_event_killable() and wait_event_interruptible_timeout(), originally
   * defined in <linux/wait.h>
   */
  
  /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
  #define wait_event_freezekillable_unsafe(wq, condition)			\
  ({									\
  	int __retval;							\
  	freezer_do_not_count();						\
  	__retval = wait_event_killable(wq, (condition));		\
  	freezer_count_unsafe();						\
  	__retval;							\
  })
  
  #else /* !CONFIG_FREEZER */
  static inline bool frozen(struct task_struct *p) { return false; }
  static inline bool freezing(struct task_struct *p) { return false; }
  static inline void __thaw_task(struct task_struct *t) {}
  
  static inline bool __refrigerator(bool check_kthr_stop) { return false; }
  static inline int freeze_processes(void) { return -ENOSYS; }
  static inline int freeze_kernel_threads(void) { return -ENOSYS; }
  static inline void thaw_processes(void) {}
  static inline void thaw_kernel_threads(void) {}
  
  static inline bool try_to_freeze(void) { return false; }
  
  static inline void freezer_do_not_count(void) {}
  static inline void freezer_count(void) {}
  static inline int freezer_should_skip(struct task_struct *p) { return 0; }
  static inline void set_freezable(void) {}
  
  #define freezable_schedule()  schedule()
  
  #define freezable_schedule_unsafe()  schedule()
  
  #define freezable_schedule_timeout(timeout)  schedule_timeout(timeout)
  
  #define freezable_schedule_timeout_interruptible(timeout)		\
  	schedule_timeout_interruptible(timeout)
  
  #define freezable_schedule_timeout_interruptible_unsafe(timeout)	\
  	schedule_timeout_interruptible(timeout)
  
  #define freezable_schedule_timeout_killable(timeout)			\
  	schedule_timeout_killable(timeout)
  
  #define freezable_schedule_timeout_killable_unsafe(timeout)		\
  	schedule_timeout_killable(timeout)
  
  #define freezable_schedule_hrtimeout_range(expires, delta, mode)	\
  	schedule_hrtimeout_range(expires, delta, mode)
  
  #define wait_event_freezekillable_unsafe(wq, condition)			\
  		wait_event_killable(wq, condition)
  
  #endif /* !CONFIG_FREEZER */
  
  #endif	/* FREEZER_H_INCLUDED */
  