Changeset 14332 in vbox for trunk/src/VBox

Timestamp:

Nov 18, 2008 10:11:06 PM (16 years ago)

Author:

vboxsync

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

39535

Message:

SUPDrv,SUPLib: generic ring-0 service interface.

Location:

trunk/src/VBox/HostDrivers/Support

Files:

• SUPDrv.c (modified) (8 diffs)
• SUPDrvIOC.h (modified) (4 diffs)
• SUPDrvInternal.h (modified) (10 diffs)
• SUPLib.cpp (modified) (9 diffs)
• win/SUPDrvA-win.asm (modified) (1 diff)

trunk/src/VBox/HostDrivers/Support/SUPDrv.c

@@ -141 +141 @@
 static int      supdrvLdrAddUsage(PSUPDRVSESSION pSession, PSUPDRVLDRIMAGE pImage);
 static void     supdrvLdrFree(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage);
+static int      supdrvIOCtl_CallServiceModule(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPCALLSERVICE pReq);
 static SUPPAGINGMODE supdrvIOCtl_GetPagingMode(void);
 static SUPGIPMODE supdrvGipDeterminTscMode(PSUPDRVDEVEXT pDevExt);
@@ -160 +161 @@
 DECLASM(int)    supdrvNtWrapModuleInit(PFNRT pfnModuleInit);
 DECLASM(void)   supdrvNtWrapModuleTerm(PFNRT pfnModuleTerm);
+DECLASM(int)    supdrvNtWrapServiceReqHandler(PFNRT pfnServiceReqHandler, PSUPDRVSESSION pSession, uint32_t uOperation, uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr);
 
 DECLASM(int)    UNWIND_WRAP(SUPR0ComponentRegisterFactory)(PSUPDRVSESSION pSession, PCSUPDRVFACTORY pFactory);
@@ -1417 +1419 @@
         }
 
+        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_CALL_SERVICE(0)):
+        {
+            /* validate */
+            PSUPCALLSERVICE pReq = (PSUPCALLSERVICE)pReqHdr;
+            Log4(("SUP_IOCTL_CALL_SERVICE: op=%u in=%u arg=%RX64 p/t=%RTproc/%RTthrd\n",
+                  pReq->u.In.uOperation, pReq->Hdr.cbIn, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
+
+            if (pReq->Hdr.cbIn == SUP_IOCTL_CALL_SERVICE_SIZE(0))
+                REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_SERVICE, SUP_IOCTL_CALL_SERVICE_SIZE_IN(0), SUP_IOCTL_CALL_SERVICE_SIZE_OUT(0));
+            else
+            {
+                PSUPR0SERVICEREQHDR pSrvReq = (PSUPR0SERVICEREQHDR)&pReq->abReqPkt[0];
+                REQ_CHECK_EXPR_FMT(pReq->Hdr.cbIn >= SUP_IOCTL_CALL_SERVICE_SIZE(sizeof(SUPR0SERVICEREQHDR)),
+                                   ("SUP_IOCTL_CALL_SERVICE: cbIn=%#x < %#lx\n", pReq->Hdr.cbIn, SUP_IOCTL_CALL_SERVICE_SIZE(sizeof(SUPR0SERVICEREQHDR))));
+                REQ_CHECK_EXPR(SUP_IOCTL_CALL_SERVICE, pSrvReq->u32Magic == SUPR0SERVICEREQHDR_MAGIC);
+                REQ_CHECK_SIZES_EX(SUP_IOCTL_CALL_SERVICE, SUP_IOCTL_CALL_SERVICE_SIZE_IN(pSrvReq->cbReq), SUP_IOCTL_CALL_SERVICE_SIZE_OUT(pSrvReq->cbReq));
+            }
+            REQ_CHECK_EXPR(SUP_IOCTL_CALL_SERVICE, memchr(pReq->u.In.szName, '\0', sizeof(pReq->u.In.szName)));
+
+            /* execute */
+            pReq->Hdr.rc = supdrvIOCtl_CallServiceModule(pDevExt, pSession, pReq);
+            return 0;
+        }
+
         default:
             Log(("Unknown IOCTL %#lx\n", (long)uIOCtl));
@@ -3713 +3739 @@
     pImage->pfnModuleInit   = NULL;
     pImage->pfnModuleTerm   = NULL;
+    pImage->pfnServiceReqHandler = NULL;
     pImage->uState          = SUP_IOCTL_LDR_OPEN;
     pImage->cUsage          = 1;
@@ -3782 +3809 @@
         case SUPLDRLOADEP_NOTHING:
             break;
+
         case SUPLDRLOADEP_VMMR0:
             if (    !pReq->u.In.EP.VMMR0.pvVMMR0
@@ -3806 +3834 @@
             }
             break;
+
+        case SUPLDRLOADEP_SERVICE:
+            if (!pReq->u.In.EP.Service.pfnServiceReq)
+            {
+                RTSemFastMutexRelease(pDevExt->mtxLdr);
+                Log(("NULL pointer: pfnServiceReq=%p!\n", pReq->u.In.EP.Service.pfnServiceReq));
+                return VERR_INVALID_PARAMETER;
+            }
+            if ((uintptr_t)pReq->u.In.EP.Service.pfnServiceReq  - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage)
+            {
+                RTSemFastMutexRelease(pDevExt->mtxLdr);
+                Log(("Out of range (%p LB %#x): pfnServiceReq=%p, pvVMMR0EntryFast=%p or pvVMMR0EntryEx=%p is NULL!\n",
+                     pImage->pvImage, pReq->u.In.cbImage, pReq->u.In.EP.Service.pfnServiceReq));
+                return VERR_INVALID_PARAMETER;
+            }
+            if (    pReq->u.In.EP.Service.apvReserved[0] != NIL_RTR0PTR
+                ||  pReq->u.In.EP.Service.apvReserved[1] != NIL_RTR0PTR
+                ||  pReq->u.In.EP.Service.apvReserved[2] != NIL_RTR0PTR)
+            {
+                RTSemFastMutexRelease(pDevExt->mtxLdr);
+                Log(("Out of range (%p LB %#x): apvReserved={%p,%p,%p} MBZ!\n",
+                     pImage->pvImage, pReq->u.In.cbImage,
+                     pReq->u.In.EP.Service.apvReserved[0],
+                     pReq->u.In.EP.Service.apvReserved[1],
+                     pReq->u.In.EP.Service.apvReserved[2]));
+                return VERR_INVALID_PARAMETER;
+            }
+            break;
+
         default:
             RTSemFastMutexRelease(pDevExt->mtxLdr);
@@ -3853 +3910 @@
             rc = supdrvLdrSetR0EP(pDevExt, pReq->u.In.EP.VMMR0.pvVMMR0, pReq->u.In.EP.VMMR0.pvVMMR0EntryInt,
                                   pReq->u.In.EP.VMMR0.pvVMMR0EntryFast, pReq->u.In.EP.VMMR0.pvVMMR0EntryEx);
+            break;
+        case SUPLDRLOADEP_SERVICE:
+            pImage->pfnServiceReqHandler = pReq->u.In.EP.Service.pfnServiceReq;
+            rc = VINF_SUCCESS;
             break;
     }
@@ -4349 +4410 @@
     pImage->uState = SUP_IOCTL_LDR_FREE;
     RTMemExecFree(pImage);
+}
+
+
+/**
+ * Implements the service call request.
+ *
+ * @returns VBox status code.
+ * @param   pDevExt         The device extension.
+ * @param   pSession        The calling session.
+ * @param   pReq            The request packet, valid.
+ */
+static int supdrvIOCtl_CallServiceModule(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPCALLSERVICE pReq)
+{
+#if !defined(RT_OS_WINDOWS) || defined(DEBUG)
+    int rc;
+
+    /*
+     * Find the module first in the module referenced by the calling session.
+     */
+    rc = RTSemFastMutexRequest(pDevExt->mtxLdr);
+    if (RT_SUCCESS(rc))
+    {
+        PFNSUPR0SERVICEREQHANDLER   pfnServiceReqHandler = NULL;
+        PSUPDRVLDRUSAGE             pUsage;
+
+        for (pUsage = pSession->pLdrUsage; pUsage; pUsage = pUsage->pNext)
+            if (    pUsage->pImage->pfnServiceReqHandler
+                &&  !strcmp(pUsage->pImage->szName, pReq->u.In.szName))
+            {
+                pfnServiceReqHandler = pUsage->pImage->pfnServiceReqHandler;
+                break;
+            }
+        RTSemFastMutexRelease(pDevExt->mtxLdr);
+
+        if (pfnServiceReqHandler)
+        {
+            /*
+             * Call it.
+             */
+            if (pReq->Hdr.cbIn == SUP_IOCTL_CALL_SERVICE_SIZE(0))
+#ifdef RT_WITH_W64_UNWIND_HACK
+                rc = supdrvNtWrapServiceReqHandler((PRNRT)pfnServiceReqHandler, pSession, pReq->u.In.uOperation, pReq->u.In.u64Arg, NULL);
+#else
+                rc = pfnServiceReqHandler(pSession, pReq->u.In.uOperation, pReq->u.In.u64Arg, NULL);
+#endif
+            else
+#ifdef RT_WITH_W64_UNWIND_HACK
+                rc = supdrvNtWrapServiceReqHandler((PRNRT)pfnServiceReqHandler, pSession, pReq->u.In.uOperation,
+                                                   pReq->u.In.u64Arg, (PSUPR0SERVICEREQHDR)&pReq->abReqPkt[0]);
+#else
+                rc = pfnServiceReqHandler(pSession, pReq->u.In.uOperation, pReq->u.In.u64Arg, (PSUPR0SERVICEREQHDR)&pReq->abReqPkt[0]);
+#endif
+        }
+        else
+            rc = VERR_SUPDRV_SERVICE_NOT_FOUND;
+    }
+
+    /* log it */
+    if (    RT_FAILURE(rc)
+        &&  rc != VERR_INTERRUPTED
+        &&  rc != VERR_TIMEOUT)
+        Log(("SUP_IOCTL_CALL_SERVICE: rc=%Rrc op=%u out=%u arg=%RX64 p/t=%RTproc/%RTthrd\n",
+             rc, pReq->u.In.uOperation, pReq->Hdr.cbOut, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
+    else
+        Log4(("SUP_IOCTL_CALL_SERVICE: rc=%Rrc op=%u out=%u arg=%RX64 p/t=%RTproc/%RTthrd\n",
+              rc, pReq->u.In.uOperation, pReq->Hdr.cbOut, pReq->u.In.u64Arg, RTProcSelf(), RTThreadNativeSelf()));
+    return rc;
+#else  /* RT_OS_WINDOWS && !DEBUG */
+    return VERR_NOT_IMPLEMENTED;
+#endif /* RT_OS_WINDOWS && !DEBUG */
 }
 

trunk/src/VBox/HostDrivers/Support/SUPDrvIOC.h

@@ -182 +182 @@
  * The upper 16-bit is the major version, the the lower the minor version.
  * When incompatible changes are made, the upper major number has to be changed. */
-#define SUPDRV_IOC_VERSION                              0x000A0000
+#define SUPDRV_IOC_VERSION                              0x000a0001
 
 /** SUP_IOCTL_COOKIE. */
@@ -383 +383 @@
     SUPLDRLOADEP_NOTHING = 0,
     SUPLDRLOADEP_VMMR0,
+    SUPLDRLOADEP_SERVICE,
     SUPLDRLOADEP_32BIT_HACK = 0x7fffffff
 } SUPLDRLOADEP;
@@ -401 +402 @@
             union
             {
+                /** SUPLDRLOADEP_VMMR0. */
                 struct
                 {
                     /** The module handle (i.e. address). */
-                    RTR0PTR         pvVMMR0;
+                    RTR0PTR                 pvVMMR0;
                     /** Address of VMMR0EntryInt function. */
-                    RTR0PTR         pvVMMR0EntryInt;
+                    RTR0PTR                 pvVMMR0EntryInt;
                     /** Address of VMMR0EntryFast function. */
-                    RTR0PTR         pvVMMR0EntryFast;
+                    RTR0PTR                 pvVMMR0EntryFast;
                     /** Address of VMMR0EntryEx function. */
-                    RTR0PTR         pvVMMR0EntryEx;
+                    RTR0PTR                 pvVMMR0EntryEx;
                 } VMMR0;
+                /** SUPLDRLOADEP_SERVICE. */
+                struct
+                {
+                    /** The service request handler.
+                     * (PFNR0SERVICEREQHANDLER isn't defined yet.) */
+                    RTR0PTR                 pfnServiceReq;
+                    /** Reserved, must be NIL. */
+                    RTR0PTR                 apvReserved[3];
+                } Service;
             }               EP;
             /** Address. */
@@ -844 +855 @@
 
 
+/** @name SUP_IOCTL_CALL_SERVICE
+ * Call the a ring-0 service.
+ *
+ * @todo    Might have to convert this to a big request, just like
+ *          SUP_IOCTL_CALL_VMMR0
+ * @{
+ */
+#define SUP_IOCTL_CALL_SERVICE(cbReq)                   SUP_CTL_CODE_SIZE(22, SUP_IOCTL_CALL_SERVICE_SIZE(cbReq))
+#define SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)              RT_UOFFSETOF(SUPCALLSERVICE, abReqPkt[cbReq])
+#define SUP_IOCTL_CALL_SERVICE_SIZE_IN(cbReq)           SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
+#define SUP_IOCTL_CALL_SERVICE_SIZE_OUT(cbReq)          SUP_IOCTL_CALL_SERVICE_SIZE(cbReq)
+typedef struct SUPCALLSERVICE
+{
+    /** The header. */
+    SUPREQHDR               Hdr;
+    union
+    {
+        struct
+        {
+            /** The service name. */
+            char            szName[28];
+            /** Which operation to execute. */
+            uint32_t        uOperation;
+            /** Argument to use when no request packet is supplied. */
+            uint64_t        u64Arg;
+        } In;
+    } u;
+    /** The request packet passed to SUP. */
+    uint8_t                 abReqPkt[1];
+} SUPCALLSERVICE, *PSUPCALLSERVICE;
+/** @} */
+
+
 #pragma pack()                          /* paranoia */
 

trunk/src/VBox/HostDrivers/Support/SUPDrvInternal.h

@@ -347 +347 @@
 #define SUPDRV_PATCH_CODE_SIZE  0x50
     /** Patch code. */
-    uint8_t                 auCode[SUPDRV_PATCH_CODE_SIZE];
+    uint8_t                         auCode[SUPDRV_PATCH_CODE_SIZE];
     /** Changed IDT entry (for parnoid UnpatchIdt()). */
-    SUPDRVIDTE              ChangedIdt;
+    SUPDRVIDTE                      ChangedIdt;
     /** Saved IDT entry. */
-    SUPDRVIDTE              SavedIdt;
+    SUPDRVIDTE                      SavedIdt;
     /** Pointer to the IDT.
      * We ASSUME the IDT is not re(al)located after bootup and use this as key
@@ -360 +360 @@
      * the(se) page(s), but we'll find that out soon enough in VBOX_STRICT mode.
      */
-    void                   *pvIdt;
+    void                           *pvIdt;
     /** Pointer to the IDT entry. */
-    SUPDRVIDTE volatile    *pIdtEntry;
+    SUPDRVIDTE volatile            *pIdtEntry;
     /** Usage counter. */
-    uint32_t volatile       cUsage;
+    uint32_t volatile               cUsage;
     /** The offset into auCode of the VMMR0Entry fixup. */
-    uint16_t                offVMMR0EntryFixup;
+    uint16_t                        offVMMR0EntryFixup;
     /** The offset into auCode of the stub function. */
-    uint16_t                offStub;
+    uint16_t                        offStub;
     /** Pointer to the next patch. */
     struct SUPDRVPATCH * volatile pNext;
@@ -381 +381 @@
     struct SUPDRVPATCHUSAGE * volatile pNext;
     /** The patch this usage applies to. */
-    PSUPDRVPATCH        pPatch;
+    PSUPDRVPATCH                    pPatch;
     /** Usage count. */
-    uint32_t volatile   cUsage;
+    uint32_t volatile               cUsage;
 } SUPDRVPATCHUSAGE, *PSUPDRVPATCHUSAGE;
 
@@ -418 +418 @@
 {
     /** The memory object handle. */
-    RTR0MEMOBJ          MemObj;
+    RTR0MEMOBJ                      MemObj;
     /** The ring-3 mapping memory object handle. */
-    RTR0MEMOBJ          MapObjR3;
+    RTR0MEMOBJ                      MapObjR3;
     /** Type of memory. */
-    SUPDRVMEMREFTYPE    eType;
+    SUPDRVMEMREFTYPE                eType;
 } SUPDRVMEMREF, *PSUPDRVMEMREF;
 
@@ -432 +432 @@
 {
     /** Pointer to the next bundle. */
-    struct SUPDRVBUNDLE * volatile pNext;
+    struct SUPDRVBUNDLE * volatile  pNext;
     /** Referenced memory. */
-    SUPDRVMEMREF        aMem[64];
+    SUPDRVMEMREF                    aMem[64];
     /** Number of entries used. */
     uint32_t volatile   cUsed;
@@ -448 +448 @@
     struct SUPDRVLDRIMAGE * volatile pNext;
     /** Pointer to the image. */
-    void               *pvImage;
+    void                           *pvImage;
     /** Pointer to the optional module initialization callback. */
-    PFNR0MODULEINIT     pfnModuleInit;
+    PFNR0MODULEINIT                 pfnModuleInit;
     /** Pointer to the optional module termination callback. */
-    PFNR0MODULETERM     pfnModuleTerm;
+    PFNR0MODULETERM                 pfnModuleTerm;
+    /** Service request handler. This is NULL for non-service modules. */
+    PFNSUPR0SERVICEREQHANDLER       pfnServiceReqHandler;
     /** Size of the image. */
-    uint32_t            cbImage;
+    uint32_t                        cbImage;
     /** The offset of the symbol table. */
-    uint32_t            offSymbols;
+    uint32_t                        offSymbols;
     /** The number of entries in the symbol table. */
-    uint32_t            cSymbols;
+    uint32_t                        cSymbols;
     /** The offset of the string table. */
-    uint32_t            offStrTab;
+    uint32_t                        offStrTab;
     /** Size of the string table. */
-    uint32_t            cbStrTab;
+    uint32_t                        cbStrTab;
     /** The ldr image state. (IOCtl code of last opration.) */
-    uint32_t            uState;
+    uint32_t                        uState;
     /** Usage count. */
-    uint32_t volatile   cUsage;
+    uint32_t volatile               cUsage;
     /** Image name. */
-    char                szName[32];
+    char                            szName[32];
 } SUPDRVLDRIMAGE, *PSUPDRVLDRIMAGE;
 
@@ -478 +480 @@
     struct SUPDRVLDRUSAGE * volatile pNext;
     /** The image. */
-    PSUPDRVLDRIMAGE     pImage;
+    PSUPDRVLDRIMAGE                 pImage;
     /** Load count. */
-    uint32_t volatile   cUsage;
+    uint32_t volatile               cUsage;
 } SUPDRVLDRUSAGE, *PSUPDRVLDRUSAGE;
 
@@ -490 +492 @@
 {
     /** Pointer to the next registration. */
-    struct SUPDRVFACTORYREG    *pNext;
+    struct SUPDRVFACTORYREG        *pNext;
     /** Pointer to the registered factory. */
-    PCSUPDRVFACTORY             pFactory;
+    PCSUPDRVFACTORY                 pFactory;
     /** The session owning the factory.
      * Used for deregistration and session cleanup. */
-    PSUPDRVSESSION              pSession;
+    PSUPDRVSESSION                  pSession;
     /** Length of the name. */
-    size_t                      cchName;
+    size_t                          cchName;
 } SUPDRVFACTORYREG;
 /** Pointer to a component factory registration record. */
@@ -558 +560 @@
 {
     /** Pointer to the device extension. */
-    PSUPDRVDEVEXT               pDevExt;
+    PSUPDRVDEVEXT                   pDevExt;
     /** Session Cookie. */
-    uint32_t                    u32Cookie;
+    uint32_t                        u32Cookie;
 
     /** Load usage records. (protected by SUPDRVDEVEXT::mtxLdr) */
-    PSUPDRVLDRUSAGE volatile    pLdrUsage;
+    PSUPDRVLDRUSAGE volatile        pLdrUsage;
 #ifdef VBOX_WITH_IDT_PATCHING
     /** Patch usage records. (protected by SUPDRVDEVEXT::SpinLock) */
-    PSUPDRVPATCHUSAGE volatile  pPatchUsage;
+    PSUPDRVPATCHUSAGE volatile      pPatchUsage;
 #endif
     /** The VM associated with the session. */
-    PVM                         pVM;
+    PVM                             pVM;
     /** List of generic usage records. (protected by SUPDRVDEVEXT::SpinLock) */
-    PSUPDRVUSAGE volatile       pUsage;
+    PSUPDRVUSAGE volatile           pUsage;
 
     /** Spinlock protecting the bundles and the GIP members. */
-    RTSPINLOCK                  Spinlock;
+    RTSPINLOCK                      Spinlock;
     /** The ring-3 mapping of the GIP (readonly). */
-    RTR0MEMOBJ                  GipMapObjR3;
+    RTR0MEMOBJ                      GipMapObjR3;
     /** Set if the session is using the GIP. */
-    uint32_t                    fGipReferenced;
+    uint32_t                        fGipReferenced;
     /** Bundle of locked memory objects. */
-    SUPDRVBUNDLE                Bundle;
+    SUPDRVBUNDLE                    Bundle;
 
     /** The user id of the session. (Set by the OS part.) */
-    RTUID                       Uid;
+    RTUID                           Uid;
     /** The group id of the session. (Set by the OS part.) */
-    RTGID                       Gid;
+    RTGID                           Gid;
     /** The process (id) of the session. */
-    RTPROCESS                   Process;
+    RTPROCESS                       Process;
     /** Which process this session is associated with.
      * This is NIL_RTR0PROCESS for kernel sessions and valid for user ones. */
-    RTR0PROCESS                 R0Process;
+    RTR0PROCESS                     R0Process;
 #if defined(RT_OS_DARWIN)
     /** Pointer to the associated org_virtualbox_SupDrvClient object. */
-    void                       *pvSupDrvClient;
+    void                           *pvSupDrvClient;
     /** Whether this session has been opened or not. */
-    bool                        fOpened;
+    bool                            fOpened;
 #endif
 #if defined(RT_OS_OS2)
     /** The system file number of this session. */
-    uint16_t                    sfn;
-    uint16_t                    Alignment; /**< Alignment */
+    uint16_t                        sfn;
+    uint16_t                        Alignment; /**< Alignment */
 #endif
 #if defined(RT_OS_DARWIN) || defined(RT_OS_OS2) || defined(RT_OS_SOLARIS)
     /** Pointer to the next session with the same hash. */
-    PSUPDRVSESSION              pNextHash;
+    PSUPDRVSESSION                  pNextHash;
 #endif
 } SUPDRVSESSION;
@@ -616 +618 @@
     /** Spinlock to serialize the initialization,
      * usage counting and destruction of the IDT entry override and objects. */
-    RTSPINLOCK              Spinlock;
+    RTSPINLOCK                      Spinlock;
 
 #ifdef VBOX_WITH_IDT_PATCHING
     /** List of patches. */
-    PSUPDRVPATCH volatile   pIdtPatches;
+    PSUPDRVPATCH volatile           pIdtPatches;
     /** List of patches Free. */
-    PSUPDRVPATCH volatile   pIdtPatchesFree;
+    PSUPDRVPATCH volatile           pIdtPatchesFree;
 #endif
 
     /** List of registered objects. Protected by the spinlock. */
-    PSUPDRVOBJ volatile     pObjs;
+    PSUPDRVOBJ volatile             pObjs;
     /** List of free object usage records. */
-    PSUPDRVUSAGE volatile   pUsageFree;
+    PSUPDRVUSAGE volatile           pUsageFree;
 
     /** Global cookie. */
-    uint32_t                u32Cookie;
+    uint32_t                        u32Cookie;
 
     /** The IDT entry number.
      * Only valid if pIdtPatches is set. */
-    uint8_t volatile        u8Idt;
+    uint8_t volatile                u8Idt;
 
     /** Loader mutex.
      * This protects pvVMMR0, pvVMMR0Entry, pImages and SUPDRVSESSION::pLdrUsage. */
-    RTSEMFASTMUTEX          mtxLdr;
+    RTSEMFASTMUTEX                  mtxLdr;
 
     /** VMM Module 'handle'.
      * 0 if the code VMM isn't loaded and Idt are nops. */
-    void * volatile         pvVMMR0;
+    void * volatile                 pvVMMR0;
     /** VMMR0EntryInt() pointer. */
-    DECLR0CALLBACKMEMBER(int, pfnVMMR0EntryInt, (PVM pVM, unsigned uOperation, void *pvArg));
+    DECLR0CALLBACKMEMBER(int,       pfnVMMR0EntryInt, (PVM pVM, unsigned uOperation, void *pvArg));
     /** VMMR0EntryFast() pointer. */
-    DECLR0CALLBACKMEMBER(void, pfnVMMR0EntryFast, (PVM pVM, unsigned idCpu, unsigned uOperation));
+    DECLR0CALLBACKMEMBER(void,      pfnVMMR0EntryFast, (PVM pVM, unsigned idCpu, unsigned uOperation));
     /** VMMR0EntryEx() pointer. */
-    DECLR0CALLBACKMEMBER(int, pfnVMMR0EntryEx, (PVM pVM, unsigned uOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION pSession));
+    DECLR0CALLBACKMEMBER(int,       pfnVMMR0EntryEx, (PVM pVM, unsigned uOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION pSession));
 
     /** Linked list of loaded code. */
-    PSUPDRVLDRIMAGE volatile pLdrImages;
+    PSUPDRVLDRIMAGE volatile        pLdrImages;
 
     /** GIP mutex.
      * Any changes to any of the GIP members requires ownership of this mutex,
      * except on driver init and termination. */
-    RTSEMFASTMUTEX          mtxGip;
+    RTSEMFASTMUTEX                  mtxGip;
     /** Pointer to the Global Info Page (GIP). */
-    PSUPGLOBALINFOPAGE      pGip;
+    PSUPGLOBALINFOPAGE              pGip;
     /** The physical address of the GIP. */
-    RTHCPHYS                HCPhysGip;
+    RTHCPHYS                        HCPhysGip;
     /** Number of processes using the GIP.
      * (The updates are suspend while cGipUsers is 0.)*/
-    uint32_t volatile       cGipUsers;
+    uint32_t volatile               cGipUsers;
     /** The ring-0 memory object handle for the GIP page. */
-    RTR0MEMOBJ              GipMemObj;
+    RTR0MEMOBJ                      GipMemObj;
     /** The GIP timer handle. */
-    PRTTIMER                pGipTimer;
+    PRTTIMER                        pGipTimer;
     /** If non-zero we've successfully called RTTimerRequestSystemGranularity(). */
-    uint32_t                u32SystemTimerGranularityGrant;
+    uint32_t                        u32SystemTimerGranularityGrant;
     /** The CPU id of the GIP master.
      * This CPU is responsible for the updating the common GIP data. */
-    RTCPUID volatile        idGipMaster;
+    RTCPUID volatile                idGipMaster;
 
 #ifdef RT_OS_WINDOWS
     /* Callback object returned by ExCreateCallback. */
-    PCALLBACK_OBJECT        pObjPowerCallback;
+    PCALLBACK_OBJECT                pObjPowerCallback;
     /* Callback handle returned by ExRegisterCallback. */
-    PVOID                   hPowerCallback;
+    PVOID                           hPowerCallback;
 #endif
 
     /** Component factory mutex.
      * This protects pComponentFactoryHead and component factory querying. */
-    RTSEMFASTMUTEX          mtxComponentFactory;
+    RTSEMFASTMUTEX                  mtxComponentFactory;
     /** The head of the list of registered component factories. */
-    PSUPDRVFACTORYREG       pComponentFactoryHead;
+    PSUPDRVFACTORYREG               pComponentFactoryHead;
 } SUPDRVDEVEXT;
 

trunk/src/VBox/HostDrivers/Support/SUPLib.cpp

@@ -151 +151 @@
 *******************************************************************************/
 static int supInitFake(PSUPDRVSESSION *ppSession);
-static int supLoadModule(const char *pszFilename, const char *pszModule, void **ppvImageBase);
+static int supLoadModule(const char *pszFilename, const char *pszModule, const char *pszSrvReqHandler, void **ppvImageBase);
 #ifdef VBOX_WITH_IDT_PATCHING
 static int supInstallIDTE(void);
@@ -679 +679 @@
 
 
+SUPR3DECL(int) SUPR3CallR0Service(const char *pszService, size_t cchService, uint32_t uOperation, uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr)
+{
+    AssertReturn(cchService < RT_SIZEOFMEMB(SUPCALLSERVICE, u.In.szName), VERR_INVALID_PARAMETER);
+    Assert(strlen(pszService) == cchService);
+
+    /* fake */
+    if (RT_UNLIKELY(g_u32FakeMode))
+        return VERR_NOT_SUPPORTED;
+
+    int rc;
+    if (!pReqHdr)
+    {
+        /* no data. */
+        SUPCALLSERVICE Req;
+        Req.Hdr.u32Cookie = g_u32Cookie;
+        Req.Hdr.u32SessionCookie = g_u32SessionCookie;
+        Req.Hdr.cbIn = SUP_IOCTL_CALL_SERVICE_SIZE_IN(0);
+        Req.Hdr.cbOut = SUP_IOCTL_CALL_SERVICE_SIZE_OUT(0);
+        Req.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
+        Req.Hdr.rc = VERR_INTERNAL_ERROR;
+        memcpy(Req.u.In.szName, pszService, cchService);
+        Req.u.In.szName[cchService] = '\0';
+        Req.u.In.uOperation = uOperation;
+        Req.u.In.u64Arg = u64Arg;
+        rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_CALL_SERVICE(0), &Req, SUP_IOCTL_CALL_SERVICE_SIZE(0));
+        if (RT_SUCCESS(rc))
+            rc = Req.Hdr.rc;
+    }
+    else if (SUP_IOCTL_CALL_SERVICE_SIZE(pReqHdr->cbReq) < _4K) /* FreeBSD won't copy more than 4K. */
+    {
+        AssertPtrReturn(pReqHdr, VERR_INVALID_POINTER);
+        AssertReturn(pReqHdr->u32Magic == SUPR0SERVICEREQHDR_MAGIC, VERR_INVALID_MAGIC);
+        const size_t cbReq = pReqHdr->cbReq;
+
+        PSUPCALLSERVICE pReq = (PSUPCALLSERVICE)alloca(SUP_IOCTL_CALL_SERVICE_SIZE(cbReq));
+        pReq->Hdr.u32Cookie = g_u32Cookie;
+        pReq->Hdr.u32SessionCookie = g_u32SessionCookie;
+        pReq->Hdr.cbIn = SUP_IOCTL_CALL_SERVICE_SIZE_IN(cbReq);
+        pReq->Hdr.cbOut = SUP_IOCTL_CALL_SERVICE_SIZE_OUT(cbReq);
+        pReq->Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
+        pReq->Hdr.rc = VERR_INTERNAL_ERROR;
+        memcpy(pReq->u.In.szName, pszService, cchService);
+        pReq->u.In.szName[cchService] = '\0';
+        pReq->u.In.uOperation = uOperation;
+        pReq->u.In.u64Arg = u64Arg;
+        memcpy(&pReq->abReqPkt[0], pReqHdr, cbReq);
+        rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_CALL_SERVICE(cbReq), pReq, SUP_IOCTL_CALL_SERVICE_SIZE(cbReq));
+        if (RT_SUCCESS(rc))
+            rc = pReq->Hdr.rc;
+        memcpy(pReqHdr, &pReq->abReqPkt[0], cbReq);
+    }
+    else /** @todo may have to remove the size limits one this request... */
+        AssertMsgFailedReturn(("cbReq=%#x\n", pReqHdr->cbReq), VERR_INTERNAL_ERROR);
+    return rc;
+}
+
+
 SUPR3DECL(int) SUPPageAlloc(size_t cPages, void **ppvPages)
 {
@@ -1180 +1237 @@
          * If it's VMMR0.r0 we need to install the IDTE.
          */
-        rc = supLoadModule(pszFilename, pszModule, ppvImageBase);
+        rc = supLoadModule(pszFilename, pszModule, NULL, ppvImageBase);
 #ifdef VBOX_WITH_IDT_PATCHING
         if (    RT_SUCCESS(rc)
@@ -1193 +1250 @@
     else
         LogRel(("SUPLoadModule: Verification of \"%s\" failed, rc=%Rrc\n", rc));
+    return rc;
+}
+
+
+SUPR3DECL(int) SUPR3LoadServiceModule(const char *pszFilename, const char *pszModule,
+                                      const char *pszSrvReqHandler, void **ppvImageBase)
+{
+    int rc = VINF_SUCCESS;
+    AssertPtrReturn(pszSrvReqHandler, VERR_INVALID_PARAMETER);
+
+#ifdef VBOX_WITH_HARDENING
+    /*
+     * Check that the module can be trusted.
+     */
+    rc = supR3HardenedVerifyFile(pszFilename, false /* fFatal */);
+#endif
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Load the module.
+         * If it's VMMR0.r0 we need to install the IDTE.
+         */
+        rc = supLoadModule(pszFilename, pszModule, pszSrvReqHandler, ppvImageBase);
+    }
+    else
+        LogRel(("SUPR3LoadServiceModule: Verification of \"%s\" failed, rc=%Rrc\n", rc));
     return rc;
 }
@@ -1569 +1652 @@
  * @param   pszFilename     Name of the VMMR0 image file
  */
-static int supLoadModule(const char *pszFilename, const char *pszModule, void **ppvImageBase)
+static int supLoadModule(const char *pszFilename, const char *pszModule, const char *pszSrvReqHandler, void **ppvImageBase)
 {
     /*
@@ -1580 +1663 @@
 
     const bool fIsVMMR0 = !strcmp(pszModule, "VMMR0.r0");
+    AssertReturn(!pszSrvReqHandler || !fIsVMMR0, VERR_INTERNAL_ERROR);
     *ppvImageBase = NULL;
 
@@ -1649 +1733 @@
                     RTUINTPTR VMMR0EntryFast = 0;
                     RTUINTPTR VMMR0EntryEx = 0;
+                    RTUINTPTR SrvReqHandler = 0;
                     RTUINTPTR ModuleInit = 0;
                     RTUINTPTR ModuleTerm = 0;
@@ -1659 +1744 @@
                             rc = RTLdrGetSymbolEx(hLdrMod, &pLoadReq->u.In.achImage[0], (uintptr_t)OpenReq.u.Out.pvImageBase, "VMMR0EntryEx", &VMMR0EntryEx);
                     }
+                    else if (pszSrvReqHandler)
+                        rc = RTLdrGetSymbolEx(hLdrMod, &pLoadReq->u.In.achImage[0], (uintptr_t)OpenReq.u.Out.pvImageBase, pszSrvReqHandler, &SrvReqHandler);
                     if (RT_SUCCESS(rc))
                     {
@@ -1704 +1791 @@
                                 pLoadReq->u.In.EP.VMMR0.pvVMMR0EntryFast= (RTR0PTR)VMMR0EntryFast;
                                 pLoadReq->u.In.EP.VMMR0.pvVMMR0EntryEx  = (RTR0PTR)VMMR0EntryEx;
+                            }
+                            else if (pszSrvReqHandler)
+                            {
+                                pLoadReq->u.In.eEPType                = SUPLDRLOADEP_SERVICE;
+                                pLoadReq->u.In.EP.Service.pfnServiceReq = (RTR0PTR)SrvReqHandler;
+                                pLoadReq->u.In.EP.Service.apvReserved[0] = NIL_RTR0PTR;
+                                pLoadReq->u.In.EP.Service.apvReserved[1] = NIL_RTR0PTR;
+                                pLoadReq->u.In.EP.Service.apvReserved[2] = NIL_RTR0PTR;
                             }
                             else

trunk/src/VBox/HostDrivers/Support/win/SUPDrvA-win.asm

@@ -294 +294 @@
 
 
+;;
+; @cproto DECLASM(int) supdrvNtWrapServiceReqHandler(PFNRT pfnServiceReqHandler, PSUPDRVSESSION pSession, uint32_t uOperation, uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr);
+;
+; @param    pfnSerivceReqHandler rcx
+; @param    pSession            rdx
+; @param    uOperation          r8
+; @param    u64Arg              r9
+; @param    pReq                [rsp + 28h] / [rbp + 30h]
+;
+BEGINPROC supdrvNtWrapServiceReqHandler
+        NtWrapProlog supdrvNtWrapServiceReqHandler
+        NtWrapCreateMarker
+
+        mov     rax, rcx
+        mov     rcx, rdx
+        mov     rdx, r8
+        mov     r8, r9
+        mov     r9, [rbp + 30h]
+        call    rax
+
+        NtWrapDestroyMarker
+        NtWrapEpilog supdrvNtWrapServiceReqHandler
+ENDPROC   supdrvNtWrapServiceReqHandler
+
+
  %endif ; RT_ARCH_AMD64
 %endif ; RT_WITH_W64_UNWIND_HACK