usb: introduce port status lock

In general we do not want khubd to act on port status changes that are
the result of in progress resets or USB runtime PM operations.
Specifically port power control testing has been able to trigger an
unintended disconnect in hub_port_connect_change(), paraphrasing:

	if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
	    udev->state != USB_STATE_NOTATTACHED) {
		if (portstatus & USB_PORT_STAT_ENABLE) {
			/* Nothing to do */
		} else if (udev->state == USB_STATE_SUSPENDED &&
				udev->persist_enabled) {
			...
		} else {
			/* Don't resuscitate */;
		}
	}

...by falling to the "Don't resuscitate" path or missing
USB_PORT_STAT_CONNECTION because usb_port_resume() was in the middle of
modifying the port status.

So, we want a new lock to hold off khubd for a given port while the
child device is being suspended, resumed, or reset.  The lock ordering
rules are now usb_lock_device() => usb_lock_port().  This is mandated by
the device core which may hold the device_lock on the usb_device before
invoking usb_port_{suspend|resume} which in turn take the status_lock on
the usb_port.  We attempt to hold the status_lock for the duration of a
port_event() run, and drop/re-acquire it when needing to take the
device_lock.  The lock is also dropped/re-acquired during
hub_port_reconnect().

This patch also deletes hub->busy_bits as all use cases are now covered
by port PM runtime synchronization or the port->status_lock and it
pushes down usb_device_lock() into usb_remote_wakeup().

Acked-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

4 files changed, 72 insertions, 37 deletions

diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index b81407518fdf..bec31e2efb88 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -2267,9 +2267,7 @@ static void hcd_resume_work(struct work_struct *work)
         struct usb_hcd *hcd = container_of(work, struct usb_hcd, wakeup_work);
         struct usb_device *udev = hcd->self.root_hub;
 
-        usb_lock_device(udev);
         usb_remote_wakeup(udev);
-        usb_unlock_device(udev);
 }
 
 /**
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 988f227e796f..d43054e8e257 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -2781,6 +2781,20 @@ static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
         return ret;
 }
 
+static void usb_lock_port(struct usb_port *port_dev)
+                __acquires(&port_dev->status_lock)
+{
+        mutex_lock(&port_dev->status_lock);
+        __acquire(&port_dev->status_lock);
+}
+
+static void usb_unlock_port(struct usb_port *port_dev)
+                __releases(&port_dev->status_lock)
+{
+        mutex_unlock(&port_dev->status_lock);
+        __release(&port_dev->status_lock);
+}
+
 #ifdef  CONFIG_PM
 
 /* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
@@ -3003,6 +3017,8 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
         int             status;
         bool            really_suspend = true;
 
+        usb_lock_port(port_dev);
+
         /* enable remote wakeup when appropriate; this lets the device
          * wake up the upstream hub (including maybe the root hub).
          *
@@ -3096,6 +3112,8 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
                 pm_runtime_put_sync(&port_dev->dev);
 
         usb_mark_last_busy(hub->hdev);
+
+        usb_unlock_port(port_dev);
         return status;
 }
 
@@ -3244,13 +3262,13 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
                 }
         }
 
+        usb_lock_port(port_dev);
+
         /* Skip the initial Clear-Suspend step for a remote wakeup */
         status = hub_port_status(hub, port1, &portstatus, &portchange);
         if (status == 0 && !port_is_suspended(hub, portstatus))
                 goto SuspendCleared;
 
-        set_bit(port1, hub->busy_bits);
-
         /* see 7.1.7.7; affects power usage, but not budgeting */
         if (hub_is_superspeed(hub->hdev))
                 status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U0);
@@ -3289,8 +3307,6 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
                 }
         }
 
-        clear_bit(port1, hub->busy_bits);
-
         status = check_port_resume_type(udev,
                         hub, port1, status, portchange, portstatus);
         if (status == 0)
@@ -3308,16 +3324,18 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
                 usb_unlocked_enable_lpm(udev);
         }
 
+        usb_unlock_port(port_dev);
+
         return status;
 }
 
 #ifdef  CONFIG_PM_RUNTIME
 
-/* caller has locked udev */
 int usb_remote_wakeup(struct usb_device *udev)
 {
         int     status = 0;
 
+        usb_lock_device(udev);
         if (udev->state == USB_STATE_SUSPENDED) {
                 dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
                 status = usb_autoresume_device(udev);
@@ -3326,6 +3344,7 @@ int usb_remote_wakeup(struct usb_device *udev)
                         usb_autosuspend_device(udev);
                 }
         }
+        usb_unlock_device(udev);
         return status;
 }
 
@@ -4030,9 +4049,10 @@ static int hub_enable_device(struct usb_device *udev)
  * Returns device in USB_STATE_ADDRESS, except on error.
  *
  * If this is called for an already-existing device (as part of
- * usb_reset_and_verify_device), the caller must own the device lock.  For a
- * newly detected device that is not accessible through any global
- * pointers, it's not necessary to lock the device.
+ * usb_reset_and_verify_device), the caller must own the device lock and
+ * the port lock.  For a newly detected device that is not accessible
+ * through any global pointers, it's not necessary to lock the device,
+ * but it is still necessary to lock the port.
  */
 static int
 hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
@@ -4502,7 +4522,9 @@ static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,
                 }
 
                 /* reset (non-USB 3.0 devices) and get descriptor */
+                usb_lock_port(port_dev);
                 status = hub_port_init(hub, udev, port1, i);
+                usb_unlock_port(port_dev);
                 if (status < 0)
                         goto loop;
 
@@ -4624,6 +4646,7 @@ done:
  */
 static void hub_port_connect_change(struct usb_hub *hub, int port1,
                                         u16 portstatus, u16 portchange)
+                __must_hold(&port_dev->status_lock)
 {
         struct usb_port *port_dev = hub->ports[port1 - 1];
         struct usb_device *udev = port_dev->child;
@@ -4655,26 +4678,29 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                         /* For a suspended device, treat this as a
                          * remote wakeup event.
                          */
-                        usb_lock_device(udev);
+                        usb_unlock_port(port_dev);
                         status = usb_remote_wakeup(udev);
-                        usb_unlock_device(udev);
+                        usb_lock_port(port_dev);
 #endif