2006-12-06 21:34:23 -07:00
|
|
|
/* Freezer declarations */
|
|
|
|
|
2007-07-17 05:03:35 -06:00
|
|
|
#ifndef FREEZER_H_INCLUDED
|
|
|
|
#define FREEZER_H_INCLUDED
|
|
|
|
|
2006-12-10 03:18:58 -07:00
|
|
|
#include <linux/sched.h>
|
2007-10-18 04:04:45 -06:00
|
|
|
#include <linux/wait.h>
|
2011-11-21 13:32:25 -07:00
|
|
|
#include <linux/atomic.h>
|
2006-12-10 03:18:58 -07:00
|
|
|
|
2008-10-18 21:27:19 -06:00
|
|
|
#ifdef CONFIG_FREEZER
|
2011-11-21 13:32:25 -07:00
|
|
|
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 */
|
|
|
|
|
2006-12-06 21:34:23 -07:00
|
|
|
/*
|
|
|
|
* Check if a process has been frozen
|
|
|
|
*/
|
2011-11-21 13:32:25 -07:00
|
|
|
static inline bool frozen(struct task_struct *p)
|
2006-12-06 21:34:23 -07:00
|
|
|
{
|
|
|
|
return p->flags & PF_FROZEN;
|
|
|
|
}
|
|
|
|
|
2011-11-21 13:32:25 -07:00
|
|
|
extern bool freezing_slow_path(struct task_struct *p);
|
2006-12-06 21:34:23 -07:00
|
|
|
|
|
|
|
/*
|
2011-11-21 13:32:25 -07:00
|
|
|
* Check if there is a request to freeze a process
|
2006-12-06 21:34:23 -07:00
|
|
|
*/
|
2011-11-21 13:32:25 -07:00
|
|
|
static inline bool freezing(struct task_struct *p)
|
2006-12-06 21:34:23 -07:00
|
|
|
{
|
2011-11-21 13:32:25 -07:00
|
|
|
if (likely(!atomic_read(&system_freezing_cnt)))
|
|
|
|
return false;
|
|
|
|
return freezing_slow_path(p);
|
2006-12-06 21:34:23 -07:00
|
|
|
}
|
|
|
|
|
2008-10-18 21:27:21 -06:00
|
|
|
/* Takes and releases task alloc lock using task_lock() */
|
2011-11-21 13:32:23 -07:00
|
|
|
extern void __thaw_task(struct task_struct *t);
|
2006-12-06 21:34:23 -07:00
|
|
|
|
2011-11-21 13:32:23 -07:00
|
|
|
extern bool __refrigerator(bool check_kthr_stop);
|
2006-12-06 21:34:23 -07:00
|
|
|
extern int freeze_processes(void);
|
2011-09-26 12:32:27 -06:00
|
|
|
extern int freeze_kernel_threads(void);
|
2006-12-06 21:34:37 -07:00
|
|
|
extern void thaw_processes(void);
|
2006-12-06 21:34:23 -07:00
|
|
|
|
2011-11-21 13:32:22 -07:00
|
|
|
static inline bool try_to_freeze(void)
|
2006-12-06 21:34:23 -07:00
|
|
|
{
|
2011-11-21 13:32:22 -07:00
|
|
|
might_sleep();
|
|
|
|
if (likely(!freezing(current)))
|
|
|
|
return false;
|
2011-11-21 13:32:23 -07:00
|
|
|
return __refrigerator(false);
|
2006-12-06 21:34:23 -07:00
|
|
|
}
|
2006-12-06 21:34:28 -07:00
|
|
|
|
2011-11-21 13:32:26 -07:00
|
|
|
extern bool freeze_task(struct task_struct *p);
|
2011-11-23 10:28:17 -07:00
|
|
|
extern bool set_freezable(void);
|
2008-10-18 21:27:19 -06:00
|
|
|
|
2008-10-18 21:27:21 -06:00
|
|
|
#ifdef CONFIG_CGROUP_FREEZER
|
2011-11-21 13:32:25 -07:00
|
|
|
extern bool cgroup_freezing(struct task_struct *task);
|
2008-10-18 21:27:21 -06:00
|
|
|
#else /* !CONFIG_CGROUP_FREEZER */
|
2011-11-21 13:32:25 -07:00
|
|
|
static inline bool cgroup_freezing(struct task_struct *task)
|
2010-03-26 16:51:44 -06:00
|
|
|
{
|
2011-11-21 13:32:25 -07:00
|
|
|
return false;
|
2010-03-26 16:51:44 -06:00
|
|
|
}
|
2008-10-18 21:27:21 -06:00
|
|
|
#endif /* !CONFIG_CGROUP_FREEZER */
|
|
|
|
|
2007-05-23 14:57:25 -06:00
|
|
|
/*
|
|
|
|
* 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 and PF_FREEZER_SKIP is only set for userland vfork
|
|
|
|
* parents. 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the current task is a user space one, tell the freezer not to count it as
|
|
|
|
* freezable.
|
|
|
|
*/
|
|
|
|
static inline void freezer_do_not_count(void)
|
|
|
|
{
|
|
|
|
if (current->mm)
|
|
|
|
current->flags |= PF_FREEZER_SKIP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the current task is a user space one, tell the freezer to count it as
|
|
|
|
* freezable again and try to freeze it.
|
|
|
|
*/
|
|
|
|
static inline void freezer_count(void)
|
|
|
|
{
|
|
|
|
if (current->mm) {
|
|
|
|
current->flags &= ~PF_FREEZER_SKIP;
|
|
|
|
try_to_freeze();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-02-16 01:25:31 -07:00
|
|
|
* Check if the task should be counted as freezable by the freezer
|
2007-05-23 14:57:25 -06:00
|
|
|
*/
|
|
|
|
static inline int freezer_should_skip(struct task_struct *p)
|
|
|
|
{
|
|
|
|
return !!(p->flags & PF_FREEZER_SKIP);
|
|
|
|
}
|
2006-12-06 21:34:28 -07:00
|
|
|
|
2011-12-01 14:44:39 -07:00
|
|
|
/*
|
|
|
|
* These macros are intended to be used whenever you want allow a task that's
|
|
|
|
* sleeping in TASK_UNINTERRUPTIBLE or TASK_KILLABLE state 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. */
|
|
|
|
#define freezable_schedule() \
|
|
|
|
({ \
|
|
|
|
freezer_do_not_count(); \
|
|
|
|
schedule(); \
|
|
|
|
freezer_count(); \
|
|
|
|
})
|
|
|
|
|
|
|
|
/* Like schedule_timeout_killable(), but should not block the freezer. */
|
|
|
|
#define freezable_schedule_timeout_killable(timeout) \
|
|
|
|
({ \
|
|
|
|
freezer_do_not_count(); \
|
|
|
|
schedule_timeout_killable(timeout); \
|
|
|
|
freezer_count(); \
|
|
|
|
})
|
|
|
|
|
2007-10-18 04:04:45 -06:00
|
|
|
/*
|
2011-10-19 13:30:40 -06:00
|
|
|
* Freezer-friendly wrappers around wait_event_interruptible(),
|
|
|
|
* wait_event_killable() and wait_event_interruptible_timeout(), originally
|
|
|
|
* defined in <linux/wait.h>
|
2007-10-18 04:04:45 -06:00
|
|
|
*/
|
|
|
|
|
2011-10-19 13:30:40 -06:00
|
|
|
#define wait_event_freezekillable(wq, condition) \
|
|
|
|
({ \
|
|
|
|
int __retval; \
|
2011-11-03 17:07:49 -06:00
|
|
|
freezer_do_not_count(); \
|
|
|
|
__retval = wait_event_killable(wq, (condition)); \
|
|
|
|
freezer_count(); \
|
2011-10-19 13:30:40 -06:00
|
|
|
__retval; \
|
|
|
|
})
|
|
|
|
|
2007-10-18 04:04:45 -06:00
|
|
|
#define wait_event_freezable(wq, condition) \
|
|
|
|
({ \
|
|
|
|
int __retval; \
|
2011-11-23 10:28:17 -07:00
|
|
|
for (;;) { \
|
2007-10-18 04:04:45 -06:00
|
|
|
__retval = wait_event_interruptible(wq, \
|
|
|
|
(condition) || freezing(current)); \
|
2011-11-23 10:28:17 -07:00
|
|
|
if (__retval || (condition)) \
|
2007-10-18 04:04:45 -06:00
|
|
|
break; \
|
2011-11-23 10:28:17 -07:00
|
|
|
try_to_freeze(); \
|
|
|
|
} \
|
2007-10-18 04:04:45 -06:00
|
|
|
__retval; \
|
|
|
|
})
|
|
|
|
|
|
|
|
#define wait_event_freezable_timeout(wq, condition, timeout) \
|
|
|
|
({ \
|
|
|
|
long __retval = timeout; \
|
2011-11-23 10:28:17 -07:00
|
|
|
for (;;) { \
|
2007-10-18 04:04:45 -06:00
|
|
|
__retval = wait_event_interruptible_timeout(wq, \
|
|
|
|
(condition) || freezing(current), \
|
|
|
|
__retval); \
|
2011-11-23 10:28:17 -07:00
|
|
|
if (__retval <= 0 || (condition)) \
|
|
|
|
break; \
|
|
|
|
try_to_freeze(); \
|
|
|
|
} \
|
2007-10-18 04:04:45 -06:00
|
|
|
__retval; \
|
|
|
|
})
|
2011-11-23 10:28:17 -07:00
|
|
|
|
2008-10-18 21:27:19 -06:00
|
|
|
#else /* !CONFIG_FREEZER */
|
2011-11-21 13:32:25 -07:00
|
|
|
static inline bool frozen(struct task_struct *p) { return false; }
|
2011-11-21 13:32:25 -07:00
|
|
|
static inline bool freezing(struct task_struct *p) { return false; }
|
2011-11-24 16:44:55 -07:00
|
|
|
static inline void __thaw_task(struct task_struct *t) {}
|
2006-12-06 21:34:23 -07:00
|
|
|
|
2011-11-21 13:32:23 -07:00
|
|
|
static inline bool __refrigerator(bool check_kthr_stop) { return false; }
|
2011-09-26 12:32:27 -06:00
|
|
|
static inline int freeze_processes(void) { return -ENOSYS; }
|
|
|
|
static inline int freeze_kernel_threads(void) { return -ENOSYS; }
|
2006-12-06 21:34:23 -07:00
|
|
|
static inline void thaw_processes(void) {}
|
|
|
|
|
2011-11-21 13:32:22 -07:00
|
|
|
static inline bool try_to_freeze(void) { return false; }
|
2006-12-06 21:34:23 -07:00
|
|
|
|
2007-05-23 14:57:25 -06:00
|
|
|
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; }
|
2007-07-17 05:03:35 -06:00
|
|
|
static inline void set_freezable(void) {}
|
2007-10-18 04:04:45 -06:00
|
|
|
|
2011-12-01 14:44:39 -07:00
|
|
|
#define freezable_schedule() schedule()
|
|
|
|
|
|
|
|
#define freezable_schedule_timeout_killable(timeout) \
|
|
|
|
schedule_timeout_killable(timeout)
|
|
|
|
|
2007-10-18 04:04:45 -06:00
|
|
|
#define wait_event_freezable(wq, condition) \
|
|
|
|
wait_event_interruptible(wq, condition)
|
|
|
|
|
|
|
|
#define wait_event_freezable_timeout(wq, condition, timeout) \
|
|
|
|
wait_event_interruptible_timeout(wq, condition, timeout)
|
|
|
|
|
2011-10-25 09:02:53 -06:00
|
|
|
#define wait_event_freezekillable(wq, condition) \
|
|
|
|
wait_event_killable(wq, condition)
|
|
|
|
|
2008-10-18 21:27:19 -06:00
|
|
|
#endif /* !CONFIG_FREEZER */
|
2007-07-17 05:03:35 -06:00
|
|
|
|
|
|
|
#endif /* FREEZER_H_INCLUDED */
|