LXR linux/include/linux/freezer.h

   1/* Freezer declarations */
   2
   3#ifndef FREEZER_H_INCLUDED
   4#define FREEZER_H_INCLUDED
   5
   6#include <linux/sched.h>
   7#include <linux/wait.h>
   8#include <linux/atomic.h>
   9
  10#ifdef CONFIG_FREEZER
  11extern atomic_t system_freezing_cnt;    /* nr of freezing conds in effect */
  12extern bool pm_freezing;                /* PM freezing in effect */
  13extern bool pm_nosig_freezing;          /* PM nosig freezing in effect */
  14
  15/*
  16 * Check if a process has been frozen
  17 */
  18static inline bool frozen(struct task_struct *p)
  19{
  20        return p->flags & PF_FROZEN;
  21}
  22
  23extern bool freezing_slow_path(struct task_struct *p);
  24
  25/*
  26 * Check if there is a request to freeze a process
  27 */
  28static inline bool freezing(struct task_struct *p)
  29{
  30        if (likely(!atomic_read(&system_freezing_cnt)))
  31                return false;
  32        return freezing_slow_path(p);
  33}
  34
  35/* Takes and releases task alloc lock using task_lock() */
  36extern void __thaw_task(struct task_struct *t);
  37
  38extern bool __refrigerator(bool check_kthr_stop);
  39extern int freeze_processes(void);
  40extern int freeze_kernel_threads(void);
  41extern void thaw_processes(void);
  42extern void thaw_kernel_threads(void);
  43
  44static inline bool try_to_freeze(void)
  45{
  46        might_sleep();
  47        if (likely(!freezing(current)))
  48                return false;
  49        return __refrigerator(false);
  50}
  51
  52extern bool freeze_task(struct task_struct *p);
  53extern bool set_freezable(void);
  54
  55#ifdef CONFIG_CGROUP_FREEZER
  56extern bool cgroup_freezing(struct task_struct *task);
  57#else /* !CONFIG_CGROUP_FREEZER */
  58static inline bool cgroup_freezing(struct task_struct *task)
  59{
  60        return false;
  61}
  62#endif /* !CONFIG_CGROUP_FREEZER */
  63
  64/*
  65 * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
  66 * calls wait_for_completion(&vfork) and reset right after it returns from this
  67 * function.  Next, the parent should call try_to_freeze() to freeze itself
  68 * appropriately in case the child has exited before the freezing of tasks is
  69 * complete.  However, we don't want kernel threads to be frozen in unexpected
  70 * places, so we allow them to block freeze_processes() instead or to set
  71 * PF_NOFREEZE if needed. Fortunately, in the ____call_usermodehelper() case the
  72 * parent won't really block freeze_processes(), since ____call_usermodehelper()
  73 * (the child) does a little before exec/exit and it can't be frozen before
  74 * waking up the parent.
  75 */
  76
  77
  78/* Tell the freezer not to count the current task as freezable. */
  79static inline void freezer_do_not_count(void)
  80{
  81        current->flags |= PF_FREEZER_SKIP;
  82}
  83
  84/*
  85 * Tell the freezer to count the current task as freezable again and try to
  86 * freeze it.
  87 */
  88static inline void freezer_count(void)
  89{
  90        current->flags &= ~PF_FREEZER_SKIP;
  91        try_to_freeze();
  92}
  93
  94/*
  95 * Check if the task should be counted as freezable by the freezer
  96 */
  97static inline int freezer_should_skip(struct task_struct *p)
  98{
  99        return !!(p->flags & PF_FREEZER_SKIP);
 100}
 101
 102/*
 103 * These macros are intended to be used whenever you want allow a task that's
 104 * sleeping in TASK_UNINTERRUPTIBLE or TASK_KILLABLE state to be frozen. Note
 105 * that neither return any clear indication of whether a freeze event happened
 106 * while in this function.
 107 */
 108
 109/* Like schedule(), but should not block the freezer. */
 110#define freezable_schedule()                                            \
 111({                                                                      \
 112        freezer_do_not_count();                                         \
 113        schedule();                                                     \
 114        freezer_count();                                                \
 115})
 116
 117/* Like schedule_timeout_killable(), but should not block the freezer. */
 118#define freezable_schedule_timeout_killable(timeout)                    \
 119({                                                                      \
 120        long __retval;                                                  \
 121        freezer_do_not_count();                                         \
 122        __retval = schedule_timeout_killable(timeout);                  \
 123        freezer_count();                                                \
 124        __retval;                                                       \
 125})
 126
 127/*
 128 * Freezer-friendly wrappers around wait_event_interruptible(),
 129 * wait_event_killable() and wait_event_interruptible_timeout(), originally
 130 * defined in <linux/wait.h>
 131 */
 132
 133#define wait_event_freezekillable(wq, condition)                        \
 134({                                                                      \
 135        int __retval;                                                   \
 136        freezer_do_not_count();                                         \
 137        __retval = wait_event_killable(wq, (condition));                \
 138        freezer_count();                                                \
 139        __retval;                                                       \
 140})
 141
 142#define wait_event_freezable(wq, condition)                             \
 143({                                                                      \
 144        int __retval;                                                   \
 145        for (;;) {                                                      \
 146                __retval = wait_event_interruptible(wq,                 \
 147                                (condition) || freezing(current));      \
 148                if (__retval || (condition))                            \
 149                        break;                                          \
 150                try_to_freeze();                                        \
 151        }                                                               \
 152        __retval;                                                       \
 153})
 154
 155#define wait_event_freezable_timeout(wq, condition, timeout)            \
 156({                                                                      \
 157        long __retval = timeout;                                        \
 158        for (;;) {                                                      \
 159                __retval = wait_event_interruptible_timeout(wq,         \
 160                                (condition) || freezing(current),       \
 161                                __retval);                              \
 162                if (__retval <= 0 || (condition))                       \
 163                        break;                                          \
 164                try_to_freeze();                                        \
 165        }                                                               \
 166        __retval;                                                       \
 167})
 168
 169#else /* !CONFIG_FREEZER */
 170static inline bool frozen(struct task_struct *p) { return false; }
 171static inline bool freezing(struct task_struct *p) { return false; }
 172static inline void __thaw_task(struct task_struct *t) {}
 173
 174static inline bool __refrigerator(bool check_kthr_stop) { return false; }
 175static inline int freeze_processes(void) { return -ENOSYS; }
 176static inline int freeze_kernel_threads(void) { return -ENOSYS; }
 177static inline void thaw_processes(void) {}
 178static inline void thaw_kernel_threads(void) {}
 179
 180static inline bool try_to_freeze(void) { return false; }
 181
 182static inline void freezer_do_not_count(void) {}
 183static inline void freezer_count(void) {}
 184static inline int freezer_should_skip(struct task_struct *p) { return 0; }
 185static inline void set_freezable(void) {}
 186
 187#define freezable_schedule()  schedule()
 188
 189#define freezable_schedule_timeout_killable(timeout)                    \
 190        schedule_timeout_killable(timeout)
 191
 192#define wait_event_freezable(wq, condition)                             \
 193                wait_event_interruptible(wq, condition)
 194
 195#define wait_event_freezable_timeout(wq, condition, timeout)            \
 196                wait_event_interruptible_timeout(wq, condition, timeout)
 197
 198#define wait_event_freezekillable(wq, condition)                \
 199                wait_event_killable(wq, condition)
 200
 201#endif /* !CONFIG_FREEZER */
 202
 203#endif  /* FREEZER_H_INCLUDED */
 204