workqueue: clean up delayed_work initializers and add missing one

Reimplement delayed_work initializers using new timer initializers
which take timer flags.  This reduces code duplications and will ease
further initializer changes.  This patch also adds a missing
initializer - INIT_DEFERRABLE_WORK_ONSTACK().

Signed-off-by: Tejun Heo <tj@kernel.org>

1 files changed, 23 insertions, 25 deletions

diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 49a9c51f9ee3..e84ebb69607d 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -133,26 +133,20 @@ struct execute_work {
         __WORK_INIT_LOCKDEP_MAP(#n, &(n))                               \
         }
 
-#define __DELAYED_WORK_INITIALIZER(n, f) {                              \
+#define __DELAYED_WORK_INITIALIZER(n, f, tflags) {                      \
         .work = __WORK_INITIALIZER((n).work, (f)),                      \
-        .timer = TIMER_INITIALIZER(delayed_work_timer_fn,               \
-                                0, (unsigned long)&(n)),                \
-        }
-
-#define __DEFERRABLE_WORK_INITIALIZER(n, f) {                           \
-        .work = __WORK_INITIALIZER((n).work, (f)),                      \
-        .timer = TIMER_DEFERRED_INITIALIZER(delayed_work_timer_fn,      \
-                                0, (unsigned long)&(n)),                \
+        .timer = __TIMER_INITIALIZER(delayed_work_timer_fn,             \
+                        0, (unsigned long)&(n), (tflags)),              \
         }
 
 #define DECLARE_WORK(n, f)                                              \
         struct work_struct n = __WORK_INITIALIZER(n, f)
 
 #define DECLARE_DELAYED_WORK(n, f)                                      \
-        struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f)
+        struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, 0)
 
 #define DECLARE_DEFERRABLE_WORK(n, f)                                   \
-        struct delayed_work n = __DEFERRABLE_WORK_INITIALIZER(n, f)
+        struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, TIMER_DEFERRABLE)
 
 /*
  * initialize a work item's function pointer
@@ -216,29 +210,33 @@ static inline unsigned int work_static(struct work_struct *work) { return 0; }
                 __INIT_WORK((_work), (_func), 1);                       \
         } while (0)
 
-#define INIT_DELAYED_WORK(_work, _func)                                 \
+#define __INIT_DELAYED_WORK(_work, _func, _tflags)                      \
         do {                                                            \
                 INIT_WORK(&(_work)->work, (_func));                     \
-                init_timer(&(_work)->timer);                            \
-                (_work)->timer.function = delayed_work_timer_fn;        \
-                (_work)->timer.data = (unsigned long)(_work);           \
+                __setup_timer(&(_work)->timer, delayed_work_timer_fn,   \
+                              (unsigned long)(_work), (_tflags));       \
         } while (0)
 
-#define INIT_DELAYED_WORK_ONSTACK(_work, _func)                         \
+#define __INIT_DELAYED_WORK_ONSTACK(_work, _func, _tflags)              \
         do {                                                            \
                 INIT_WORK_ONSTACK(&(_work)->work, (_func));             \
-                init_timer_on_stack(&(_work)->timer);                   \
-                (_work)->timer.function = delayed_work_timer_fn;        \
-                (_work)->timer.data = (unsigned long)(_work);           \
+                __setup_timer_on_stack(&(_work)->timer,                 \
+                                       delayed_work_timer_fn,           \
+                                       (unsigned long)(_work),          \
+                                       (_tflags));                      \
         } while (0)
 
+#define INIT_DELAYED_WORK(_work, _func)                                 \
+        __INIT_DELAYED_WORK(_work, _func, 0)
+
+#define INIT_DELAYED_WORK_ONSTACK(_work, _func)                         \
+        __INIT_DELAYED_WORK_ONSTACK(_work, _func, 0)
+
 #define INIT_DEFERRABLE_WORK(_work, _func)                              \
-        do {                                                            \
-                INIT_WORK(&(_work)->work, (_func));                     \
-                init_timer_deferrable(&(_work)->timer);                 \
-                (_work)->timer.function = delayed_work_timer_fn;        \
-                (_work)->timer.data = (unsigned long)(_work);           \
-        } while (0)
+        __INIT_DELAYED_WORK(_work, _func, TIMER_DEFERRABLE)
+
+#define INIT_DEFERRABLE_WORK_ONSTACK(_work, _func)                      \
+        __INIT_DELAYED_WORK_ONSTACK(_work, _func, TIMER_DEFERRABLE)
 
 /**
  * work_pending - Find out whether a work item is currently pending