freezer: add unsafe versions of freezable helpers for NFS

[deliverable/linux.git] / include / linux / freezer.h

diff --git a/include/linux/freezer.h b/include/linux/freezer.h
index e70df40d84f6fe83c72f732aa44b454148661b6e..5b31e21c485f4ac7ecf5cd6b43cbdece997ca5f1 100644 (file)
--- a/include/linux/freezer.h
+++ b/include/linux/freezer.h
@@ -46,7 +46,11 @@ extern int freeze_kernel_threads(void);
 extern void thaw_processes(void);
 extern void thaw_kernel_threads(void);
 
-static inline bool try_to_freeze(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)))
@@ -54,6 +58,11 @@ static inline bool try_to_freeze(void)
        return __refrigerator(false);
 }
 
+static inline bool try_to_freeze(void)
+{
+       return try_to_freeze_unsafe();
+}
+
 extern bool freeze_task(struct task_struct *p);
 extern bool set_freezable(void);
 
@@ -115,6 +124,14 @@ static inline void freezer_count(void)
        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
@@ -152,6 +169,14 @@ static inline bool freezer_should_skip(struct task_struct *p)
        freezer_count();                                                \
 })
 
+/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
+#define freezable_schedule_unsafe()                                    \
+({                                                                     \
+       freezer_do_not_count();                                         \
+       schedule();                                                     \
+       freezer_count_unsafe();                                         \
+})
+
 /* Like schedule_timeout_killable(), but should not block the freezer. */
 #define freezable_schedule_timeout_killable(timeout)                   \
 ({                                                                     \
@@ -162,6 +187,16 @@ static inline bool freezer_should_skip(struct task_struct *p)
        __retval;                                                       \
 })
 
+/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
+#define freezable_schedule_timeout_killable_unsafe(timeout)            \
+({                                                                     \
+       long __retval;                                                  \
+       freezer_do_not_count();                                         \
+       __retval = schedule_timeout_killable(timeout);                  \
+       freezer_count_unsafe();                                         \
+       __retval;                                                       \
+})
+
 /*
  * Freezer-friendly wrappers around wait_event_interruptible(),
  * wait_event_killable() and wait_event_interruptible_timeout(), originally
@@ -225,9 +260,14 @@ static inline void set_freezable(void) {}
 
 #define freezable_schedule()  schedule()
 
+#define freezable_schedule_unsafe()  schedule()
+
 #define freezable_schedule_timeout_killable(timeout)                   \
        schedule_timeout_killable(timeout)
 
+#define freezable_schedule_timeout_killable_unsafe(timeout)            \
+       schedule_timeout_killable(timeout)
+
 #define wait_event_freezable(wq, condition)                            \
                wait_event_interruptible(wq, condition)