Changeset 211 for trunk/src/os2ahci/ctxhook.c

Timestamp:

Jul 24, 2023, 5:51:46 PM (2 years ago)

Author:

David Azarewicz

Message:

Added workaround to help with VirtualBox issues.
Improved diagnostic messages.
Changed how timeouts are reset and how ctx hooks are triggered.
Added quirk for devices with issues executing some standard commands.
Changed to make /N the default.

File:

• trunk/src/os2ahci/ctxhook.c (modified) (23 diffs)

trunk/src/os2ahci/ctxhook.c

@@ -4 +4 @@
  * Copyright (c) 2011 thi.guten Software Development
  * Copyright (c) 2011 Mensys B.V.
- * Copyright (c) 2013-2021 David Azarewicz <david@88watts.net>
+ * Copyright (c) 2013-2023 David Azarewicz <david@88watts.net>
  *
  * Authors: Christian Mueller, Markus Thielen
@@ -31 +31 @@
 
 /* port restart context hook and input data */
-ULONG           restart_ctxhook_h;
+ULONG           RestartCtxHook_h;
 volatile u32    ports_to_restart[MAX_AD];
 
 /* port reset context hook and input data */
-ULONG           reset_ctxhook_h;
-ULONG           th_reset_watchdog;
+ULONG           ResetCtxHook_h;
+ULONG           th_watchdog;
 volatile u32    ports_to_reset[MAX_AD];
 IORB_QUEUE      abort_queue;
@@ -42 +42 @@
 /* trigger engine context hook and input data */
 ULONG           engine_ctxhook_h;
+
+#define QUEUEDEPTH 8
+static struct _ctxq_
+{
+  ULONG ulHandle;
+  ULONG ulArg;
+} CtxQueue[QUEUEDEPTH] = {0};
+static ULONG ulCtxStatusFlag = 0;
+
+void SafeArmCtxHook(ULONG ulHandle, ULONG armData)
+{
+  USHORT i;
+
+  i = LockInc(&ulCtxStatusFlag);
+
+  if (i)
+  {
+    i--;
+    if (i < QUEUEDEPTH)
+    {
+      CtxQueue[i].ulHandle = ulHandle;
+      CtxQueue[i].ulArg = armData;
+    }
+  }
+  else
+  {
+    KernArmHook(ulHandle, armData, 0);
+  }
+}
+
+void ClearThreadStatus(ULONG ulHandle)
+{
+  USHORT i;
+
+  i = LockDec(&ulCtxStatusFlag);
+
+  if (i)
+  {
+    i--;
+    if (i < QUEUEDEPTH)
+    {
+      KernArmHook(CtxQueue[i].ulHandle, CtxQueue[i].ulArg, 0);
+    }
+    else
+    {
+      KernArmHook(ulHandle, 0, 0);
+    }
+  }
+}
 
 /******************************************************************************
@@ -78 +127 @@
  * in the interrupt and error handlers.
  */
-void _Syscall restart_ctxhook(ULONG parm)
+void _Syscall RestartCtxHook(ULONG parm)
 {
   IORB_QUEUE done_queue;
@@ -85 +134 @@
   IORBH FAR16DATA *vIorb;
   IORBH FAR16DATA *vNext;
+  IORBH *pIorb;
+  ADD_WORKSPACE *aws;
   u8 *port_mmio;
   int rearm_ctx_hook;
@@ -97 +148 @@
   rearm_ctx_hook = 0;
 
-  DPRINTF(DBG_FUNCBEG, DBG_PREFIX": restart_ctxhook() started\n");
+  AhciStats.ulSoftErrorCount++;
+  DPRINTF(0, DBG_PREFIX": BEG\n");
   memset(&done_queue, 0x00, sizeof(done_queue));
 
   spin_lock(drv_lock);
+
+  if (th_watchdog != 0)
+  {
+    /* watchdog timer still active -- just reset it */
+    Timer_CancelTimer(th_watchdog);
+    th_watchdog = 0;
+  }
 
   for (a = 0; a < ad_info_cnt; a++)
@@ -124 +183 @@
         need_reset = 0;
 
-        DPRINTF(DBG_DETAILED, DBG_PREFIX": port %d, TF_DATA: 0x%x\n", p, readl(port_mmio + PORT_TFDATA));
+        DPRINTF(DBG_DETAILED, DBG_PREFIX": port=%d TF_DATA=0x%x\n", p, readl(port_mmio + PORT_TFDATA));
 
         /* get "current command slot"; only valid if there are no NCQ cmds */
         ccs = (int) ((readl(port_mmio + PORT_CMD) >> 8) & 0x1f);
-        DPRINTF(DBG_DETAILED, DBG_PREFIX": PORT_CMD      = 0x%x\n", ccs);
+        DPRINTF(DBG_DETAILED, DBG_PREFIX": PORT_CMD=0x%x\n", ccs);
 
         for (vIorb = ai->ports[p].iorb_queue.vRoot; vIorb != FAR16NULL; vIorb = vNext)
         {
-          IORBH *pIorb = Far16ToFlat(vIorb);
-          ADD_WORKSPACE *aws = add_workspace(pIorb);
+          pIorb = Far16ToFlat(vIorb);
+          aws = add_workspace(pIorb);
           vNext = pIorb->f16NxtIORB;
 
           if (aws->queued_hw)
           {
+            if (aws->timer != 0)
+            {
+              Timer_CancelTimer(aws->timer);
+              aws->timer = 0;
+            }
+
             if (ai->ports[p].ncq_cmds & (1UL << aws->cmd_slot))
             {
@@ -144 +209 @@
               aws->no_ncq = 1;
               need_reset = 1;
+              DPRINTF(0, DBG_PREFIX": failing IORB: %x NCQ slot=%x\n", vIorb, aws->cmd_slot);
+              #ifdef DEBUG
+              DumpIorb(pIorb, vIorb);
+              #endif
             }
             else
@@ -152 +221 @@
               {
                 /* this is the non-NCQ command that failed */
-                DPRINTF(0, DBG_PREFIX": failing IORB: %x\n", vIorb);
+                DPRINTF(0, DBG_PREFIX": failing IORB: %x slot=%x\n", vIorb, aws->cmd_slot);
+                #ifdef DEBUG
+                DumpIorb(pIorb, vIorb);
+                #endif
                 vProblemIorb = vIorb;
               }
@@ -179 +251 @@
         if (ai->ports[p].ncq_cmds != 0 || ai->ports[p].reg_cmds != 0)
         {
-          DPRINTF(0, DBG_PREFIX": warning: commands issued not 0 (%08lx/%08lx); resetting...\n",
+          DPRINTF(0, DBG_PREFIX": warning: commands issued not 0 (%08x/%08x); resetting...\n",
                   ai->ports[p].ncq_cmds, ai->ports[p].reg_cmds);
           need_reset = 1;
@@ -260 +332 @@
   spin_unlock(drv_lock);
 
+  DPRINTF(0, DBG_PREFIX": Resuming\n");
   /* call notification routine on all IORBs which have completed */
   for (vIorb = done_queue.vRoot; vIorb != FAR16NULL; vIorb = vNext)
   {
-    IORBH *pIorb = Far16ToFlat(vIorb);
+    pIorb = Far16ToFlat(vIorb);
     vNext = pIorb->f16NxtIORB;
 
@@ -278 +351 @@
   spin_unlock(drv_lock);
 
-  DPRINTF(DBG_FUNCEND, DBG_PREFIX": restart_ctxhook() completed\n");
+  DPRINTF(0, DBG_PREFIX": END Rearm=%x\n", rearm_ctx_hook);
 
   /* Check whether we have to rearm ourselves because some adapters were busy
@@ -285 +358 @@
   if (rearm_ctx_hook)
   {
-    msleep(250);
-    KernArmHook(restart_ctxhook_h, 0, 0);
-  }
+    /* we cannot rearm ourself because we will execute immediately leaving
+     * no time to process and clear the reason we need to rearm. Therefore
+     * we set the timer again.
+     */
+    Timer_StartTimerMS(&th_watchdog, 250, WatchdogTimer, RestartCtxHook_h);
+  }
+
+  ClearThreadStatus(RestartCtxHook_h);
   KernThunkStackTo16();
 }
@@ -317 +395 @@
  * the upstream code might reuse the IORBs before we're done with them.
  */
-void _Syscall reset_ctxhook(ULONG parm)
+void _Syscall ResetCtxHook(ULONG ulArg)
 {
   IORB_QUEUE done_queue;
@@ -323 +401 @@
   IORBH FAR16DATA *vIorb;
   IORBH FAR16DATA *vNext;
+  IORBH *pIorb;
+  ADD_WORKSPACE *aws;
   int rearm_ctx_hook;
   int a;
@@ -332 +412 @@
   rearm_ctx_hook = 0;
 
-  DPRINTF(DBG_FUNCBEG, DBG_PREFIX": reset_ctxhook() started\n");
+  AhciStats.ulHardErrorCount++;
+  DPRINTF(0, DBG_PREFIX": BEG Arg=%x\n", ulArg);
   memset(&done_queue, 0x00, sizeof(done_queue));
 
+  if (th_watchdog != 0)
+  {
+    /* watchdog timer still active -- just reset it */
+    Timer_CancelTimer(th_watchdog);
+    th_watchdog = 0;
+  }
+
   spin_lock(drv_lock);
 
-  if (th_reset_watchdog != 0)
-  {
-    /* watchdog timer still active -- just reset it */
-    Timer_CancelTimer(th_reset_watchdog);
-    th_reset_watchdog = 0;
+  if (ulArg)
+  {
+    /* Move the timed-out IORB to the abort queue. Since it's possible that the
+     * IORB has completed after the timeout has expired but before we got to
+     * this line of code, we'll check the return code of iorb_queue_del(): If it
+     * returns an error, the IORB must have completed a few microseconds ago and
+     * there is no timeout.
+     */
+    vIorb = (IORBH FAR16DATA *)CastULONGToFar16(ulArg);
+    pIorb = Far16ToFlat(vIorb);
+    a = iorb_unit_adapter(pIorb);
+    p = iorb_unit_port(pIorb);
+    if (iorb_queue_del(&ad_infos[a].ports[p].iorb_queue, vIorb) == 0)
+    {
+      pIorb = Far16ToFlat(vIorb);
+      iorb_queue_add(&abort_queue, vIorb, pIorb);
+      pIorb->ErrorCode = IOERR_ADAPTER_TIMEOUT;
+    }
   }
 
@@ -347 +448 @@
   for (vIorb = abort_queue.vRoot; vIorb != FAR16NULL; vIorb = vNext)
   {
-    IORBH *pIorb = Far16ToFlat(vIorb);
+    pIorb = Far16ToFlat(vIorb);
     vNext = pIorb->f16NxtIORB;
     a = iorb_unit_adapter(pIorb);
     p = iorb_unit_port(pIorb);
     ai = ad_infos + a;
+    aws = add_workspace(pIorb);
 
     if (ai->busy)
@@ -365 +467 @@
 
     /* reset port if the IORB has already been queued to hardware */
-    if (add_workspace(pIorb)->queued_hw)
-    {
+    if (aws->queued_hw)
+    {
+      if (aws->timer != 0)
+      {
+        Timer_CancelTimer(aws->timer);
+        aws->timer = 0;
+      }
+
       /* prepare port reset */
       ports_to_reset[a] |= (1UL << p);
@@ -411 +519 @@
         {
           IORBH *pIorb = Far16ToFlat(vIorb);
-          ADD_WORKSPACE *aws = add_workspace(pIorb);
           vNext = pIorb->f16NxtIORB;
+
+          aws = add_workspace(pIorb);
 
           if (aws->queued_hw)
@@ -421 +530 @@
               /* we can retry this IORB */
               iorb_requeue(pIorb);
-
             }
             else
@@ -438 +546 @@
   spin_unlock(drv_lock);
 
+  DPRINTF(0, DBG_PREFIX": Resuming\n");
+
   /* complete all aborted IORBs */
   for (vIorb = done_queue.vRoot; vIorb != FAR16NULL; vIorb = vNext)
   {
-    IORBH *pIorb = Far16ToFlat(vIorb);
+    pIorb = Far16ToFlat(vIorb);
     vNext = pIorb->f16NxtIORB;
 
@@ -457 +567 @@
   spin_unlock(drv_lock);
 
-  DPRINTF(DBG_FUNCEND, DBG_PREFIX": reset_ctxhook() completed\n");
+  DPRINTF(0, DBG_PREFIX": END Rearm=%x\n", rearm_ctx_hook);
 
   /* Check whether we have to rearm ourselves because some adapters were busy
@@ -468 +578 @@
      * we set the timer again.
      */
-    //msleep(250);
-    //KernArmHook(reset_ctxhook_h, 0, 0);
-    Timer_StartTimerMS(&th_reset_watchdog, 250, reset_watchdog, 0);
-  }
-
+    Timer_StartTimerMS(&th_watchdog, 250, WatchdogTimer, ResetCtxHook_h);
+  }
+
+  ClearThreadStatus(ResetCtxHook_h);
   KernThunkStackTo16();
 }