Changeset f3baab1 in mainline

Timestamp:

2018-01-11T21:41:36Z (7 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

49e62998

Parents:

665368c

git-author:

Ondřej Hlavatý <aearsis@…> (2018-01-11 21:41:34)

git-committer:

Ondřej Hlavatý <aearsis@…> (2018-01-11 21:41:36)

Message:

xhci: do not rely on internal fibril quirks

Previousy, we abused the fact new fibrils are spawned for handling
notifications, so we could afford blocking the event handler. We were
told this is a subject to change and we should stop doing it.

This commit removes the abuse, but newly requires event handlers not to
block waiting for another event (e.g. commands do wait for events). To
quickly detect this situation, deadlock detection was added.

This commit breaks current functionality. Our current job is to identify
processes which do block and have them moved to separate fibril / spawn
fibril for the process alone.

Location:

uspace/drv/bus/usb/xhci

Files:

• commands.c (modified) (1 diff)
• hc.c (modified) (3 diffs)
• hc.h (modified) (1 diff)

uspace/drv/bus/usb/xhci/commands.c

@@ -666 +666 @@
         int rv = EOK;
 
+        if (fibril_get_id() == hc->event_handler) {
+                usb_log_error("Deadlock detected in waiting for command.");
+                abort();
+        }
+
         fibril_mutex_lock(&cmd->_header.completed_mtx);
         while (!cmd->_header.completed) {

uspace/drv/bus/usb/xhci/hc.c

@@ -511 +511 @@
 {
         int err;
-        ssize_t size = 16;
-        xhci_trb_t *queue = malloc(sizeof(xhci_trb_t) * size);
-        if (!queue) {
-                usb_log_error("Not enough memory to run the event ring.");
-                return;
-        }
-
-        xhci_trb_t *head = queue;
-
-        while ((err = xhci_event_ring_dequeue(event_ring, head)) != ENOENT) {
-                if (err != EOK) {
-                        usb_log_warning("Error while accessing event ring: %s", str_error(err));
-                        break;
-                }
-
-                usb_log_debug2("Dequeued trb from event ring: %s", xhci_trb_str_type(TRB_TYPE(*head)));
-                head++;
-
-                /* Expand the array if needed. */
-                if (head - queue >= size) {
-                        size *= 2;
-                        xhci_trb_t *new_queue = realloc(queue, size);
-                        if (new_queue == NULL)
-                                break; /* Will process only those TRBs we have memory for. */
-
-                        head = new_queue + (head - queue);
+
+        xhci_trb_t trb;
+        hc->event_handler = fibril_get_id();
+
+        while ((err = xhci_event_ring_dequeue(event_ring, &trb)) != ENOENT) {
+                if ((err = hc_handle_event(hc, &trb, intr)) != EOK) {
+                        usb_log_error("Failed to handle event: %s", str_error(err));
                 }
 
@@ -543 +524 @@
                 XHCI_REG_WR(intr, XHCI_INTR_ERDP_HI, UPPER32(erdp));
         }
+
+        hc->event_handler = 0;
 
         /* Update the ERDP to make room in the ring. */
@@ -551 +534 @@
         XHCI_REG_WR(intr, XHCI_INTR_ERDP_HI, UPPER32(erdp));
 
-        /* Handle all of the collected events if possible. */
-        if (head == queue)
-                usb_log_warning("No events to be handled!");
-
-        for (xhci_trb_t *tail = queue; tail != head; tail++) {
-                if ((err = hc_handle_event(hc, tail, intr)) != EOK) {
-                        usb_log_error("Failed to handle event: %s", str_error(err));
-                }
-        }
-
-        free(queue);
         usb_log_debug2("Event ring run finished.");
 }

uspace/drv/bus/usb/xhci/hc.h

@@ -81 +81 @@
         xhci_bus_t bus;
 
+        /* Fibril that is currently hanling events */
+        fid_t event_handler;
+
         /* Cached capabilities */
         unsigned max_slots;