Changeset 108864 in vbox

Timestamp:

Apr 7, 2025 9:10:44 AM (13 days ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

168314

Message:

VMM/GIC: bugref:10877 GIC ITS command-queue, work-in-progress.

Location:

trunk

Files:

• include/VBox/gic-its.h (modified) (4 diffs)
• src/VBox/VMM/VMMAll/GICAll.cpp (modified) (1 diff)
• src/VBox/VMM/VMMAll/GITSAll.cpp (modified) (8 diffs)
• src/VBox/VMM/VMMR3/GICR3.cpp (modified) (5 diffs)
• src/VBox/VMM/include/GICInternal.h (modified) (2 diffs)
• src/VBox/VMM/include/GITSInternal.h (modified) (4 diffs)

trunk/include/VBox/gic-its.h

@@ -45 +45 @@
 /** Size of the ITS register frame. */
 #define GITS_REG_FRAME_SIZE                                     _64K
+
+/** The GITS command queue page size. */
+#define GITS_CMD_QUEUE_PAGE_SIZE                                0x1000
+/** The GITS command queue page offset mask. */
+#define GITS_CMD_QUEUE_PAGE_OFFSET_MASK                         0xfff
+/** The guest page shift (x86). */
+#define GITS_CMD_QUEUE_PAGE_SHIFT                               12
 
 /** GITS_CTLR: Control register - RW. */
@@ -228 +235 @@
                             (SIZE, RSVD_9_8, SHAREABILITY, PHYS_ADDR, RSVD_52, OUTER_CACHE, RSVD_58_56, INNER_CACHE, RSVD_62,
                              VALID));
+/** GITS_CBASER: Physical address bits [15:12] are reserved MBZ. */
+#define GITS_CTRL_REG_CBASER_PHYS_ADDR_RSVD_15_12_MASK          UINT64_C(0x000000000000f000)
 /** GITS_CBASER: Mask of valid read-write bits. */
 #define GITS_CTRL_REG_CBASER_RW_MASK                            (UINT64_MAX & ~(GITS_BF_CTRL_REG_CBASER_RSVD_9_8_MASK   | \
                                                                                 GITS_BF_CTRL_REG_CBASER_RSVD_52_MASK    | \
                                                                                 GITS_BF_CTRL_REG_CBASER_RSVD_58_56_MASK | \
-                                                                                GITS_BF_CTRL_REG_CBASER_RSVD_62_MASK))
+                                                                                GITS_BF_CTRL_REG_CBASER_RSVD_62_MASK    | \
+                                                                                GITS_CTRL_REG_CBASER_PHYS_ADDR_RSVD_15_12_MASK))
 
 /** GITS_CWRITER: ITS command queue write register - RW. */
@@ -370 +380 @@
 } GITSMEMATTR;
 
-
 /**
- * The ITS entry type.
+ * ITS entry type.
  * In accordance to the ARM GIC spec.
  */
@@ -383 +392 @@
 } GITSITSTYPE;
 
+/** GITS command size in bytes.  */
+#define GITS_CMD_SIZE                                           32
+
+/**
+ * ITS command.
+ * In accordance to the ARM GIC spec.
+ */
+typedef union GITSCMD
+{
+    RTUINT64U au64[4];
+    struct
+    {
+        uint8_t         uCmdId;
+        uint8_t         au8Rsvd[3];
+        uint32_t        uDeviceId;
+
+        uint32_t        uEventId;
+        uint32_t        u32Rsvd;
+
+        uint64_t        au64Rsvd[2];
+    } clear;
+} GITSCMD;
+/** Pointer to an ITS command. */
+typedef GITSCMD *PGITSCMD;
+/** Pointer to a const ITS command. */
+typedef GITSCMD const *PCGITSCMD;
+
+
 #endif /* !VBOX_INCLUDED_gic_its_h */
 

trunk/src/VBox/VMM/VMMAll/GICAll.cpp

@@ -3357 +3357 @@
         /* Control registers space. */
         uint16_t const offReg = off & 0xfffc;
-        gitsMmioWriteCtrl(pGitsDev, offReg, uValue, cb);
+        gitsMmioWriteCtrl(pDevIns, pGitsDev, offReg, uValue, cb);
         LogFlowFunc(("offReg=%#RX16 (%s) written %#RX64\n", offReg, gitsGetCtrlRegDescription(offReg), uValue));
     }

trunk/src/VBox/VMM/VMMAll/GITSAll.cpp

@@ -35 +35 @@
 #include <VBox/log.h>
 #include <VBox/gic.h>
+#include <VBox/vmm/pdmdev.h>
 #include <VBox/vmm/dbgf.h>
 #include <iprt/errcore.h>       /* VINF_SUCCESS */
 #include <iprt/string.h>        /* RT_ZERO */
+#include <iprt/mem.h>           /* RTMemAllocZ, RTMemFree */
 
 
@@ -103 +105 @@
         default:
             return "<UNKNOWN>";
+    }
+}
+
+
+DECL_FORCE_INLINE(bool) gitsCmdQueueIsEmptyEx(PCGITSDEV pGitsDev, uint32_t *poffRead, uint32_t *poffWrite)
+{
+    *poffRead  = pGitsDev->uCmdReadReg  & GITS_BF_CTRL_REG_CREADR_OFFSET_MASK;
+    *poffWrite = pGitsDev->uCmdWriteReg & GITS_BF_CTRL_REG_CWRITER_OFFSET_MASK;
+    return *poffRead == *poffWrite;
+}
+
+
+DECL_HIDDEN_CALLBACK(bool) gitsCmdQueueIsEmpty(PCGITSDEV pGitsDev)
+{
+    uint32_t offRead;
+    uint32_t offWrite;
+    return gitsCmdQueueIsEmptyEx(pGitsDev, &offRead, &offWrite);
+}
+
+
+DECL_HIDDEN_CALLBACK(bool) gitsCmdQueueCanProcessRequests(PCGITSDEV pGitsDev)
+{
+    if (     pGitsDev->fEnabled
+        &&  (pGitsDev->uCmdBaseReg.u & GITS_BF_CTRL_REG_CBASER_VALID_MASK)
+        && !(pGitsDev->uCmdReadReg   & GITS_BF_CTRL_REG_CREADR_STALLED_MASK))
+        return true;
+    return false;
+}
+
+
+static void gitsCmdQueueThreadWakeUpIfNeeded(PPDMDEVINS pDevIns, PGITSDEV pGitsDev)
+{
+    Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo)));
+    if (    gitsCmdQueueCanProcessRequests(pGitsDev)
+        && !gitsCmdQueueIsEmpty(pGitsDev))
+    {
+        int const rc = PDMDevHlpSUPSemEventSignal(pDevIns, pGitsDev->hEvtCmdQueue);
+        AssertRC(rc);
     }
 }
@@ -218 +258 @@
 
 
-DECL_HIDDEN_CALLBACK(void) gitsMmioWriteCtrl(PGITSDEV pGitsDev, uint16_t offReg, uint64_t uValue, unsigned cb)
+DECL_HIDDEN_CALLBACK(void) gitsMmioWriteCtrl(PPDMDEVINS pDevIns, PGITSDEV pGitsDev, uint16_t offReg, uint64_t uValue, unsigned cb)
 {
     Assert(cb == 8 || cb == 4);
@@ -250 +290 @@
             Assert(cb == 4);
             pGitsDev->fEnabled = RT_BF_GET(uValue, GITS_BF_CTRL_REG_CTLR_ENABLED);
+            gitsCmdQueueThreadWakeUpIfNeeded(pDevIns, pGitsDev);
             break;
 
@@ -258 +299 @@
             else
                 pGitsDev->uCmdBaseReg.s.Lo = (uint32_t)uValue;
+            gitsCmdQueueThreadWakeUpIfNeeded(pDevIns, pGitsDev);
             break;
 
@@ -263 +305 @@
             Assert(cb == 4);
             pGitsDev->uCmdBaseReg.s.Hi = uValue & RT_HI_U32(GITS_CTRL_REG_CBASER_RW_MASK);
+            gitsCmdQueueThreadWakeUpIfNeeded(pDevIns, pGitsDev);
             break;
 
         case GITS_CTRL_REG_CWRITER_OFF:
             pGitsDev->uCmdWriteReg = uValue & RT_LO_U32(GITS_CTRL_REG_CWRITER_RW_MASK);
+            gitsCmdQueueThreadWakeUpIfNeeded(pDevIns, pGitsDev);
             break;
 
@@ -272 +316 @@
             /* Upper 32-bits are all reserved, ignore write. Fedora 40 arm64 guests (and probably others) do this. */
             Assert(uValue == 0);
+            gitsCmdQueueThreadWakeUpIfNeeded(pDevIns, pGitsDev);
             break;
 
@@ -371 +416 @@
     }
 }
+
+
+DECL_HIDDEN_CALLBACK(int) gitsR3CmdQueueProcess(PPDMDEVINS pDevIns, PGITSDEV pGitsDev, void *pvBuf, uint32_t cbBuf)
+{
+    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VINF_SUCCESS);
+    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
+
+    if (gitsCmdQueueCanProcessRequests(pGitsDev))
+    {
+        uint32_t   offRead;
+        uint32_t   offWrite;
+        bool const fIsEmpty = gitsCmdQueueIsEmptyEx(pGitsDev, &offRead, &offWrite);
+        if (!fIsEmpty)
+        {
+            uint32_t const cCmdQueuePages = (pGitsDev->uCmdBaseReg.u & GITS_BF_CTRL_REG_CBASER_SIZE_MASK) + 1;
+            uint32_t const cbCmdQueue     = cCmdQueuePages << GITS_CMD_QUEUE_PAGE_SHIFT;
+            AssertRelease(cbCmdQueue <= cbBuf); /** @todo Paranoia; make this a debug assert later. */
+
+#if 0
+            /*
+             * Allocate space for the command-queue if we haven't done so already.
+             */
+            if (pGitsDev->pvCmdQueue != NULL)
+            {
+                if (pGitsDev->cbCmdQueue <= cbCmdQueue)
+                {   /* Already allocated sufficient space. */   }
+                else
+                {
+                    /* Free old allocation and allocate a new one. */
+                    RTMemFree(pGitsDev->pvCmdQueue);
+                    pGitsDev->cbCmdQueue = cbCmdQueue;
+                    pGitsDev->pvCmdQueue = RTMemAllocZ(cbCmdQueue);
+                    if (pGitsDev->pvCmdQueue)
+                    { /* likely */ }
+                    else
+                        return VERR_NO_MEMORY;
+                }
+            }
+            else
+            {
+                /* Allocate one. */
+                pGitsDev->cbCmdQueue = cbCmdQueue;
+                pGitsDev->pvCmdQueue = RTMemAllocZ(cbCmdQueue);
+                if (pGitsDev->pvCmdQueue)
+                { /* likely */ }
+                else
+                    return VERR_NO_MEMORY;
+            }
+#endif
+
+            /*
+             * Read all the commands into the command queue.
+             */
+            RTGCPHYS const GCPhysCmds = pGitsDev->uCmdBaseReg.u & GITS_BF_CTRL_REG_CBASER_PHYS_ADDR_MASK;
+
+            /* Leave the critical section before reading (a potentially large amount of) commands. */
+            PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
+
+            int      rc;
+            uint32_t cbCmds;
+            if (offWrite > offRead)
+            {
+                /* The commands have not wrapped around, read them in one go. */
+                cbCmds = offWrite - offRead;
+                Assert(cbCmds <= cbBuf);
+                rc = PDMDevHlpPhysReadMeta(pDevIns, GCPhysCmds, pvBuf, cbCmds);
+            }
+            else
+            {
+                /* The commands have wrapped around, read forward and wrapped-around. */
+                uint32_t const cbForward = cbCmdQueue - offRead;
+                uint32_t const cbWrapped = offWrite;
+                Assert(cbForward + cbWrapped <= cbBuf);
+                rc  = PDMDevHlpPhysReadMeta(pDevIns, GCPhysCmds, pvBuf, cbForward);
+                if (   RT_SUCCESS(rc)
+                    && cbWrapped > 0)
+                    rc = PDMDevHlpPhysReadMeta(pDevIns, GCPhysCmds + cbForward,
+                                               (void *)((uintptr_t)pvBuf + cbForward), cbWrapped);
+                cbCmds = cbForward + cbWrapped;
+            }
+
+            /* Re-acquire the critical section as we now need to modify device state. */
+            int const rcLock2 = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VINF_SUCCESS);
+            PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock2);
+
+            /*
+             * Process the commands in the queue.
+             */
+            if (RT_SUCCESS(rc))
+            {
+
+                uint32_t const cCmds = cbCmds / GITS_CMD_SIZE;
+                for (uint32_t idxCmd = 0; idxCmd < cCmds; idxCmd++)
+                {
+                    PCGITSCMD pCmd = (PCGITSCMD)((uintptr_t)pvBuf + (idxCmd * sizeof(GITSCMD)));
+                    AssertReleaseMsgFailed(("Cmd=%#x\n", pCmd->clear.uCmdId));
+                }
+
+                PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
+                return VINF_SUCCESS;
+            }
+
+            /* Failed to read command queue from the physical address specified by the guest, stall queue and retry later. */
+
+
+            /** @todo Stall the command queue. */
+            return VINF_TRY_AGAIN;
+        }
+    }
+
+    PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
+    return VINF_SUCCESS;
+}
 #endif /* IN_RING3 */
 

trunk/src/VBox/VMM/VMMR3/GICR3.cpp

@@ -309 +309 @@
         return VINF_SUCCESS;
 
-    PGICDEV pGicDev = PDMDEVINS_2_DATA(pDevIns, PGICDEV);
+    PGICDEV  pGicDev  = PDMDEVINS_2_DATA(pDevIns, PGICDEV);
+    PGITSDEV pGitsDev = &pGicDev->Gits;
     AssertPtrReturn(pGicDev, VERR_INVALID_PARAMETER);
     LogFlowFunc(("Command-queue thread spawned and initialized\n"));
 
     /*
-     * Pre-allocate the maximum size of the command queue allowed by the spec.
-     * This prevents trashing the heap as well as deal with out-of-memory situations
+     * Pre-allocate the maximum size of the command queue allowed by the ARM GIC spec.
+     * This prevents trashing the heap as well as dealing with out-of-memory situations
      * up-front while starting the VM. It also simplifies the code from having to
      * dynamically grow/shrink the allocation based on how software sizes the queue.
      * Guests normally don't alter the queue size all the time, but that's not an
-     * assumption we can make.
-     */
-    uint16_t const cMaxPages  = GITS_BF_CTRL_REG_CBASER_SIZE_MASK + 1;
-    size_t const   cbCmdQueue = cMaxPages << GUEST_PAGE_SHIFT;
-    void *pvCommands = RTMemAllocZ(cbCmdQueue);
-    AssertLogRelMsgReturn(pvCommands, ("Failed to alloc %.Rhcb (%zu bytes) for GITS command queue\n", cbCmdQueue, cbCmdQueue),
+     * assumption we can make. Another benefit is that we can avoid releasing and
+     * re-acquiring the device critical section if/when guests modifies the command
+     * queue size.
+     */
+    uint16_t const cMaxPages = GITS_BF_CTRL_REG_CBASER_SIZE_MASK + 1;
+    size_t const   cbCmds    = cMaxPages << GITS_CMD_QUEUE_PAGE_SHIFT;
+    void *pvCmds = RTMemAllocZ(cbCmds);
+    AssertLogRelMsgReturn(pvCmds, ("Failed to alloc %.Rhcb (%zu bytes) for the GITS command queue\n", cbCmds, cbCmds),
                           VERR_NO_MEMORY);
 
     while (pThread->enmState == PDMTHREADSTATE_RUNNING)
     {
-        /*
-         * Sleep until we are woken up.
-         */
+        /* Sleep until we are woken up. */
         {
-            int const rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pGicDev->hEvtCmdQueue, RT_INDEFINITE_WAIT);
-            AssertLogRelMsgReturnStmt(RT_SUCCESS(rc) || rc == VERR_INTERRUPTED, ("%Rrc\n", rc), RTMemFree(pvCommands), rc);
+            int const rcLock = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pGitsDev->hEvtCmdQueue, RT_INDEFINITE_WAIT);
+            AssertLogRelMsgReturnStmt(RT_SUCCESS(rcLock) || rcLock == VERR_INTERRUPTED, ("%Rrc\n", rcLock),
+                                      RTMemFree(pvCmds), rcLock);
             if (pThread->enmState != PDMTHREADSTATE_RUNNING)
                 break;
         }
 
-        int const rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VINF_SUCCESS);
-        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
-
-        /** @todo Process commands. */
-
-        PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
-    }
-
-    RTMemFree(pvCommands);
+        /* Process the command queue. */
+        int const rc = gitsR3CmdQueueProcess(pDevIns, pGitsDev, pvCmds, cbCmds);
+        if (RT_FAILURE(rc))
+            break;
+    }
+
+    RTMemFree(pvCmds);
 
     LogFlowFunc(("Command-queue thread terminating\n"));
@@ -357 +357 @@
  * Wakes up the command-queue thread so it can respond to a state change.
  *
- * @returns VBox status code.
+ * @return VBox status code.
  * @param   pDevIns     The device instance.
  * @param   pThread     The command-queue thread.
@@ -365 +365 @@
 static DECLCALLBACK(int) gicItsR3CmdQueueThreadWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
 {
-    RT_NOREF2(pDevIns, pThread);
+    RT_NOREF(pThread);
     LogFlowFunc(("\n"));
-    PGICDEV pGicDev = PDMDEVINS_2_DATA(pDevIns, PGICDEV);
-    return PDMDevHlpSUPSemEventSignal(pDevIns, pGicDev->hEvtCmdQueue);
+    PGICDEV  pGicDev  = PDMDEVINS_2_DATA(pDevIns, PGICDEV);
+    PGITSDEV pGitsDev = &pGicDev->Gits;
+    return PDMDevHlpSUPSemEventSignal(pDevIns, pGitsDev->hEvtCmdQueue);
 }
 
@@ -638 +639 @@
     PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
 
-    PGICDEV pGicDev = PDMDEVINS_2_DATA(pDevIns, PGICDEV);
-    if (pGicDev->hEvtCmdQueue != NIL_SUPSEMEVENT)
-    {
-        PDMDevHlpSUPSemEventClose(pDevIns, pGicDev->hEvtCmdQueue);
-        pGicDev->hEvtCmdQueue = NIL_SUPSEMEVENT;
+    PGICDEV  pGicDev  = PDMDEVINS_2_DATA(pDevIns, PGICDEV);
+    PGITSDEV pGitsDev = &pGicDev->Gits;
+    if (pGitsDev->hEvtCmdQueue != NIL_SUPSEMEVENT)
+    {
+        PDMDevHlpSUPSemEventClose(pDevIns, pGitsDev->hEvtCmdQueue);
+        pGitsDev->hEvtCmdQueue = NIL_SUPSEMEVENT;
     }
 
@@ -916 +918 @@
 
             /* Create ITS command-queue thread and semaphore. */
+            PGITSDEV pGitsDev = &pGicDev->Gits;
             char szCmdQueueThread[32];
             RT_ZERO(szCmdQueueThread);
             RTStrPrintf(szCmdQueueThread, sizeof(szCmdQueueThread), "Gits-CmdQ-%u", iInstance);
-            rc = PDMDevHlpThreadCreate(pDevIns, &pGicDev->pCmdQueueThread, &pGicDev, gicItsR3CmdQueueThread,
+            rc = PDMDevHlpThreadCreate(pDevIns, &pGitsDev->pCmdQueueThread, &pGicDev, gicItsR3CmdQueueThread,
                                        gicItsR3CmdQueueThreadWakeUp, 0 /* cbStack */, RTTHREADTYPE_IO, szCmdQueueThread);
             AssertLogRelRCReturn(rc, rc);
 
-            rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pGicDev->hEvtCmdQueue);
+            rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pGitsDev->hEvtCmdQueue);
             AssertLogRelRCReturn(rc, rc);
         }

trunk/src/VBox/VMM/include/GICInternal.h

@@ -34 +34 @@
 #include <VBox/gic.h>
 #include <VBox/vmm/pdmdev.h>
-#include <VBox/vmm/pdmthread.h>
 #include <VBox/vmm/pdmgic.h>
 #include <VBox/vmm/stam.h>
@@ -154 +153 @@
     /** Padding. */
     bool                        afPadding1[7];
-    /** The command-queue thread. */
-    R3PTRTYPE(PPDMTHREAD)       pCmdQueueThread;
-    /** The event semaphore the command-queue thread waits on. */
-    SUPSEMEVENT                 hEvtCmdQueue;
     /** @} */
 

trunk/src/VBox/VMM/include/GITSInternal.h

@@ -32 +32 @@
 #endif
 
+#include <iprt/cdefs.h>
 #include <VBox/types.h>
 #include <VBox/gic-its.h>
+#include <VBox/vmm/pdmthread.h>
 
 /** @defgroup grp_gits_int       Internal
@@ -82 +84 @@
     /** Whether unmapped MSI reporting interrupt is enabled. */
     bool                    fUnmappedMsiReport;
-    /** Whether ITS is quiescent and can be powered down. */
+    /** Whether the ITS is quiescent and can be powered down. */
     bool                    fQuiescent;
     /** Padding. */
@@ -98 +100 @@
     /** @name Interrupt translation space.
      * @{ */
+    /** @} */
+
+    /** @name Command queue thread.
+     * @{ */
+    /** The command-queue thread. */
+    R3PTRTYPE(PPDMTHREAD)   pCmdQueueThread;
+    /** The event semaphore the command-queue thread waits on. */
+    SUPSEMEVENT             hEvtCmdQueue;
     /** @} */
 
@@ -119 +129 @@
 DECL_HIDDEN_CALLBACK(uint64_t)     gitsMmioReadCtrl(PCGITSDEV pGitsDev, uint16_t offReg, unsigned cb);
 DECL_HIDDEN_CALLBACK(uint64_t)     gitsMmioReadTranslate(PCGITSDEV pGitsDev, uint16_t offReg, unsigned cb);
-DECL_HIDDEN_CALLBACK(void)         gitsMmioWriteCtrl(PGITSDEV pGitsDev, uint16_t offReg, uint64_t uValue, unsigned cb);
+DECL_HIDDEN_CALLBACK(void)         gitsMmioWriteCtrl(PPDMDEVINS pDevIns, PGITSDEV pGitsDev, uint16_t offReg, uint64_t uValue, unsigned cb);
 DECL_HIDDEN_CALLBACK(void)         gitsMmioWriteTranslate(PGITSDEV pGitsDev, uint16_t offReg, uint64_t uValue, unsigned cb);
 
 #ifdef IN_RING3
 DECL_HIDDEN_CALLBACK(void)         gitsR3DbgInfo(PCGITSDEV pGitsDev, PCDBGFINFOHLP pHlp, const char *pszArgs);
+DECL_HIDDEN_CALLBACK(int)          gitsR3CmdQueueProcess(PPDMDEVINS pDevIns, PGITSDEV pGitsDev, void *pvBuf, uint32_t cbBuf);
+DECL_HIDDEN_CALLBACK(bool)         gitsR3CmdQueueCanProcessRequests(PCGITSDEV pGitsDev);
+DECL_HIDDEN_CALLBACK(bool)         gitsR3CmdQueueIsEmpty(PCGITSDEV pGitsDev);
 #endif