WorkStruct: Merge the pending bit into the wq_data pointer

Reclaim a word from the size of the work_struct by folding the pending bit and the wq_data pointer together. This shouldn't cause misalignment problems as all pointers should be at least 4-byte aligned. Signed-Off-By: David Howells <dhowells@redhat.com>

WorkStruct: Merge the pending bit into the wq_data pointer
Reclaim a word from the size of the work_struct by folding the pending bit and the wq_data pointer together. This shouldn't cause misalignment problems as all pointers should be at least 4-byte aligned. Signed-Off-By: David Howells <dhowells@redhat.com>
David Howells
1 parent 6bb49e5965
Showing 3 changed files with 57 additions and 15 deletions Side-by-side Diff
drivers/block/floppy.c
include/linux/workqueue.h
kernel/workqueue.c
@@ -1868,7 +1868,7 @@
 	printk("fdc_busy=%lu\n", fdc_busy);
 	if (do_floppy)
 		printk("do_floppy=%p\n", do_floppy);
-	if (floppy_work.pending)
+	if (work_pending(&floppy_work))
 		printk("floppy_work.func=%p\n", floppy_work.func);
 	if (timer_pending(&fd_timer))
 		printk("fd_timer.function=%p\n", fd_timer.function);
@@ -4498,7 +4498,7 @@
 		printk("floppy timer still active:%s\n", timeout_message);
 	if (timer_pending(&fd_timer))
 		printk("auxiliary floppy timer still active\n");
-	if (floppy_work.pending)
+	if (work_pending(&floppy_work))
 		printk("work still pending\n");
 #endif
 	old_fdc = fdc;
@@ -14,11 +14,15 @@
 typedef void (*work_func_t)(void *data);
  
 struct work_struct {
-	unsigned long pending;
+	/* the first word is the work queue pointer and the pending flag
+	 * rolled into one */
+	unsigned long management;
+#define WORK_STRUCT_PENDING 0		/* T if work item pending execution */
+#define WORK_STRUCT_FLAG_MASK (3UL)
+#define WORK_STRUCT_WQ_DATA_MASK (~WORK_STRUCT_FLAG_MASK)
 	struct list_head entry;
 	work_func_t func;
 	void *data;
-	void *wq_data;
 };
  
 struct delayed_work {
@@ -65,7 +69,7 @@
 #define INIT_WORK(_work, _func, _data)				\
 	do {							\
 		INIT_LIST_HEAD(&(_work)->entry);		\
-		(_work)->pending = 0;				\
+		(_work)->management = 0;			\
 		PREPARE_WORK((_work), (_func), (_data));	\
 	} while (0)
  
  
@@ -75,7 +79,22 @@
 		init_timer(&(_work)->timer);			\
 	} while (0)
  
+/**
+ * work_pending - Find out whether a work item is currently pending
+ * @work: The work item in question
+ */
+#define work_pending(work) \
+	test_bit(WORK_STRUCT_PENDING, &(work)->management)
  
+/**
+ * delayed_work_pending - Find out whether a delayable work item is currently
+ * pending
+ * @work: The work item in question
+ */
+#define delayed_work_pending(work) \
+	test_bit(WORK_STRUCT_PENDING, &(work)->work.management)
+
+
 extern struct workqueue_struct *__create_workqueue(const char *name,
 						    int singlethread);
 #define create_workqueue(name) __create_workqueue((name), 0)
@@ -115,7 +134,7 @@
  
 	ret = del_timer_sync(&work->timer);
 	if (ret)
-		clear_bit(0, &work->work.pending);
+		clear_bit(WORK_STRUCT_PENDING, &work->work.management);
 	return ret;
 }
  
@@ -80,6 +80,29 @@
 	return list_empty(&wq->list);
 }
  
+static inline void set_wq_data(struct work_struct *work, void *wq)
+{
+	unsigned long new, old, res;
+
+	/* assume the pending flag is already set and that the task has already
+	 * been queued on this workqueue */
+	new = (unsigned long) wq | (1UL << WORK_STRUCT_PENDING);
+	res = work->management;
+	if (res != new) {
+		do {
+			old = res;
+			new = (unsigned long) wq;
+			new |= (old & WORK_STRUCT_FLAG_MASK);
+			res = cmpxchg(&work->management, old, new);
+		} while (res != old);
+	}
+}
+
+static inline void *get_wq_data(struct work_struct *work)
+{
+	return (void *) (work->management & WORK_STRUCT_WQ_DATA_MASK);
+}
+
 /* Preempt must be disabled. */
 static void __queue_work(struct cpu_workqueue_struct *cwq,
 			 struct work_struct *work)
@@ -87,7 +110,7 @@
 	unsigned long flags;
  
 	spin_lock_irqsave(&cwq->lock, flags);
-	work->wq_data = cwq;
+	set_wq_data(work, cwq);
 	list_add_tail(&work->entry, &cwq->worklist);
 	cwq->insert_sequence++;
 	wake_up(&cwq->more_work);
@@ -108,7 +131,7 @@
 {
 	int ret = 0, cpu = get_cpu();
  
-	if (!test_and_set_bit(0, &work->pending)) {
+	if (!test_and_set_bit(WORK_STRUCT_PENDING, &work->management)) {
 		if (unlikely(is_single_threaded(wq)))
 			cpu = singlethread_cpu;
 		BUG_ON(!list_empty(&work->entry));
@@ -123,7 +146,7 @@
 static void delayed_work_timer_fn(unsigned long __data)
 {
 	struct delayed_work *dwork = (struct delayed_work *)__data;
-	struct workqueue_struct *wq = dwork->work.wq_data;
+	struct workqueue_struct *wq = get_wq_data(&dwork->work);
 	int cpu = smp_processor_id();
  
 	if (unlikely(is_single_threaded(wq)))
  
@@ -150,12 +173,12 @@
 	if (delay == 0)
 		return queue_work(wq, work);
  
-	if (!test_and_set_bit(0, &work->pending)) {
+	if (!test_and_set_bit(WORK_STRUCT_PENDING, &work->management)) {
 		BUG_ON(timer_pending(timer));
 		BUG_ON(!list_empty(&work->entry));
  
 		/* This stores wq for the moment, for the timer_fn */
-		work->wq_data = wq;
+		set_wq_data(work, wq);
 		timer->expires = jiffies + delay;
 		timer->data = (unsigned long)dwork;
 		timer->function = delayed_work_timer_fn;
  
@@ -182,12 +205,12 @@
 	struct timer_list *timer = &dwork->timer;
 	struct work_struct *work = &dwork->work;
  
-	if (!test_and_set_bit(0, &work->pending)) {
+	if (!test_and_set_bit(WORK_STRUCT_PENDING, &work->management)) {
 		BUG_ON(timer_pending(timer));
 		BUG_ON(!list_empty(&work->entry));
  
 		/* This stores wq for the moment, for the timer_fn */
-		work->wq_data = wq;
+		set_wq_data(work, wq);
 		timer->expires = jiffies + delay;
 		timer->data = (unsigned long)dwork;
 		timer->function = delayed_work_timer_fn;
@@ -223,8 +246,8 @@
 		list_del_init(cwq->worklist.next);
 		spin_unlock_irqrestore(&cwq->lock, flags);
  
-		BUG_ON(work->wq_data != cwq);
-		clear_bit(0, &work->pending);
+		BUG_ON(get_wq_data(work) != cwq);
+		clear_bit(WORK_STRUCT_PENDING, &work->management);
 		f(data);
  
 		spin_lock_irqsave(&cwq->lock, flags);
...	...	@@ -1868,7 +1868,7 @@
1868	1868	printk("fdc_busy=%lu\n", fdc_busy);
1869	1869	if (do_floppy)
1870	1870	printk("do_floppy=%p\n", do_floppy);
1871		- if (floppy_work.pending)
	1871	+ if (work_pending(&floppy_work))
1872	1872	printk("floppy_work.func=%p\n", floppy_work.func);
1873	1873	if (timer_pending(&fd_timer))
1874	1874	printk("fd_timer.function=%p\n", fd_timer.function);
...	...	@@ -4498,7 +4498,7 @@
4498	4498	printk("floppy timer still active:%s\n", timeout_message);
4499	4499	if (timer_pending(&fd_timer))
4500	4500	printk("auxiliary floppy timer still active\n");
4501		- if (floppy_work.pending)
	4501	+ if (work_pending(&floppy_work))
4502	4502	printk("work still pending\n");
4503	4503	#endif
4504	4504	old_fdc = fdc;
...	...	@@ -14,11 +14,15 @@
14	14	typedef void (work_func_t)(void data);
15	15
16	16	struct work_struct {
17		- unsigned long pending;
	17	+ /* the first word is the work queue pointer and the pending flag
	18	+ * rolled into one */
	19	+ unsigned long management;
	20	+#define WORK_STRUCT_PENDING 0 /* T if work item pending execution */
	21	+#define WORK_STRUCT_FLAG_MASK (3UL)
	22	+#define WORK_STRUCT_WQ_DATA_MASK (~WORK_STRUCT_FLAG_MASK)
18	23	struct list_head entry;
19	24	work_func_t func;
20	25	void *data;
21		- void *wq_data;
22	26	};
23	27
24	28	struct delayed_work {
...	...	@@ -65,7 +69,7 @@
65	69	#define INIT_WORK(_work, _func, _data) \
66	70	do { \
67	71	INIT_LIST_HEAD(&(_work)->entry); \
68		- (_work)->pending = 0; \
	72	+ (_work)->management = 0; \
69	73	PREPARE_WORK((_work), (_func), (_data)); \
70	74	} while (0)
71	75
72	76
...	...	@@ -75,7 +79,22 @@
75	79	init_timer(&(_work)->timer); \
76	80	} while (0)
77	81
	82	+/**
	83	+ * work_pending - Find out whether a work item is currently pending
	84	+ * @work: The work item in question
	85	+ */
	86	+#define work_pending(work) \
	87	+ test_bit(WORK_STRUCT_PENDING, &(work)->management)
78	88
	89	+/**
	90	+ * delayed_work_pending - Find out whether a delayable work item is currently
	91	+ * pending
	92	+ * @work: The work item in question
	93	+ */
	94	+#define delayed_work_pending(work) \
	95	+ test_bit(WORK_STRUCT_PENDING, &(work)->work.management)
	96	+
	97	+
79	98	extern struct workqueue_struct __create_workqueue(const char name,
80	99	int singlethread);
81	100	#define create_workqueue(name) __create_workqueue((name), 0)
...	...	@@ -115,7 +134,7 @@
115	134
116	135	ret = del_timer_sync(&work->timer);
117	136	if (ret)
118		- clear_bit(0, &work->work.pending);
	137	+ clear_bit(WORK_STRUCT_PENDING, &work->work.management);
119	138	return ret;
120	139	}
121	140
...	...	@@ -80,6 +80,29 @@
80	80	return list_empty(&wq->list);
81	81	}
82	82
	83	+static inline void set_wq_data(struct work_struct work, void wq)
	84	+{
	85	+ unsigned long new, old, res;
	86	+
	87	+ /* assume the pending flag is already set and that the task has already
	88	+ * been queued on this workqueue */
	89	+ new = (unsigned long) wq \| (1UL << WORK_STRUCT_PENDING);
	90	+ res = work->management;
	91	+ if (res != new) {
	92	+ do {
	93	+ old = res;
	94	+ new = (unsigned long) wq;
	95	+ new \|= (old & WORK_STRUCT_FLAG_MASK);
	96	+ res = cmpxchg(&work->management, old, new);
	97	+ } while (res != old);
	98	+ }
	99	+}
	100	+
	101	+static inline void get_wq_data(struct work_struct work)
	102	+{
	103	+ return (void *) (work->management & WORK_STRUCT_WQ_DATA_MASK);
	104	+}
	105	+
83	106	/* Preempt must be disabled. */
84	107	static void __queue_work(struct cpu_workqueue_struct *cwq,
85	108	struct work_struct *work)
...	...	@@ -87,7 +110,7 @@
87	110	unsigned long flags;
88	111
89	112	spin_lock_irqsave(&cwq->lock, flags);
90		- work->wq_data = cwq;
	113	+ set_wq_data(work, cwq);
91	114	list_add_tail(&work->entry, &cwq->worklist);
92	115	cwq->insert_sequence++;
93	116	wake_up(&cwq->more_work);
...	...	@@ -108,7 +131,7 @@
108	131	{
109	132	int ret = 0, cpu = get_cpu();
110	133
111		- if (!test_and_set_bit(0, &work->pending)) {
	134	+ if (!test_and_set_bit(WORK_STRUCT_PENDING, &work->management)) {
112	135	if (unlikely(is_single_threaded(wq)))
113	136	cpu = singlethread_cpu;
114	137	BUG_ON(!list_empty(&work->entry));
...	...	@@ -123,7 +146,7 @@
123	146	static void delayed_work_timer_fn(unsigned long __data)
124	147	{
125	148	struct delayed_work dwork = (struct delayed_work )__data;
126		- struct workqueue_struct *wq = dwork->work.wq_data;
	149	+ struct workqueue_struct *wq = get_wq_data(&dwork->work);
127	150	int cpu = smp_processor_id();
128	151
129	152	if (unlikely(is_single_threaded(wq)))
130	153
...	...	@@ -150,12 +173,12 @@
150	173	if (delay == 0)
151	174	return queue_work(wq, work);
152	175
153		- if (!test_and_set_bit(0, &work->pending)) {
	176	+ if (!test_and_set_bit(WORK_STRUCT_PENDING, &work->management)) {
154	177	BUG_ON(timer_pending(timer));
155	178	BUG_ON(!list_empty(&work->entry));
156	179
157	180	/* This stores wq for the moment, for the timer_fn */
158		- work->wq_data = wq;
	181	+ set_wq_data(work, wq);
159	182	timer->expires = jiffies + delay;
160	183	timer->data = (unsigned long)dwork;
161	184	timer->function = delayed_work_timer_fn;
162	185
...	...	@@ -182,12 +205,12 @@
182	205	struct timer_list *timer = &dwork->timer;
183	206	struct work_struct *work = &dwork->work;
184	207
185		- if (!test_and_set_bit(0, &work->pending)) {
	208	+ if (!test_and_set_bit(WORK_STRUCT_PENDING, &work->management)) {
186	209	BUG_ON(timer_pending(timer));
187	210	BUG_ON(!list_empty(&work->entry));
188	211
189	212	/* This stores wq for the moment, for the timer_fn */
190		- work->wq_data = wq;
	213	+ set_wq_data(work, wq);
191	214	timer->expires = jiffies + delay;
192	215	timer->data = (unsigned long)dwork;
193	216	timer->function = delayed_work_timer_fn;
...	...	@@ -223,8 +246,8 @@
223	246	list_del_init(cwq->worklist.next);
224	247	spin_unlock_irqrestore(&cwq->lock, flags);
225	248
226		- BUG_ON(work->wq_data != cwq);
227		- clear_bit(0, &work->pending);
	249	+ BUG_ON(get_wq_data(work) != cwq);
	250	+ clear_bit(WORK_STRUCT_PENDING, &work->management);
228	251	f(data);
229	252
230	253	spin_lock_irqsave(&cwq->lock, flags);