[SCSI] add execute_in_process_context() API

We have several points in the SCSI stack (primarily for our device functions) where we need to guarantee process context, but (given the place where the last reference was released) we cannot guarantee this. This API gets around the issue by executing the function directly if the caller has process context, but scheduling a workqueue to execute in process context if the caller doesn't have it. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>

[SCSI] add execute_in_process_context() API
We have several points in the SCSI stack (primarily for our device functions) where we need to guarantee process context, but (given the place where the last reference was released) we cannot guarantee this. This API gets around the issue by executing the function directly if the caller has process context, but scheduling a workqueue to execute in process context if the caller doesn't have it. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
James Bottomley · James Bottomley
1 parent ba3af0aff0
Showing 2 changed files with 35 additions and 0 deletions Side-by-side Diff
include/linux/workqueue.h
kernel/workqueue.c
@@ -20,6 +20,10 @@
 	struct timer_list timer;
 };
  
+struct execute_work {
+	struct work_struct work;
+};
+
 #define __WORK_INITIALIZER(n, f, d) {				\
         .entry	= { &(n).entry, &(n).entry },			\
 	.func = (f),						\
@@ -74,6 +78,8 @@
 void cancel_rearming_delayed_work(struct work_struct *work);
 void cancel_rearming_delayed_workqueue(struct workqueue_struct *,
 				       struct work_struct *);
+int execute_in_process_context(void (*fn)(void *), void *,
+			       struct execute_work *);
  
 /*
  * Kill off a pending schedule_delayed_work().  Note that the work callback
@@ -27,6 +27,7 @@
 #include <linux/cpu.h>
 #include <linux/notifier.h>
 #include <linux/kthread.h>
+#include <linux/hardirq.h>
  
 /*
  * The per-CPU workqueue (if single thread, we always use the first
@@ -475,6 +476,34 @@
 	cancel_rearming_delayed_workqueue(keventd_wq, work);
 }
 EXPORT_SYMBOL(cancel_rearming_delayed_work);
+
+/**
+ * execute_in_process_context - reliably execute the routine with user context
+ * @fn:		the function to execute
+ * @data:	data to pass to the function
+ * @ew:		guaranteed storage for the execute work structure (must
+ *		be available when the work executes)
+ *
+ * Executes the function immediately if process context is available,
+ * otherwise schedules the function for delayed execution.
+ *
+ * Returns:	0 - function was executed
+ *		1 - function was scheduled for execution
+ */
+int execute_in_process_context(void (*fn)(void *data), void *data,
+			       struct execute_work *ew)
+{
+	if (!in_interrupt()) {
+		fn(data);
+		return 0;
+	}
+
+	INIT_WORK(&ew->work, fn, data);
+	schedule_work(&ew->work);
+
+	return 1;
+}
+EXPORT_SYMBOL_GPL(execute_in_process_context);
  
 int keventd_up(void)
 {
...	...	@@ -20,6 +20,10 @@
20	20	struct timer_list timer;
21	21	};
22	22
	23	+struct execute_work {
	24	+ struct work_struct work;
	25	+};
	26	+
23	27	#define __WORK_INITIALIZER(n, f, d) { \
24	28	.entry = { &(n).entry, &(n).entry }, \
25	29	.func = (f), \
...	...	@@ -74,6 +78,8 @@
74	78	void cancel_rearming_delayed_work(struct work_struct *work);
75	79	void cancel_rearming_delayed_workqueue(struct workqueue_struct *,
76	80	struct work_struct *);
	81	+int execute_in_process_context(void (fn)(void ), void *,
	82	+ struct execute_work *);
77	83
78	84	/*
79	85	* Kill off a pending schedule_delayed_work(). Note that the work callback
...	...	@@ -27,6 +27,7 @@
27	27	#include <linux/cpu.h>
28	28	#include <linux/notifier.h>
29	29	#include <linux/kthread.h>
	30	+#include <linux/hardirq.h>
30	31
31	32	/*
32	33	* The per-CPU workqueue (if single thread, we always use the first
...	...	@@ -475,6 +476,34 @@
475	476	cancel_rearming_delayed_workqueue(keventd_wq, work);
476	477	}
477	478	EXPORT_SYMBOL(cancel_rearming_delayed_work);
	479	+
	480	+/**
	481	+ * execute_in_process_context - reliably execute the routine with user context
	482	+ * @fn: the function to execute
	483	+ * @data: data to pass to the function
	484	+ * @ew: guaranteed storage for the execute work structure (must
	485	+ * be available when the work executes)
	486	+ *
	487	+ * Executes the function immediately if process context is available,
	488	+ * otherwise schedules the function for delayed execution.
	489	+ *
	490	+ * Returns: 0 - function was executed
	491	+ * 1 - function was scheduled for execution
	492	+ */
	493	+int execute_in_process_context(void (fn)(void data), void *data,
	494	+ struct execute_work *ew)
	495	+{
	496	+ if (!in_interrupt()) {
	497	+ fn(data);
	498	+ return 0;
	499	+ }
	500	+
	501	+ INIT_WORK(&ew->work, fn, data);
	502	+ schedule_work(&ew->work);
	503	+
	504	+ return 1;
	505	+}
	506	+EXPORT_SYMBOL_GPL(execute_in_process_context);
478	507
479	508	int keventd_up(void)
480	509	{