From 25e985b3e913aad4671a6c32a715f45b1b6be28b Mon Sep 17 00:00:00 2001
From: Taylor R Campbell <riastradh@NetBSD.org>
Date: Wed, 1 Aug 2018 15:10:53 +0000
Subject: [PATCH] Make usb_rem_task_wait return whether it removed from queue
 or not.

- True if it was on the queue and we intercepted it before it ran.
- False if we could not intercept it: either it wasn't queued at all,
  or it already ran.  (Up to caller to distinguish these cases.)

While here, simplify.
---
 sys/dev/usb/usb.c   | 70 ++++++++++++++++++-----------------------------------
 sys/dev/usb/usbdi.h |  2 +-
 2 files changed, 25 insertions(+), 47 deletions(-)

diff --git a/sys/dev/usb/usb.c b/sys/dev/usb/usb.c
index c497b0fbdebe..da40fbb35d76 100644
--- a/sys/dev/usb/usb.c
+++ b/sys/dev/usb/usb.c
@@ -458,28 +458,12 @@ usb_rem_task(struct usbd_device *dev, struct usb_task *task)
 }
 
 /*
- * usb_taskq_wait(taskq, task)
- *
- *	Wait for taskq to finish executing task, if it is executing
- *	task.  Caller must hold the taskq lock.
- */
-static void
-usb_taskq_wait(struct usb_taskq *taskq, struct usb_task *task)
-{
-
-	KASSERT(mutex_owned(&taskq->lock));
-
-	while (taskq->current_task == task)
-		cv_wait(&taskq->cv, &taskq->lock);
-
-	KASSERT(taskq->current_task != task);
-}
-
-/*
  * usb_rem_task_wait(dev, task, queue)
  *
  *	If task is scheduled to run, remove it from the queue.  If it
- *	may have already begun to run, wait for it to complete.
+ *	may have already begun to run, wait for it to complete.  Return
+ *	true if it successfully removed the task from the queue, false
+ *	if not.
  *
  *	Caller MUST guarantee that task will not be scheduled on a
  *	_different_ queue, at least until after this returns.
@@ -490,11 +474,12 @@ usb_taskq_wait(struct usb_taskq *taskq, struct usb_task *task)
  *
  *	May sleep.
  */
-void
+bool
 usb_rem_task_wait(struct usbd_device *dev, struct usb_task *task, int queue)
 {
 	struct usb_taskq *taskq;
 	int queue1;
+	bool removed;
 
 	USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
 	ASSERT_SLEEPABLE();
@@ -502,38 +487,31 @@ usb_rem_task_wait(struct usbd_device *dev, struct usb_task *task, int queue)
 	KASSERT(queue < USB_NUM_TASKQS);
 
 	taskq = &usb_taskq[queue];
-
-	if ((queue1 = task->queue) == USB_NUM_TASKQS) {
+	mutex_enter(&taskq->lock);
+	queue1 = task->queue;
+	if (queue1 == USB_NUM_TASKQS) {
 		/*
-		 * It is not on the queue, but it may have already run.
-		 * Wait for it.
+		 * It is not on the queue.  It may be about to run, or
+		 * it may have already finished running -- there is no
+		 * stopping it now.  Wait for it if it is running.
 		 */
-		mutex_enter(&taskq->lock);
-		usb_taskq_wait(taskq, task);
-		mutex_exit(&taskq->lock);
+		while (taskq->current_task == task)
+			cv_wait(&taskq->cv, &taskq->lock);
+		removed = false;
 	} else {
 		/*
-		 * It may be on the queue (and not another one), but
-		 * the state may have changed by now because we don't
-		 * have the queue locked.  Lock and reload.
+		 * It is still on the queue.  We can stop it before the
+		 * task thread will run it.
 		 */
-		KASSERTMSG(queue1 == queue,
-		    "task %p on q%d expected on q%d", task, queue1, queue);
-		mutex_enter(&taskq->lock);
-		queue1 = task->queue;
-		if (queue1 == queue) {
-			/* Still queued, not run.  Just remove it.  */
-			TAILQ_REMOVE(&taskq->tasks, task, next);
-			task->queue = USB_NUM_TASKQS;
-		} else {
-			/* Already ran.  Wait for it.  */
-			KASSERTMSG(queue1 == USB_NUM_TASKQS,
-			    "task %p on q%d expected on q%d",
-			    task, queue1, queue);
-			usb_taskq_wait(taskq, task);
-		}
-		mutex_exit(&taskq->lock);
+		KASSERTMSG(queue1 == queue, "task %p on q%d expected on q%d",
+		    task, queue1, queue);
+		TAILQ_REMOVE(&taskq->tasks, task, next);
+		task->queue = USB_NUM_TASKQS;
+		removed = true;
 	}
+	mutex_exit(&taskq->lock);
+
+	return removed;
 }
 
 void
diff --git a/sys/dev/usb/usbdi.h b/sys/dev/usb/usbdi.h
index 291e87d1226f..091eabccc4a9 100644
--- a/sys/dev/usb/usbdi.h
+++ b/sys/dev/usb/usbdi.h
@@ -221,7 +221,7 @@ struct usb_task {
 
 void usb_add_task(struct usbd_device *, struct usb_task *, int);
 void usb_rem_task(struct usbd_device *, struct usb_task *);
-void usb_rem_task_wait(struct usbd_device *, struct usb_task *, int);
+bool usb_rem_task_wait(struct usbd_device *, struct usb_task *, int);
 #define usb_init_task(t, f, a, fl) ((t)->fun = (f), (t)->arg = (a), (t)->queue = USB_NUM_TASKQS, (t)->flags = (fl))
 
 struct usb_devno {
-- 
2.11.0