home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / freezer.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  5.1 KB  |  191 lines
  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.  
  9. #ifdef CONFIG_FREEZER
  10. /*
  11.  * Check if a process has been frozen
  12.  */
  13. static inline int frozen(struct task_struct *p)
  14. {
  15.     return p->flags & PF_FROZEN;
  16. }
  17.  
  18. /*
  19.  * Check if there is a request to freeze a process
  20.  */
  21. static inline int freezing(struct task_struct *p)
  22. {
  23.     return test_tsk_thread_flag(p, TIF_FREEZE);
  24. }
  25.  
  26. /*
  27.  * Request that a process be frozen
  28.  */
  29. static inline void set_freeze_flag(struct task_struct *p)
  30. {
  31.     set_tsk_thread_flag(p, TIF_FREEZE);
  32. }
  33.  
  34. /*
  35.  * Sometimes we may need to cancel the previous 'freeze' request
  36.  */
  37. static inline void clear_freeze_flag(struct task_struct *p)
  38. {
  39.     clear_tsk_thread_flag(p, TIF_FREEZE);
  40. }
  41.  
  42. static inline bool should_send_signal(struct task_struct *p)
  43. {
  44.     return !(p->flags & PF_FREEZER_NOSIG);
  45. }
  46.  
  47. /* Takes and releases task alloc lock using task_lock() */
  48. extern int thaw_process(struct task_struct *p);
  49.  
  50. extern void refrigerator(void);
  51. extern int freeze_processes(void);
  52. extern void thaw_processes(void);
  53.  
  54. static inline int try_to_freeze(void)
  55. {
  56.     if (freezing(current)) {
  57.         refrigerator();
  58.         return 1;
  59.     } else
  60.         return 0;
  61. }
  62.  
  63. extern bool freeze_task(struct task_struct *p, bool sig_only);
  64. extern void cancel_freezing(struct task_struct *p);
  65.  
  66. #ifdef CONFIG_CGROUP_FREEZER
  67. extern int cgroup_frozen(struct task_struct *task);
  68. #else /* !CONFIG_CGROUP_FREEZER */
  69. static inline int cgroup_frozen(struct task_struct *task) { return 0; }
  70. #endif /* !CONFIG_CGROUP_FREEZER */
  71.  
  72. /*
  73.  * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
  74.  * calls wait_for_completion(&vfork) and reset right after it returns from this
  75.  * function.  Next, the parent should call try_to_freeze() to freeze itself
  76.  * appropriately in case the child has exited before the freezing of tasks is
  77.  * complete.  However, we don't want kernel threads to be frozen in unexpected
  78.  * places, so we allow them to block freeze_processes() instead or to set
  79.  * PF_NOFREEZE if needed and PF_FREEZER_SKIP is only set for userland vfork
  80.  * parents.  Fortunately, in the ____call_usermodehelper() case the parent won't
  81.  * really block freeze_processes(), since ____call_usermodehelper() (the child)
  82.  * does a little before exec/exit and it can't be frozen before waking up the
  83.  * parent.
  84.  */
  85.  
  86. /*
  87.  * If the current task is a user space one, tell the freezer not to count it as
  88.  * freezable.
  89.  */
  90. static inline void freezer_do_not_count(void)
  91. {
  92.     if (current->mm)
  93.         current->flags |= PF_FREEZER_SKIP;
  94. }
  95.  
  96. /*
  97.  * If the current task is a user space one, tell the freezer to count it as
  98.  * freezable again and try to freeze it.
  99.  */
  100. static inline void freezer_count(void)
  101. {
  102.     if (current->mm) {
  103.         current->flags &= ~PF_FREEZER_SKIP;
  104.         try_to_freeze();
  105.     }
  106. }
  107.  
  108. /*
  109.  * Check if the task should be counted as freezeable by the freezer
  110.  */
  111. static inline int freezer_should_skip(struct task_struct *p)
  112. {
  113.     return !!(p->flags & PF_FREEZER_SKIP);
  114. }
  115.  
  116. /*
  117.  * Tell the freezer that the current task should be frozen by it
  118.  */
  119. static inline void set_freezable(void)
  120. {
  121.     current->flags &= ~PF_NOFREEZE;
  122. }
  123.  
  124. /*
  125.  * Tell the freezer that the current task should be frozen by it and that it
  126.  * should send a fake signal to the task to freeze it.
  127.  */
  128. static inline void set_freezable_with_signal(void)
  129. {
  130.     current->flags &= ~(PF_NOFREEZE | PF_FREEZER_NOSIG);
  131. }
  132.  
  133. /*
  134.  * Freezer-friendly wrappers around wait_event_interruptible() and
  135.  * wait_event_interruptible_timeout(), originally defined in <linux/wait.h>
  136.  */
  137.  
  138. #define wait_event_freezable(wq, condition)                \
  139. ({                                    \
  140.     int __retval;                            \
  141.     do {                                \
  142.         __retval = wait_event_interruptible(wq,         \
  143.                 (condition) || freezing(current));    \
  144.         if (__retval && !freezing(current))            \
  145.             break;                        \
  146.         else if (!(condition))                    \
  147.             __retval = -ERESTARTSYS;            \
  148.     } while (try_to_freeze());                    \
  149.     __retval;                            \
  150. })
  151.  
  152.  
  153. #define wait_event_freezable_timeout(wq, condition, timeout)        \
  154. ({                                    \
  155.     long __retval = timeout;                    \
  156.     do {                                \
  157.         __retval = wait_event_interruptible_timeout(wq,        \
  158.                 (condition) || freezing(current),    \
  159.                 __retval);                 \
  160.     } while (try_to_freeze());                    \
  161.     __retval;                            \
  162. })
  163. #else /* !CONFIG_FREEZER */
  164. static inline int frozen(struct task_struct *p) { return 0; }
  165. static inline int freezing(struct task_struct *p) { return 0; }
  166. static inline void set_freeze_flag(struct task_struct *p) {}
  167. static inline void clear_freeze_flag(struct task_struct *p) {}
  168. static inline int thaw_process(struct task_struct *p) { return 1; }
  169.  
  170. static inline void refrigerator(void) {}
  171. static inline int freeze_processes(void) { BUG(); return 0; }
  172. static inline void thaw_processes(void) {}
  173.  
  174. static inline int try_to_freeze(void) { return 0; }
  175.  
  176. static inline void freezer_do_not_count(void) {}
  177. static inline void freezer_count(void) {}
  178. static inline int freezer_should_skip(struct task_struct *p) { return 0; }
  179. static inline void set_freezable(void) {}
  180. static inline void set_freezable_with_signal(void) {}
  181.  
  182. #define wait_event_freezable(wq, condition)                \
  183.         wait_event_interruptible(wq, condition)
  184.  
  185. #define wait_event_freezable_timeout(wq, condition, timeout)        \
  186.         wait_event_interruptible_timeout(wq, condition, timeout)
  187.  
  188. #endif /* !CONFIG_FREEZER */
  189.  
  190. #endif    /* FREEZER_H_INCLUDED */
  191.