WorkStruct: Separate delayable and non-delayable events.

Separate delayable work items from non-delayable work items be splitting them
into a separate structure (delayed_work), which incorporates a work_struct and
the timer_list removed from work_struct.

The work_struct struct is huge, and this limits it's usefulness.  On a 64-bit
architecture it's nearly 100 bytes in size.  This reduces that by half for the
non-delayable type of event.

Signed-Off-By: David Howells <dhowells@redhat.com>

8 files changed, 40 insertions, 20 deletions

diff --git a/include/linux/aio.h b/include/linux/aio.h
index 0d71c0041f13..9e350fd44d77 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h
@@ -194,7 +194,7 @@ struct kioctx {
 
         struct aio_ring_info    ring_info;
 
-        struct work_struct      wq;
+        struct delayed_work     wq;
 };
 
 /* prototypes */
diff --git a/include/linux/kbd_kern.h b/include/linux/kbd_kern.h
index efe0ee4cc80b..06c58c423fe1 100644
--- a/include/linux/kbd_kern.h
+++ b/include/linux/kbd_kern.h
@@ -158,7 +158,7 @@ static inline void con_schedule_flip(struct tty_struct *t)
         if (t->buf.tail != NULL)
                 t->buf.tail->commit = t->buf.tail->used;
         spin_unlock_irqrestore(&t->buf.lock, flags);
-        schedule_work(&t->buf.work);
+        schedule_delayed_work(&t->buf.work, 0);
 }
 
 #endif
diff --git a/include/linux/libata.h b/include/linux/libata.h
index abd2debebca2..5f04006e8dd2 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -568,8 +568,8 @@ struct ata_port {
         struct ata_host         *host;
         struct device           *dev;
 
-        struct work_struct      port_task;
-        struct work_struct      hotplug_task;
+        struct delayed_work     port_task;
+        struct delayed_work     hotplug_task;
         struct work_struct      scsi_rescan_task;
 
         unsigned int            hsm_task_state;
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 7ccfc7ef0a83..95796e6924f1 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -51,7 +51,7 @@ struct nfs_client {
 
         unsigned long           cl_lease_time;
         unsigned long           cl_last_renewal;
-        struct work_struct      cl_renewd;
+        struct delayed_work     cl_renewd;
 
         struct rpc_wait_queue   cl_rpcwaitq;
 
diff --git a/include/linux/sunrpc/rpc_pipe_fs.h b/include/linux/sunrpc/rpc_pipe_fs.h
index a2eb9b4a9de3..4a68125b6de6 100644
--- a/include/linux/sunrpc/rpc_pipe_fs.h
+++ b/include/linux/sunrpc/rpc_pipe_fs.h
@@ -30,7 +30,7 @@ struct rpc_inode {
 #define RPC_PIPE_WAIT_FOR_OPEN  1
         int flags;
         struct rpc_pipe_ops *ops;
-        struct work_struct queue_timeout;
+        struct delayed_work queue_timeout;
 };
 
 static inline struct rpc_inode *
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 60394fbc4c70..3e04c1512fc4 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -177,7 +177,7 @@ struct rpc_xprt {
         unsigned long           connect_timeout,
                                 bind_timeout,
                                 reestablish_timeout;
-        struct work_struct      connect_worker;
+        struct delayed_work     connect_worker;
         unsigned short          port;
 
         /*
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 44091c0db0b4..c1f716446161 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -53,7 +53,7 @@ struct tty_buffer {
 };
 
 struct tty_bufhead {
-        struct work_struct              work;
+        struct delayed_work work;
         struct semaphore pty_sem;
         spinlock_t lock;
         struct tty_buffer *head;        /* Queue head */
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 9bca3539a1e5..9faaccae570e 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -17,6 +17,10 @@ struct work_struct {
         void (*func)(void *);
         void *data;
         void *wq_data;
+};
+
+struct delayed_work {
+        struct work_struct work;
         struct timer_list timer;
 };
 
@@ -28,32 +32,48 @@ struct execute_work {
         .entry  = { &(n).entry, &(n).entry },                   \
         .func = (f),                                            \
         .data = (d),                                            \
+        }
+
+#define __DELAYED_WORK_INITIALIZER(n, f, d) {                   \
+        .work = __WORK_INITIALIZER((n).work, (f), (d)),         \
         .timer = TIMER_INITIALIZER(NULL, 0, 0),                 \
         }
 
 #define DECLARE_WORK(n, f, d)                                   \
         struct work_struct n = __WORK_INITIALIZER(n, f, d)
 
+#define DECLARE_DELAYED_WORK(n, f, d)                           \
+        struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, d)
+
 /*
- * initialize a work-struct's func and data pointers:
+ * initialize a work item's function and data pointers
  */
 #define PREPARE_WORK(_work, _func, _data)                       \
         do {                                                    \
-                (_work)->func = _func;                          \
-                (_work)->data = _data;                          \
+                (_work)->func = (_func);                        \
+                (_work)->data = (_data);                        \
         } while (0)
 
+#define PREPARE_DELAYED_WORK(_work, _func, _data)               \
+        PREPARE_WORK(&(_work)->work, (_func), (_data))
+
 /*
- * initialize all of a work-struct:
+ * initialize all of a work item in one go
  */
 #define INIT_WORK(_work, _func, _data)                          \
         do {                                                    \
                 INIT_LIST_HEAD(&(_work)->entry);                \
                 (_work)->pending = 0;                           \
                 PREPARE_WORK((_work), (_func), (_data));        \
+        } while (0)
+
+#define INIT_DELAYED_WORK(_work, _func, _data)          \
+        do {                                                    \
+                INIT_WORK(&(_work)->work, (_func), (_data));    \
                 init_timer(&(_work)->timer);                    \
         } while (0)
 
+
 extern struct workqueue_struct *__create_workqueue(const char *name,
                                                     int singlethread);
 #define create_workqueue(name) __create_workqueue((name), 0)
@@ -62,24 +82,24 @@ extern struct workqueue_struct *__create_workqueue(const char *name,
 extern void destroy_workqueue(struct workqueue_struct *wq);
 
 extern int FASTCALL(queue_work(struct workqueue_struct *wq, struct work_struct *work));
-extern int FASTCALL(queue_delayed_work(struct workqueue_struct *wq, struct work_struct *work, unsigned long delay));
+extern int FASTCALL(queue_delayed_work(struct workqueue_struct *wq, struct delayed_work *work, unsigned long delay));
 extern int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
-        struct work_struct *work, unsigned long delay);
+        struct delayed_work *work, unsigned long delay);
 extern void FASTCALL(flush_workqueue(struct workqueue_struct *wq));
 
 extern int FASTCALL(schedule_work(struct work_struct *work));
-extern int FASTCALL(schedule_delayed_work(struct work_struct *work, unsigned long delay));
+extern int FASTCALL(schedule_delayed_work(struct delayed_work *work, unsigned long delay));
 
-extern int schedule_delayed_work_on(int cpu, struct work_struct *work, unsigned long delay);
+extern int schedule_delayed_work_on(int cpu, struct delayed_work *work, unsigned long delay);
 extern int schedule_on_each_cpu(void (*func)(void *info), void *info);
 extern void flush_scheduled_work(void);
 extern int current_is_keventd(void);
 extern int keventd_up(void);
 
 extern void init_workqueues(void);
-void cancel_rearming_delayed_work(struct work_struct *work);
+void cancel_rearming_delayed_work(struct delayed_work *work);
 void cancel_rearming_delayed_workqueue(struct workqueue_struct *,
-                                       struct work_struct *);
+                                       struct delayed_work *);
 int execute_in_process_context(void (*fn)(void *), void *,
                                struct execute_work *);
 
@@ -88,13 +108,13 @@ int execute_in_process_context(void (*fn)(void *), void *,
  * function may still be running on return from cancel_delayed_work().  Run
  * flush_scheduled_work() to wait on it.
  */
-static inline int cancel_delayed_work(struct work_struct *work)
+static inline int cancel_delayed_work(struct delayed_work *work)
 {
         int ret;
 
         ret = del_timer_sync(&work->timer);
         if (ret)
-                clear_bit(0, &work->pending);
+                clear_bit(0, &work->work.pending);
         return ret;
 }