VirtualBox

Ignore:
Timestamp:
Dec 9, 2009 1:52:52 AM (15 years ago)
Author:
vboxsync
Message:

SUPDrv: Sketched out support for native module loading. (OS parts are all stubs and the IOC interface changes disabled.)

Location:
trunk/src/VBox/HostDrivers/Support
Files:
11 edited

Legend:

Unmodified
Added
Removed

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

    r25181 r25258  
    12881288            PSUPLDROPEN pReq = (PSUPLDROPEN)pReqHdr;
    12891289            REQ_CHECK_SIZES(SUP_IOCTL_LDR_OPEN);
    1290             REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.cbImage > 0);
    1291             REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.cbImage < _1M*16);
     1290            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.cbImageWithTabs > 0);
     1291            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.cbImageWithTabs < 16*_1M);
     1292#ifdef SUPDRV_USE_NATIVE_LOADER
     1293            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.cbImageBits > 0);
     1294            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.cbImageBits > 0);
     1295            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.cbImageBits < pReq->u.In.cbImageWithTabs);
     1296#endif
    12921297            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, pReq->u.In.szName[0]);
    12931298            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, memchr(pReq->u.In.szName, '\0', sizeof(pReq->u.In.szName)));
    12941299            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, !supdrvCheckInvalidChar(pReq->u.In.szName, ";:()[]{}/\\|&*%#@!~`\"'"));
     1300#ifdef SUPDRV_USE_NATIVE_LOADER
     1301            REQ_CHECK_EXPR(SUP_IOCTL_LDR_OPEN, memchr(pReq->u.In.szFilename, '\0', sizeof(pReq->u.In.szFilename)));
     1302#endif
    12951303
    12961304            /* execute */
    … …  
    13041312            PSUPLDRLOAD pReq = (PSUPLDRLOAD)pReqHdr;
    13051313            REQ_CHECK_EXPR(Name, pReq->Hdr.cbIn >= sizeof(*pReq));
    1306             REQ_CHECK_SIZES_EX(SUP_IOCTL_LDR_LOAD, SUP_IOCTL_LDR_LOAD_SIZE_IN(pReq->u.In.cbImage), SUP_IOCTL_LDR_LOAD_SIZE_OUT);
     1314            REQ_CHECK_SIZES_EX(SUP_IOCTL_LDR_LOAD, SUP_IOCTL_LDR_LOAD_SIZE_IN(pReq->u.In.cbImageWithTabs), SUP_IOCTL_LDR_LOAD_SIZE_OUT);
    13071315            REQ_CHECK_EXPR(SUP_IOCTL_LDR_LOAD, pReq->u.In.cSymbols <= 16384);
    13081316            REQ_CHECK_EXPR_FMT(     !pReq->u.In.cSymbols
    1309                                ||   (   pReq->u.In.offSymbols < pReq->u.In.cbImage
    1310                                      && pReq->u.In.offSymbols + pReq->u.In.cSymbols * sizeof(SUPLDRSYM) <= pReq->u.In.cbImage),
    1311                                ("SUP_IOCTL_LDR_LOAD: offSymbols=%#lx cSymbols=%#lx cbImage=%#lx\n", (long)pReq->u.In.offSymbols,
    1312                                 (long)pReq->u.In.cSymbols, (long)pReq->u.In.cbImage));
     1317                               ||   (   pReq->u.In.offSymbols < pReq->u.In.cbImageWithTabs
     1318                                     && pReq->u.In.offSymbols + pReq->u.In.cSymbols * sizeof(SUPLDRSYM) <= pReq->u.In.cbImageWithTabs),
     1319                               ("SUP_IOCTL_LDR_LOAD: offSymbols=%#lx cSymbols=%#lx cbImageWithTabs=%#lx\n", (long)pReq->u.In.offSymbols,
     1320                                (long)pReq->u.In.cSymbols, (long)pReq->u.In.cbImageWithTabs));
    13131321            REQ_CHECK_EXPR_FMT(     !pReq->u.In.cbStrTab
    1314                                ||   (   pReq->u.In.offStrTab < pReq->u.In.cbImage
    1315                                      && pReq->u.In.offStrTab + pReq->u.In.cbStrTab <= pReq->u.In.cbImage
    1316                                      && pReq->u.In.cbStrTab <= pReq->u.In.cbImage),
    1317                                ("SUP_IOCTL_LDR_LOAD: offStrTab=%#lx cbStrTab=%#lx cbImage=%#lx\n", (long)pReq->u.In.offStrTab,
    1318                                 (long)pReq->u.In.cbStrTab, (long)pReq->u.In.cbImage));
     1322                               ||   (   pReq->u.In.offStrTab < pReq->u.In.cbImageWithTabs
     1323                                     && pReq->u.In.offStrTab + pReq->u.In.cbStrTab <= pReq->u.In.cbImageWithTabs
     1324                                     && pReq->u.In.cbStrTab <= pReq->u.In.cbImageWithTabs),
     1325                               ("SUP_IOCTL_LDR_LOAD: offStrTab=%#lx cbStrTab=%#lx cbImageWithTabs=%#lx\n", (long)pReq->u.In.offStrTab,
     1326                                (long)pReq->u.In.cbStrTab, (long)pReq->u.In.cbImageWithTabs));
    13191327
    13201328            if (pReq->u.In.cSymbols)
    … …  
    13241332                for (i = 0; i < pReq->u.In.cSymbols; i++)
    13251333                {
    1326                     REQ_CHECK_EXPR_FMT(paSyms[i].offSymbol < pReq->u.In.cbImage,
    1327                                        ("SUP_IOCTL_LDR_LOAD: sym #%ld: symb off %#lx (max=%#lx)\n", (long)i, (long)paSyms[i].offSymbol, (long)pReq->u.In.cbImage));
     1334                    REQ_CHECK_EXPR_FMT(paSyms[i].offSymbol < pReq->u.In.cbImageWithTabs,
     1335                                       ("SUP_IOCTL_LDR_LOAD: sym #%ld: symb off %#lx (max=%#lx)\n", (long)i, (long)paSyms[i].offSymbol, (long)pReq->u.In.cbImageWithTabs));
    13281336                    REQ_CHECK_EXPR_FMT(paSyms[i].offName < pReq->u.In.cbStrTab,
    1329                                        ("SUP_IOCTL_LDR_LOAD: sym #%ld: name off %#lx (max=%#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImage));
     1337                                       ("SUP_IOCTL_LDR_LOAD: sym #%ld: name off %#lx (max=%#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImageWithTabs));
    13301338                    REQ_CHECK_EXPR_FMT(memchr(&pReq->u.In.achImage[pReq->u.In.offStrTab + paSyms[i].offName], '\0', pReq->u.In.cbStrTab - paSyms[i].offName),
    1331                                        ("SUP_IOCTL_LDR_LOAD: sym #%ld: unterminated name! (%#lx / %#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImage));
     1339                                       ("SUP_IOCTL_LDR_LOAD: sym #%ld: unterminated name! (%#lx / %#lx)\n", (long)i, (long)paSyms[i].offName, (long)pReq->u.In.cbImageWithTabs));
    13321340                }
    13331341            }
    … …  
    34283436static int supdrvIOCtl_LdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLDROPEN pReq)
    34293437{
     3438    int             rc;
    34303439    PSUPDRVLDRIMAGE pImage;
    3431     unsigned        cb;
    34323440    void           *pv;
    34333441    size_t          cchName = strlen(pReq->u.In.szName); /* (caller checked < 32). */
    3434     LogFlow(("supdrvIOCtl_LdrOpen: szName=%s cbImage=%d\n", pReq->u.In.szName, pReq->u.In.cbImage));
     3442    LogFlow(("supdrvIOCtl_LdrOpen: szName=%s cbImageWithTabs=%d\n", pReq->u.In.szName, pReq->u.In.cbImageWithTabs));
    34353443
    34363444    /*
    … …  
    34433451            &&  !memcmp(pImage->szName, pReq->u.In.szName, cchName))
    34443452        {
     3453            /** @todo check cbImageBits and cbImageWithTabs here, if they differs that indicates that the images are different. */
    34453454            pImage->cUsage++;
    34463455            pReq->u.Out.pvImageBase   = pImage->pvImage;
    … …  
    34563465     * Allocate memory.
    34573466     */
    3458     cb = pReq->u.In.cbImage + sizeof(SUPDRVLDRIMAGE) + 31;
    3459     pv = RTMemExecAlloc(cb);
     3467    pv = RTMemAlloc(RT_OFFSETOF(SUPDRVLDRIMAGE, szName[cchName + 1]));
    34603468    if (!pv)
    34613469    {
    34623470        RTSemFastMutexRelease(pDevExt->mtxLdr);
    3463         Log(("supdrvIOCtl_LdrOpen: RTMemExecAlloc(%u) failed\n", cb));
     3471        Log(("supdrvIOCtl_LdrOpen: RTMemAlloc() failed\n"));
    34643472        return VERR_NO_MEMORY;
    34653473    }
    … …  
    34693477     */
    34703478    pImage = (PSUPDRVLDRIMAGE)pv;
    3471     pImage->pvImage         = RT_ALIGN_P(pImage + 1, 32);
    3472     pImage->cbImage         = pReq->u.In.cbImage;
     3479    pImage->pvImage         = NULL;
     3480    pImage->pvImageAlloc    = NULL;
     3481    pImage->cbImageWithTabs = pReq->u.In.cbImageWithTabs;
     3482#ifdef SUPDRV_USE_NATIVE_LOADER
     3483    pImage->cbImageBits     = pReq->u.In.cbImageBits;
     3484#else
     3485    pImage->cbImageBits     = pReq->u.In.cbImageWithTabs;
     3486#endif
     3487    pImage->cSymbols        = 0;
     3488    pImage->paSymbols       = NULL;
     3489    pImage->pachStrTab      = NULL;
     3490    pImage->cbStrTab        = 0;
    34733491    pImage->pfnModuleInit   = NULL;
    34743492    pImage->pfnModuleTerm   = NULL;
    … …  
    34783496    memcpy(pImage->szName, pReq->u.In.szName, cchName + 1);
    34793497
     3498    /*
     3499     * Try load it using the native loader, if that isn't supported, fall back
     3500     * on the older method.
     3501     */
     3502#ifdef SUPDRV_USE_NATIVE_LOADER
     3503    pImage->fNative         = true;
     3504    rc = supdrvOSLdrOpen(pDevExt, pImage, pReq->u.In.szFilename);
     3505#else
     3506    rc = VERR_NOT_SUPPORTED;
     3507#endif
     3508    if (rc == VERR_NOT_SUPPORTED)
     3509    {
     3510        pImage->pvImageAlloc = RTMemExecAlloc(pImage->cbImageBits + 31);
     3511        pImage->pvImage     = RT_ALIGN_P(pImage->pvImageAlloc, 32);
     3512#ifdef SUPDRV_USE_NATIVE_LOADER
     3513        pImage->fNative     = false;
     3514#endif
     3515        rc = pImage->pvImageAlloc ? VINF_SUCCESS : VERR_NO_MEMORY;
     3516    }
     3517    if (RT_FAILURE(rc))
     3518    {
     3519        RTSemFastMutexRelease(pDevExt->mtxLdr);
     3520        RTMemFree(pImage);
     3521        Log(("supdrvIOCtl_LdrOpen(%s): failed - %Rrc\n", pReq->u.In.szName, rc));
     3522        return VERR_NO_MEMORY;
     3523    }
     3524    Assert(VALID_PTR(pImage->pvImage) || RT_FAILURE(rc));
     3525
     3526    /*
     3527     * Link it.
     3528     */
    34803529    pImage->pNext           = pDevExt->pLdrImages;
    34813530    pDevExt->pLdrImages     = pImage;
    … …  
    34953544
    34963545/**
     3546 * Worker that validates a pointer to an image entrypoint.
     3547 *
     3548 * @returns IPRT status code.
     3549 * @param   pDevExt     The device globals.
     3550 * @param   pImage      The loader image.
     3551 * @param   pv          The pointer into the image.
     3552 * @param   fMayBeNull  Whether it may be NULL.
     3553 * @param   pszWhat     What is this entrypoint? (for logging)
     3554 * @param   pbImageBits The image bits prepared by ring-3.
     3555 *
     3556 * @remarks Will leave the lock on failure.
     3557 */
     3558static int supdrvLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void *pv,
     3559                                    bool fMayBeNull, const uint8_t *pbImageBits, const char *pszWhat)
     3560{
     3561    if (!fMayBeNull || pv)
     3562    {
     3563        if ((uintptr_t)pv - (uintptr_t)pImage->pvImage >= pImage->cbImageBits)
     3564        {
     3565            RTSemFastMutexRelease(pDevExt->mtxLdr);
     3566            Log(("Out of range (%p LB %#x): %s=%p\n", pImage->pvImage, pImage->cbImageBits, pszWhat, pv));
     3567            return VERR_INVALID_PARAMETER;
     3568        }
     3569
     3570#ifdef SUPDRV_USE_NATIVE_LOADER
     3571        if (pImage->fNative)
     3572        {
     3573            int rc = supdrvOSLdrValidatePointer(pDevExt, pImage, pv, pbImageBits);
     3574            if (RT_FAILURE(rc))
     3575            {
     3576                RTSemFastMutexRelease(pDevExt->mtxLdr);
     3577                Log(("Bad entry point address: %s=%p (rc=%Rrc)\n", pszWhat, pv, rc));
     3578                return rc;
     3579            }
     3580        }
     3581#endif
     3582    }
     3583    return VINF_SUCCESS;
     3584}
     3585
     3586
     3587/**
    34973588 * Loads the image bits.
    34983589 *
    … …  
    35093600    PSUPDRVLDRIMAGE pImage;
    35103601    int             rc;
    3511     LogFlow(("supdrvIOCtl_LdrLoad: pvImageBase=%p cbImage=%d\n", pReq->u.In.pvImageBase, pReq->u.In.cbImage));
     3602    LogFlow(("supdrvIOCtl_LdrLoad: pvImageBase=%p cbImageWithBits=%d\n", pReq->u.In.pvImageBase, pReq->u.In.cbImageWithTabs));
    35123603
    35133604    /*
    … …  
    35253616    }
    35263617    pImage = pUsage->pImage;
    3527     if (pImage->cbImage != pReq->u.In.cbImage)
     3618
     3619    /*
     3620     * Validate input.
     3621     */
     3622#ifdef SUPDRV_USE_NATIVE_LOADER
     3623    if (   pImage->cbImageWithTabs != pReq->u.In.cbImageWithTabs
     3624        || pImage->cbImageBits     != pReq->u.In.cbImageBits)
     3625#else
     3626    if (pImage->cbImageWithTabs != pReq->u.In.cbImageWithTabs)
     3627#endif
    35283628    {
    35293629        RTSemFastMutexRelease(pDevExt->mtxLdr);
    3530         Log(("SUP_IOCTL_LDR_LOAD: image size mismatch!! %d(prep) != %d(load)\n", pImage->cbImage, pReq->u.In.cbImage));
     3630#ifdef SUPDRV_USE_NATIVE_LOADER
     3631        Log(("SUP_IOCTL_LDR_LOAD: image size mismatch!! %d(prep) != %d(load) or %d != %d\n",
     3632             pImage->cbImageWithTabs, pReq->u.In.cbImageWithTabs, pImage->cbImageBits, pReq->u.In.cbImageBits));
     3633#else
     3634        Log(("SUP_IOCTL_LDR_LOAD: image size mismatch!! %d(prep) != %d(load)\n", pImage->cbImageWithTabs, pReq->u.In.cbImageWithTabs));
     3635#endif
    35313636        return VERR_INVALID_HANDLE;
    35323637    }
     3638
    35333639    if (pImage->uState != SUP_IOCTL_LDR_OPEN)
    35343640    {
    … …  
    35393645        return SUPDRV_ERR_ALREADY_LOADED;
    35403646    }
     3647
    35413648    switch (pReq->u.In.eEPType)
    35423649    {
    … …  
    35453652
    35463653        case SUPLDRLOADEP_VMMR0:
    3547             if (    !pReq->u.In.EP.VMMR0.pvVMMR0
    3548                 ||  !pReq->u.In.EP.VMMR0.pvVMMR0EntryInt
    3549                 ||  !pReq->u.In.EP.VMMR0.pvVMMR0EntryFast
    3550                 ||  !pReq->u.In.EP.VMMR0.pvVMMR0EntryEx)
    3551             {
    3552                 RTSemFastMutexRelease(pDevExt->mtxLdr);
    3553                 Log(("NULL pointer: pvVMMR0=%p pvVMMR0EntryInt=%p pvVMMR0EntryFast=%p pvVMMR0EntryEx=%p!\n",
    3554                      pReq->u.In.EP.VMMR0.pvVMMR0, pReq->u.In.EP.VMMR0.pvVMMR0EntryInt,
    3555                      pReq->u.In.EP.VMMR0.pvVMMR0EntryFast, pReq->u.In.EP.VMMR0.pvVMMR0EntryEx));
    3556                 return VERR_INVALID_PARAMETER;
    3557             }
    3558             /** @todo validate pReq->u.In.EP.VMMR0.pvVMMR0 against pvImage! */
    3559             if (    (uintptr_t)pReq->u.In.EP.VMMR0.pvVMMR0EntryInt  - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage
    3560                 ||  (uintptr_t)pReq->u.In.EP.VMMR0.pvVMMR0EntryFast - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage
    3561                 ||  (uintptr_t)pReq->u.In.EP.VMMR0.pvVMMR0EntryEx   - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage)
    3562             {
    3563                 RTSemFastMutexRelease(pDevExt->mtxLdr);
    3564                 Log(("Out of range (%p LB %#x): pvVMMR0EntryInt=%p, pvVMMR0EntryFast=%p or pvVMMR0EntryEx=%p is NULL!\n",
    3565                      pImage->pvImage, pReq->u.In.cbImage, pReq->u.In.EP.VMMR0.pvVMMR0EntryInt,
    3566                      pReq->u.In.EP.VMMR0.pvVMMR0EntryFast, pReq->u.In.EP.VMMR0.pvVMMR0EntryEx));
    3567                 return VERR_INVALID_PARAMETER;
    3568             }
     3654            rc = supdrvLdrValidatePointer(    pDevExt, pImage, pReq->u.In.EP.VMMR0.pvVMMR0,          false, pReq->u.In.achImage, "pvVMMR0");
     3655            if (RT_SUCCESS(rc))
     3656                rc = supdrvLdrValidatePointer(pDevExt, pImage, pReq->u.In.EP.VMMR0.pvVMMR0EntryInt,  false, pReq->u.In.achImage, "pvVMMR0EntryInt");
     3657            if (RT_SUCCESS(rc))
     3658                rc = supdrvLdrValidatePointer(pDevExt, pImage, pReq->u.In.EP.VMMR0.pvVMMR0EntryFast, false, pReq->u.In.achImage, "pvVMMR0EntryFast");
     3659            if (RT_SUCCESS(rc))
     3660                rc = supdrvLdrValidatePointer(pDevExt, pImage, pReq->u.In.EP.VMMR0.pvVMMR0EntryEx,   false, pReq->u.In.achImage, "pvVMMR0EntryEx");
     3661            if (RT_FAILURE(rc))
     3662                return rc;
    35693663            break;
    35703664
    35713665        case SUPLDRLOADEP_SERVICE:
    3572             if (!pReq->u.In.EP.Service.pfnServiceReq)
    3573             {
    3574                 RTSemFastMutexRelease(pDevExt->mtxLdr);
    3575                 Log(("NULL pointer: pfnServiceReq=%p!\n", pReq->u.In.EP.Service.pfnServiceReq));
    3576                 return VERR_INVALID_PARAMETER;
    3577             }
    3578             if ((uintptr_t)pReq->u.In.EP.Service.pfnServiceReq  - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage)
    3579             {
    3580                 RTSemFastMutexRelease(pDevExt->mtxLdr);
    3581                 Log(("Out of range (%p LB %#x): pfnServiceReq=%p, pvVMMR0EntryFast=%p or pvVMMR0EntryEx=%p is NULL!\n",
    3582                      pImage->pvImage, pReq->u.In.cbImage, pReq->u.In.EP.Service.pfnServiceReq));
    3583                 return VERR_INVALID_PARAMETER;
    3584             }
     3666            rc = supdrvLdrValidatePointer(pDevExt, pImage, pReq->u.In.EP.Service.pfnServiceReq, false, pReq->u.In.achImage, "pfnServiceReq");
     3667            if (RT_FAILURE(rc))
     3668                return rc;
    35853669            if (    pReq->u.In.EP.Service.apvReserved[0] != NIL_RTR0PTR
    35863670                ||  pReq->u.In.EP.Service.apvReserved[1] != NIL_RTR0PTR
    … …  
    35893673                RTSemFastMutexRelease(pDevExt->mtxLdr);
    35903674                Log(("Out of range (%p LB %#x): apvReserved={%p,%p,%p} MBZ!\n",
    3591                      pImage->pvImage, pReq->u.In.cbImage,
     3675                     pImage->pvImage, pReq->u.In.cbImageWithTabs,
    35923676                     pReq->u.In.EP.Service.apvReserved[0],
    35933677                     pReq->u.In.EP.Service.apvReserved[1],
    … …  
    36023686            return VERR_INVALID_PARAMETER;
    36033687    }
    3604     if (    pReq->u.In.pfnModuleInit
    3605         &&  (uintptr_t)pReq->u.In.pfnModuleInit - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage)
    3606     {
    3607         RTSemFastMutexRelease(pDevExt->mtxLdr);
    3608         Log(("SUP_IOCTL_LDR_LOAD: pfnModuleInit=%p is outside the image (%p %d bytes)\n",
    3609              pReq->u.In.pfnModuleInit, pImage->pvImage, pReq->u.In.cbImage));
    3610         return VERR_INVALID_PARAMETER;
    3611     }
    3612     if (    pReq->u.In.pfnModuleTerm
    3613         &&  (uintptr_t)pReq->u.In.pfnModuleTerm - (uintptr_t)pImage->pvImage >= pReq->u.In.cbImage)
    3614     {
    3615         RTSemFastMutexRelease(pDevExt->mtxLdr);
    3616         Log(("SUP_IOCTL_LDR_LOAD: pfnModuleTerm=%p is outside the image (%p %d bytes)\n",
    3617              pReq->u.In.pfnModuleTerm, pImage->pvImage, pReq->u.In.cbImage));
    3618         return VERR_INVALID_PARAMETER;
    3619     }
    3620 
    3621     /*
    3622      * Copy the memory.
    3623      */
    3624     /* no need to do try/except as this is a buffered request. */
    3625     memcpy(pImage->pvImage, &pReq->u.In.achImage[0], pImage->cbImage);
    3626     pImage->uState = SUP_IOCTL_LDR_LOAD;
    3627     pImage->pfnModuleInit = pReq->u.In.pfnModuleInit;
    3628     pImage->pfnModuleTerm = pReq->u.In.pfnModuleTerm;
    3629     pImage->offSymbols    = pReq->u.In.offSymbols;
    3630     pImage->cSymbols      = pReq->u.In.cSymbols;
    3631     pImage->offStrTab     = pReq->u.In.offStrTab;
    3632     pImage->cbStrTab      = pReq->u.In.cbStrTab;
     3688
     3689    rc = supdrvLdrValidatePointer(pDevExt, pImage, pReq->u.In.pfnModuleInit, true, pReq->u.In.achImage, "pfnModuleInit");
     3690    if (RT_FAILURE(rc))
     3691        return rc;
     3692    rc = supdrvLdrValidatePointer(pDevExt, pImage, pReq->u.In.pfnModuleTerm, true, pReq->u.In.achImage, "pfnModuleTerm");
     3693    if (RT_FAILURE(rc))
     3694        return rc;
     3695
     3696    /*
     3697     * Allocate and copy the tables.
     3698     * (No need to do try/except as this is a buffered request.)
     3699     */
     3700    pImage->cbStrTab = pReq->u.In.cbStrTab;
     3701    if (pImage->cbStrTab)
     3702    {
     3703        pImage->pachStrTab = (char *)RTMemAlloc(pImage->cbStrTab);
     3704        if (pImage->pachStrTab)
     3705            memcpy(pImage->pachStrTab, &pReq->u.In.achImage[pReq->u.In.offStrTab], pImage->cbStrTab);
     3706        else
     3707            rc = VERR_NO_MEMORY;
     3708    }
     3709
     3710    pImage->cSymbols = pReq->u.In.cSymbols;
     3711    if (RT_SUCCESS(rc) && pImage->cSymbols)
     3712    {
     3713        size_t  cbSymbols = pImage->cSymbols * sizeof(SUPLDRSYM);
     3714        pImage->paSymbols = (PSUPLDRSYM)RTMemAlloc(cbSymbols);
     3715        if (pImage->paSymbols)
     3716            memcpy(pImage->paSymbols, &pReq->u.In.achImage[pReq->u.In.offSymbols], cbSymbols);
     3717        else
     3718            rc = VERR_NO_MEMORY;
     3719    }
     3720
     3721    /*
     3722     * Copy the bits / complete native loading.
     3723     */
     3724    if (RT_SUCCESS(rc))
     3725    {
     3726        pImage->uState = SUP_IOCTL_LDR_LOAD;
     3727        pImage->pfnModuleInit = pReq->u.In.pfnModuleInit;
     3728        pImage->pfnModuleTerm = pReq->u.In.pfnModuleTerm;
     3729
     3730#ifdef SUPDRV_USE_NATIVE_LOADER
     3731        if (pImage->fNative)
     3732            rc = supdrvOSLdrLoad(pDevExt, pImage, pReq->u.In.achImage);
     3733        else
     3734#endif
     3735            memcpy(pImage->pvImage, &pReq->u.In.achImage[0], pImage->cbImageBits);
     3736    }
    36333737
    36343738    /*
    36353739     * Update any entry points.
    36363740     */
    3637     switch (pReq->u.In.eEPType)
    3638     {
    3639         default:
    3640         case SUPLDRLOADEP_NOTHING:
    3641             rc = VINF_SUCCESS;
    3642             break;
    3643         case SUPLDRLOADEP_VMMR0:
    3644             rc = supdrvLdrSetVMMR0EPs(pDevExt, pReq->u.In.EP.VMMR0.pvVMMR0, pReq->u.In.EP.VMMR0.pvVMMR0EntryInt,
    3645                                       pReq->u.In.EP.VMMR0.pvVMMR0EntryFast, pReq->u.In.EP.VMMR0.pvVMMR0EntryEx);
    3646             break;
    3647         case SUPLDRLOADEP_SERVICE:
    3648             pImage->pfnServiceReqHandler = pReq->u.In.EP.Service.pfnServiceReq;
    3649             rc = VINF_SUCCESS;
    3650             break;
     3741    if (RT_SUCCESS(rc))
     3742    {
     3743        switch (pReq->u.In.eEPType)
     3744        {
     3745            default:
     3746            case SUPLDRLOADEP_NOTHING:
     3747                rc = VINF_SUCCESS;
     3748                break;
     3749            case SUPLDRLOADEP_VMMR0:
     3750                rc = supdrvLdrSetVMMR0EPs(pDevExt, pReq->u.In.EP.VMMR0.pvVMMR0, pReq->u.In.EP.VMMR0.pvVMMR0EntryInt,
     3751                                          pReq->u.In.EP.VMMR0.pvVMMR0EntryFast, pReq->u.In.EP.VMMR0.pvVMMR0EntryEx);
     3752                break;
     3753            case SUPLDRLOADEP_SERVICE:
     3754                pImage->pfnServiceReqHandler = pReq->u.In.EP.Service.pfnServiceReq;
     3755                rc = VINF_SUCCESS;
     3756                break;
     3757        }
    36513758    }
    36523759
    … …  
    36673774    }
    36683775
    3669     if (rc)
    3670         pImage->uState = SUP_IOCTL_LDR_OPEN;
     3776    if (RT_FAILURE(rc))
     3777    {
     3778        pImage->uState              = SUP_IOCTL_LDR_OPEN;
     3779        pImage->pfnModuleInit       = NULL;
     3780        pImage->pfnModuleTerm       = NULL;
     3781        pImage->pfnServiceReqHandler= NULL;
     3782        pImage->cbStrTab            = 0;
     3783        RTMemFree(pImage->pachStrTab);
     3784        pImage->pachStrTab          = NULL;
     3785        RTMemFree(pImage->paSymbols);
     3786        pImage->paSymbols           = NULL;
     3787        pImage->cSymbols            = 0;
     3788    }
    36713789
    36723790    RTSemFastMutexRelease(pDevExt->mtxLdr);
    … …  
    37273845            PSUPDRVOBJ pObj;
    37283846            for (pObj = pDevExt->pObjs; pObj; pObj = pObj->pNext)
    3729                 if (RT_UNLIKELY((uintptr_t)pObj->pfnDestructor - (uintptr_t)pImage->pvImage < pImage->cbImage))
     3847                if (RT_UNLIKELY((uintptr_t)pObj->pfnDestructor - (uintptr_t)pImage->pvImage < pImage->cbImageBits))
    37303848                {
    37313849                    rc = VERR_DANGLING_OBJECTS;
    … …  
    37373855            PSUPDRVUSAGE pGenUsage;
    37383856            for (pGenUsage = pSession->pUsage; pGenUsage; pGenUsage = pGenUsage->pNext)
    3739                 if (RT_UNLIKELY((uintptr_t)pGenUsage->pObj->pfnDestructor - (uintptr_t)pImage->pvImage < pImage->cbImage))
     3857                if (RT_UNLIKELY((uintptr_t)pGenUsage->pObj->pfnDestructor - (uintptr_t)pImage->pvImage < pImage->cbImageBits))
    37403858                {
    37413859                    rc = VERR_DANGLING_OBJECTS;
    … …  
    37583876
    37593877            /*
    3760              * Derefrence the image.
     3878             * Dereference the image.
    37613879             */
    37623880            if (pImage->cUsage <= 1)
    … …  
    38313949     * Search the symbol strings.
    38323950     */
    3833     pchStrings = (const char *)((uint8_t *)pImage->pvImage + pImage->offStrTab);
    3834     paSyms     =   (PSUPLDRSYM)((uint8_t *)pImage->pvImage + pImage->offSymbols);
     3951    pchStrings = pImage->pachStrTab;
     3952    paSyms     = pImage->paSymbols;
    38353953    for (i = 0; i < pImage->cSymbols; i++)
    38363954    {
    3837         if (    paSyms[i].offSymbol < pImage->cbImage /* paranoia */
     3955        if (    paSyms[i].offSymbol < pImage->cbImageBits /* paranoia */
    38383956            &&  paSyms[i].offName + cbSymbol <= pImage->cbStrTab
    38393957            &&  !memcmp(pchStrings + paSyms[i].offName, pReq->u.In.szSymbol, cbSymbol))
    … …  
    39154033             * Search the symbol strings.
    39164034             */
    3917             const char *pchStrings = (const char *)((uint8_t *)pImage->pvImage + pImage->offStrTab);
    3918             PCSUPLDRSYM paSyms     =  (PCSUPLDRSYM)((uint8_t *)pImage->pvImage + pImage->offSymbols);
     4035            const char *pchStrings = pImage->pachStrTab;
     4036            PCSUPLDRSYM paSyms     = pImage->paSymbols;
    39194037            for (i = 0; i < pImage->cSymbols; i++)
    39204038            {
    3921                 if (    paSyms[i].offSymbol < pImage->cbImage /* paranoia */
     4039                if (    paSyms[i].offSymbol < pImage->cbImageBits /* paranoia */
    39224040                    &&  paSyms[i].offName + cbSymbol <= pImage->cbStrTab
    39234041                    &&  !memcmp(pchStrings + paSyms[i].offName, pszSymbol, cbSymbol))
    … …  
    40844202        RTSpinlockAcquire(pDevExt->Spinlock, &SpinlockTmp);
    40854203        for (pObj = pDevExt->pObjs; pObj; pObj = pObj->pNext)
    4086             if (RT_UNLIKELY((uintptr_t)pObj->pfnDestructor - (uintptr_t)pImage->pvImage < pImage->cbImage))
     4204            if (RT_UNLIKELY((uintptr_t)pObj->pfnDestructor - (uintptr_t)pImage->pvImage < pImage->cbImageBits))
    40874205            {
    40884206                pObj->pfnDestructor = NULL;
    … …  
    41064224    }
    41074225
     4226#ifdef SUPDRV_USE_NATIVE_LOADER
     4227    /* do native unload if appropriate. */
     4228    if (pImage->fNative)
     4229        supdrvOSLdrUnload(pDevExt, pImage);
     4230#endif
     4231
    41084232    /* free the image */
    41094233    pImage->cUsage = 0;
    41104234    pImage->pNext  = 0;
    41114235    pImage->uState = SUP_IOCTL_LDR_FREE;
    4112     RTMemExecFree(pImage);
     4236    RTMemExecFree(pImage->pvImageAlloc);
     4237    pImage->pvImageAlloc = NULL;
     4238    RTMemFree(pImage->pachStrTab);
     4239    pImage->pachStrTab = NULL;
     4240    RTMemFree(pImage->paSymbols);
     4241    pImage->paSymbols = NULL;
     4242    RTMemFree(pImage);
    41134243}
    41144244

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

    r24498 r25258  
    3131#ifndef ___SUPDrvIOC_h___
    3232#define ___SUPDrvIOC_h___
     33
     34/*#define SUPDRV_USE_NATIVE_LOADER*/
    3335
    3436/*
    … …  
    200202 *          next major version used on the trunk will be 0x00120000!
    201203 */
     204#ifdef SUPDRV_USE_NATIVE_LOADER
     205#define SUPDRV_IOC_VERSION                              0x00120000
     206#else
    202207#define SUPDRV_IOC_VERSION                              0x00100001
     208#endif
    203209
    204210/** SUP_IOCTL_COOKIE. */
    … …  
    292298        struct
    293299        {
    294             /** Size of the image we'll be loading. */
    295             uint32_t        cbImage;
     300            /** Size of the image we'll be loading (includeing tables). */
     301            uint32_t        cbImageWithTabs;
     302#ifdef SUPDRV_USE_NATIVE_LOADER
     303            /** The size of the image bits. (Less or equal to cbImageWithTabs.) */
     304            uint32_t        cbImageBits;
     305#endif
    296306            /** Image name.
    297307             * This is the NAME of the image, not the file name. It is used
    298308             * to share code with other processes. (Max len is 32 chars!)  */
    299309            char            szName[32];
     310#ifdef SUPDRV_USE_NATIVE_LOADER
     311            /** Image file name.
     312             * This can be used to load the image using a native loader. */
     313            char            szFilename[196];
     314#endif
    300315        } In;
    301316        struct
    … …  
    406421            /** Entry point type. */
    407422            SUPLDRLOADEP    eEPType;
     423#ifdef SUPDRV_USE_NATIVE_LOADER
     424            /** The size of the image bits (starting at offset 0 and
     425             * approaching offSymbols). */
     426            uint32_t        cbImageBits;
     427#endif
    408428            /** The offset of the symbol table. */
    409429            uint32_t        offSymbols;
    … …  
    414434            /** Size of the string table. */
    415435            uint32_t        cbStrTab;
    416             /** Size of image (including string and symbol tables). */
    417             uint32_t        cbImage;
     436            /** Size of image data in achImage. */
     437            uint32_t        cbImageWithTabs;
    418438            /** The image data. */
    419439            char            achImage[1];

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

    r23726 r25258  
    401401    /** Pointer to the image. */
    402402    void                           *pvImage;
     403    /** Pointer to the allocated image buffer.
     404     * pvImage is 32-byte aligned or it may governed by the native loader (this
     405     * member is NULL then). */
     406    void                           *pvImageAlloc;
     407    /** Size of the image including the tables. This is mainly for verification
     408     * of the load request. */
     409    uint32_t                        cbImageWithTabs;
     410    /** Size of the image. */
     411    uint32_t                        cbImageBits;
     412    /** The number of entries in the symbol table. */
     413    uint32_t                        cSymbols;
     414    /** Pointer to the symbol table. */
     415    PSUPLDRSYM                      paSymbols;
     416    /** The offset of the string table. */
     417    char                           *pachStrTab;
     418    /** Size of the string table. */
     419    uint32_t                        cbStrTab;
    403420    /** Pointer to the optional module initialization callback. */
    404421    PFNR0MODULEINIT                 pfnModuleInit;
    … …  
    407424    /** Service request handler. This is NULL for non-service modules. */
    408425    PFNSUPR0SERVICEREQHANDLER       pfnServiceReqHandler;
    409     /** Size of the image. */
    410     uint32_t                        cbImage;
    411     /** The offset of the symbol table. */
    412     uint32_t                        offSymbols;
    413     /** The number of entries in the symbol table. */
    414     uint32_t                        cSymbols;
    415     /** The offset of the string table. */
    416     uint32_t                        offStrTab;
    417     /** Size of the string table. */
    418     uint32_t                        cbStrTab;
    419426    /** The ldr image state. (IOCtl code of last opration.) */
    420427    uint32_t                        uState;
    421428    /** Usage count. */
    422429    uint32_t volatile               cUsage;
     430#ifdef SUPDRV_USE_NATIVE_LOADER
     431    /** Whether it's loaded by the native loader or not. */
     432    bool                            fNative;
     433#endif
    423434    /** Image name. */
    424435    char                            szName[32];
    … …  
    651662int  VBOXCALL   supdrvOSEnableVTx(bool fEnabled);
    652663
     664#ifdef SUPDRV_USE_NATIVE_LOADER
     665
     666/**
     667 * Try open the image using the native loader.
     668 *
     669 * @returns IPRT status code.
     670 * @retval  VERR_NOT_SUPPORTED if native loading isn't supported.
     671 *
     672 * @param   pDevExt             The device globals.
     673 * @param   pImage              The image handle.  pvImage should be set on
     674 *                              success, pvImageAlloc can also be set if
     675 *                              appropriate.
     676 * @param   pszFilename         The file name - UTF-8, may containg UNIX
     677 *                              slashes on non-UNIX systems.
     678 */
     679int  VBOXCALL   supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename);
     680
     681/**
     682 * Validates an entry point address.
     683 *
     684 * Called before supdrvOSLdrLoad.
     685 *
     686 * @returns IPRT status code.
     687 * @param   pDevExt             The device globals.
     688 * @param   pImage              The image data (still in the open state).
     689 * @param   pv                  The address within the image.
     690 * @param   pbImageBits         The image bits as loaded by ring-3.
     691 */
     692int  VBOXCALL   supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage,
     693                                           void *pv, const uint8_t *pbImageBits);
     694
     695/**
     696 * Load the image.
     697 *
     698 * @returns IPRT status code.
     699 * @param   pDevExt             The device globals.
     700 * @param   pImage              The image data (up to date except for some
     701 *                              entry point pointers).
     702 * @param   pbImageBits         The image bits as loaded by ring-3.
     703 */
     704int  VBOXCALL   supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits);
     705
     706
     707/**
     708 * Unload the image.
     709 *
     710 * @param   pDevExt             The device globals.
     711 * @param   pImage              The image data (mostly still valid).
     712 */
     713void VBOXCALL   supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage);
     714
     715#endif /* SUPDRV_USE_NATIVE_LOADER */
    653716
    654717/*******************************************************************************

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

    r23725 r25258  
    272272        strcpy(CookieReq.u.In.szMagic, SUPCOOKIE_MAGIC);
    273273        CookieReq.u.In.u32ReqVersion = SUPDRV_IOC_VERSION;
    274         const uint32_t uMinVersion = (SUPDRV_IOC_VERSION & 0xffff0000) == 0x00100001
    275                                    ?  0x00100001
     274#ifdef SUPDRV_USE_NATIVE_LOADER
     275        const uint32_t uMinVersion = (SUPDRV_IOC_VERSION & 0xffff0000) == 0x00120000
     276                                   ?  0x00120000
    276277                                   :  SUPDRV_IOC_VERSION & 0xffff0000;
     278#else
     279       const uint32_t uMinVersion = (SUPDRV_IOC_VERSION & 0xffff0000) == 0x00100001
     280                                       ?  0x00100001
     281                                   :  SUPDRV_IOC_VERSION & 0xffff0000;
     282#endif
    277283        CookieReq.u.In.u32MinVersion = uMinVersion;
    278284        rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_COOKIE, &CookieReq, SUP_IOCTL_COOKIE_SIZE);
    … …  
    16441650static int supLoadModule(const char *pszFilename, const char *pszModule, const char *pszSrvReqHandler, void **ppvImageBase)
    16451651{
     1652    int rc;
     1653
    16461654    /*
    16471655     * Validate input.
    … …  
    16511659    AssertPtrReturn(ppvImageBase, VERR_INVALID_PARAMETER);
    16521660    AssertReturn(strlen(pszModule) < RT_SIZEOFMEMB(SUPLDROPEN, u.In.szName), VERR_FILENAME_TOO_LONG);
     1661#ifdef SUPDRV_USE_NATIVE_LOADER
     1662    char szAbsFilename[RT_SIZEOFMEMB(SUPLDROPEN, u.In.szFilename)];
     1663    rc = RTPathAbs(pszFilename, szAbsFilename, sizeof(szAbsFilename));
     1664    if (RT_FAILURE(rc))
     1665        return rc;
     1666    pszFilename = szAbsFilename;
     1667#endif
    16531668
    16541669    const bool fIsVMMR0 = !strcmp(pszModule, "VMMR0.r0");
    … …  
    16601675     */
    16611676    RTLDRMOD hLdrMod;
    1662     int rc = RTLdrOpen(pszFilename, 0, RTLDRARCH_HOST, &hLdrMod);
     1677    rc = RTLdrOpen(pszFilename, 0, RTLDRARCH_HOST, &hLdrMod);
    16631678    if (!RT_SUCCESS(rc))
    16641679        return rc;
    … …  
    16731688        const uint32_t  offSymTab = RT_ALIGN_32(CalcArgs.cbImage, 8);
    16741689        const uint32_t  offStrTab = offSymTab + CalcArgs.cSymbols * sizeof(SUPLDRSYM);
    1675         const uint32_t  cbImage  = RT_ALIGN_32(offStrTab + CalcArgs.cbStrings, 8);
     1690        const uint32_t  cbImageWithTabs = RT_ALIGN_32(offStrTab + CalcArgs.cbStrings, 8);
    16761691
    16771692        /*
    … …  
    16851700        OpenReq.Hdr.fFlags = SUPREQHDR_FLAGS_DEFAULT;
    16861701        OpenReq.Hdr.rc = VERR_INTERNAL_ERROR;
    1687         OpenReq.u.In.cbImage = cbImage;
     1702        OpenReq.u.In.cbImageWithTabs = cbImageWithTabs;
     1703#ifdef SUPDRV_USE_NATIVE_LOADER
     1704        OpenReq.u.In.cbImageBits = (uint32_t)CalcArgs.cbImage;
     1705#endif
    16881706        strcpy(OpenReq.u.In.szName, pszModule);
     1707#ifdef SUPDRV_USE_NATIVE_LOADER
     1708        strcpy(OpenReq.u.In.szFilename, pszFilename);
     1709#endif
    16891710        if (!g_u32FakeMode)
    16901711        {
    … …  
    17061727             * Allocate memory for the image bits.
    17071728             */
    1708             PSUPLDRLOAD pLoadReq = (PSUPLDRLOAD)RTMemTmpAlloc(SUP_IOCTL_LDR_LOAD_SIZE(cbImage));
     1729            PSUPLDRLOAD pLoadReq = (PSUPLDRLOAD)RTMemTmpAlloc(SUP_IOCTL_LDR_LOAD_SIZE(cbImageWithTabs));
    17091730            if (pLoadReq)
    17101731            {
    … …  
    17671788                            pLoadReq->Hdr.u32Cookie = g_u32Cookie;
    17681789                            pLoadReq->Hdr.u32SessionCookie = g_u32SessionCookie;
    1769                             pLoadReq->Hdr.cbIn = SUP_IOCTL_LDR_LOAD_SIZE_IN(cbImage);
     1790                            pLoadReq->Hdr.cbIn = SUP_IOCTL_LDR_LOAD_SIZE_IN(cbImageWithTabs);
    17701791                            pLoadReq->Hdr.cbOut = SUP_IOCTL_LDR_LOAD_SIZE_OUT;
    17711792                            pLoadReq->Hdr.fFlags = SUPREQHDR_FLAGS_MAGIC | SUPREQHDR_FLAGS_EXTRA_IN;
    … …  
    17951816                            pLoadReq->u.In.cbStrTab                   = (uint32_t)CalcArgs.cbStrings;
    17961817                            AssertRelease(pLoadReq->u.In.cbStrTab == CalcArgs.cbStrings);
     1818#ifdef SUPDRV_USE_NATIVE_LOADER
     1819                            pLoadReq->u.In.cbImageBits                = (uint32_t)CalcArgs.cbImage;
     1820#endif
    17971821                            pLoadReq->u.In.offSymbols                 = offSymTab;
    17981822                            pLoadReq->u.In.cSymbols                   = CalcArgs.cSymbols;
    1799                             pLoadReq->u.In.cbImage                    = cbImage;
     1823                            pLoadReq->u.In.cbImageWithTabs            = cbImageWithTabs;
    18001824                            pLoadReq->u.In.pvImageBase                = OpenReq.u.Out.pvImageBase;
    18011825                            if (!g_u32FakeMode)
    18021826                            {
    1803                                 rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_LDR_LOAD, pLoadReq, SUP_IOCTL_LDR_LOAD_SIZE(cbImage));
     1827                                rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_LDR_LOAD, pLoadReq, SUP_IOCTL_LDR_LOAD_SIZE(cbImageWithTabs));
    18041828                                if (RT_SUCCESS(rc))
    18051829                                    rc = pLoadReq->Hdr.rc;
    … …  
    18341858            else
    18351859            {
    1836                 AssertMsgFailed(("failed to allocated %d bytes for SUPLDRLOAD_IN structure!\n", SUP_IOCTL_LDR_LOAD_SIZE(cbImage)));
     1860                AssertMsgFailed(("failed to allocated %u bytes for SUPLDRLOAD_IN structure!\n", SUP_IOCTL_LDR_LOAD_SIZE(cbImageWithTabs)));
    18371861                rc = VERR_NO_TMP_MEMORY;
    18381862            }

  • trunk/src/VBox/HostDrivers/Support/SUPLibInternal.h

    r22615 r25258  
    3131#ifndef ___SUPLibInternal_h___
    3232#define ___SUPLibInternal_h___
     33
     34/*#define SUPDRV_USE_NATIVE_LOADER*/
    3335
    3436#include <VBox/cdefs.h>

  • trunk/src/VBox/HostDrivers/Support/darwin/SUPDrv-darwin.cpp

    r24183 r25258  
    759759}
    760760
     761#ifdef SUPDRV_USE_NATIVE_LOADER
     762
     763int  VBOXCALL   supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
     764{
     765    NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
     766    return VERR_NOT_SUPPORTED;
     767}
     768
     769
     770int  VBOXCALL   supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void *pv, const uint8_t *pbImageBits)
     771{
     772    NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits);
     773    return VERR_NOT_SUPPORTED;
     774}
     775
     776
     777int  VBOXCALL   supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits)
     778{
     779    NOREF(pDevExt); NOREF(pImage); NOREF(pbImageBits);
     780    return VERR_NOT_SUPPORTED;
     781}
     782
     783
     784void VBOXCALL   supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
     785{
     786    NOREF(pDevExt); NOREF(pImage);
     787}
     788
     789#endif /* SUPDRV_USE_NATIVE_LOADER */
    761790
    762791/**

  • trunk/src/VBox/HostDrivers/Support/freebsd/SUPDrv-freebsd.c

    r22678 r25258  
    9292/** Declare the module as a pseudo device. */
    9393DECLARE_MODULE(vboxdrv,     g_VBoxDrvFreeBSDModule, SI_SUB_PSEUDO, SI_ORDER_ANY);
    94 MODULE_VERSION(vboxdrv, 1); 
     94MODULE_VERSION(vboxdrv, 1);
    9595
    9696/**
    … …  
    600600}
    601601
     602#ifdef SUPDRV_USE_NATIVE_LOADER
     603
     604int  VBOXCALL   supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
     605{
     606    NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
     607    return VERR_NOT_SUPPORTED;
     608}
     609
     610
     611int  VBOXCALL   supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void *pv, const uint8_t *pbImageBits)
     612{
     613    NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits);
     614    return VERR_NOT_SUPPORTED;
     615}
     616
     617
     618int  VBOXCALL   supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits)
     619{
     620    NOREF(pDevExt); NOREF(pImage); NOREF(pbImageBits);
     621    return VERR_NOT_SUPPORTED;
     622}
     623
     624
     625void VBOXCALL   supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
     626{
     627    NOREF(pDevExt); NOREF(pImage);
     628}
     629
     630#endif /* SUPDRV_USE_NATIVE_LOADER */
    602631
    603632SUPR0DECL(int) SUPR0Printf(const char *pszFormat, ...)

  • trunk/src/VBox/HostDrivers/Support/linux/SUPDrv-linux.c

    r25090 r25258  
    10061006}
    10071007
     1008#ifdef SUPDRV_USE_NATIVE_LOADER
     1009
     1010int  VBOXCALL   supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
     1011{
     1012    NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
     1013    return VERR_NOT_SUPPORTED;
     1014}
     1015
     1016
     1017int  VBOXCALL   supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void *pv, const uint8_t *pbImageBits)
     1018{
     1019    NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits);
     1020    return VERR_NOT_SUPPORTED;
     1021}
     1022
     1023
     1024int  VBOXCALL   supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits)
     1025{
     1026    NOREF(pDevExt); NOREF(pImage); NOREF(pbImageBits);
     1027    return VERR_NOT_SUPPORTED;
     1028}
     1029
     1030
     1031void VBOXCALL   supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
     1032{
     1033    NOREF(pDevExt); NOREF(pImage);
     1034}
     1035
     1036#endif /* SUPDRV_USE_NATIVE_LOADER */
    10081037
    10091038/**

  • trunk/src/VBox/HostDrivers/Support/os2/SUPDrv-os2.cpp

    r22077 r25258  
    382382}
    383383
     384#ifdef SUPDRV_USE_NATIVE_LOADER
     385
     386int  VBOXCALL   supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
     387{
     388    NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
     389    return VERR_NOT_SUPPORTED;
     390}
     391
     392
     393int  VBOXCALL   supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void *pv, const uint8_t *pbImageBits)
     394{
     395    NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits);
     396    return VERR_NOT_SUPPORTED;
     397}
     398
     399
     400int  VBOXCALL   supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits)
     401{
     402    NOREF(pDevExt); NOREF(pImage); NOREF(pbImageBits);
     403    return VERR_NOT_SUPPORTED;
     404}
     405
     406
     407void VBOXCALL   supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
     408{
     409    NOREF(pDevExt); NOREF(pImage);
     410}
     411
     412#endif /* SUPDRV_USE_NATIVE_LOADER */
    384413
    385414/**

  • trunk/src/VBox/HostDrivers/Support/solaris/SUPDrv-solaris.c

    r25181 r25258  
    897897}
    898898
     899#ifdef SUPDRV_USE_NATIVE_LOADER
     900
     901int  VBOXCALL   supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
     902{
     903    NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
     904    return VERR_NOT_SUPPORTED;
     905}
     906
     907
     908int  VBOXCALL   supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void *pv, const uint8_t *pbImageBits)
     909{
     910    NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits);
     911    return VERR_NOT_SUPPORTED;
     912}
     913
     914
     915int  VBOXCALL   supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits)
     916{
     917    NOREF(pDevExt); NOREF(pImage); NOREF(pbImageBits);
     918    return VERR_NOT_SUPPORTED;
     919}
     920
     921
     922void VBOXCALL   supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
     923{
     924    NOREF(pDevExt); NOREF(pImage);
     925}
     926
     927#endif /* SUPDRV_USE_NATIVE_LOADER */
    899928
    900929RTDECL(int) SUPR0Printf(const char *pszFormat, ...)

  • trunk/src/VBox/HostDrivers/Support/win/SUPDrv-win.cpp

    r24035 r25258  
    594594}
    595595
     596#ifdef SUPDRV_USE_NATIVE_LOADER
     597
     598int  VBOXCALL   supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
     599{
     600    NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
     601    return VERR_NOT_SUPPORTED;
     602}
     603
     604
     605int  VBOXCALL   supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void *pv, const uint8_t *pbImageBits)
     606{
     607    NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits);
     608    return VERR_NOT_SUPPORTED;
     609}
     610
     611
     612int  VBOXCALL   supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits)
     613{
     614    NOREF(pDevExt); NOREF(pImage); NOREF(pbImageBits);
     615    return VERR_NOT_SUPPORTED;
     616}
     617
     618
     619void VBOXCALL   supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
     620{
     621    NOREF(pDevExt); NOREF(pImage);
     622}
     623
     624#endif /* SUPDRV_USE_NATIVE_LOADER */
    596625
    597626/**
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette