VirtualBox

Ignore:
Timestamp:
May 20, 2009 1:35:36 PM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
47540
Message:

SUP: Expose ring-0 event semaphores to ring-3, part 1.

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

Legend:

Unmodified
Added
Removed

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

    r19730 r19866  
    3838#endif
    3939#include <iprt/alloc.h>
     40#include <iprt/cpuset.h>
     41#include <iprt/handletable.h>
     42#include <iprt/mp.h>
     43#include <iprt/power.h>
     44#include <iprt/process.h>
    4045#include <iprt/semaphore.h>
    4146#include <iprt/spinlock.h>
    4247#include <iprt/thread.h>
    43 #include <iprt/process.h>
    44 #include <iprt/mp.h>
    45 #include <iprt/power.h>
    46 #include <iprt/cpuset.h>
    4748#include <iprt/uuid.h>
    4849#include <VBox/param.h>
    … …  
    125126*   Internal Functions                                                         *
    126127*******************************************************************************/
     128static DECLCALLBACK(int)    supdrvSessionObjHandleRetain(RTHANDLETABLE hHandleTable, void *pvObj, void *pvCtx, void *pvUser);
     129static DECLCALLBACK(void)   supdrvSessionObjHandleDelete(RTHANDLETABLE hHandleTable, uint32_t h, void *pvObj, void *pvCtx, void *pvUser);
    127130static int      supdrvMemAdd(PSUPDRVMEMREF pMem, PSUPDRVSESSION pSession);
    128131static int      supdrvMemRelease(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, SUPDRVMEMREFTYPE eType);
    … …  
    178181DECLASM(int)    UNWIND_WRAP(SUPR0PageFree)(PSUPDRVSESSION pSession, RTR3PTR pvR3);
    179182//DECLASM(int)    UNWIND_WRAP(SUPR0Printf)(const char *pszFormat, ...);
     183DECLASM(int)    UNWIND_WRAP(SUPSemEventCreate)(PSUPDRVSESSION pSession, PSUPSEMEVENT phEvent);
     184DECLASM(int)    UNWIND_WRAP(SUPSemEventClose)(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent);
     185DECLASM(int)    UNWIND_WRAP(SUPSemEventSignal)(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent);
     186DECLASM(int)    UNWIND_WRAP(SUPSemEventWait)(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies);
     187DECLASM(int)    UNWIND_WRAP(SUPSemEventWaitNoResume)(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies);
     188DECLASM(int)    UNWIND_WRAP(SUPSemEventMultiCreate)(PSUPDRVSESSION pSession, PSUPSEMEVENTMULTI phEventMulti);
     189DECLASM(int)    UNWIND_WRAP(SUPSemEventMultiClose)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
     190DECLASM(int)    UNWIND_WRAP(SUPSemEventMultiSignal)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
     191DECLASM(int)    UNWIND_WRAP(SUPSemEventMultiReset)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti);
     192DECLASM(int)    UNWIND_WRAP(SUPSemEventMultiWait)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies);
     193DECLASM(int)    UNWIND_WRAP(SUPSemEventMultiWaitNoResume)(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies);
    180194DECLASM(SUPPAGINGMODE) UNWIND_WRAP(SUPR0GetPagingMode)(void);
    181195DECLASM(void *) UNWIND_WRAP(RTMemAlloc)(size_t cb) RT_NO_THROW;
    … …  
    316330    { "SUPR0PageFree",                          (void *)UNWIND_WRAP(SUPR0PageFree) },
    317331    { "SUPR0Printf",                            (void *)SUPR0Printf }, /** @todo needs wrapping? */
     332    { "SUPSemEventCreate",                      (void *)UNWIND_WRAP(SUPSemEventCreate) },
     333    { "SUPSemEventClose",                       (void *)UNWIND_WRAP(SUPSemEventClose) },
     334    { "SUPSemEventSignal",                      (void *)UNWIND_WRAP(SUPSemEventSignal) },
     335    { "SUPSemEventWait",                        (void *)UNWIND_WRAP(SUPSemEventWait) },
     336    { "SUPSemEventWaitNoResume",                (void *)UNWIND_WRAP(SUPSemEventWaitNoResume) },
     337    { "SUPSemEventMultiCreate",                 (void *)UNWIND_WRAP(SUPSemEventMultiCreate) },
     338    { "SUPSemEventMultiClose",                  (void *)UNWIND_WRAP(SUPSemEventMultiClose) },
     339    { "SUPSemEventMultiSignal",                 (void *)UNWIND_WRAP(SUPSemEventMultiSignal) },
     340    { "SUPSemEventMultiReset",                  (void *)UNWIND_WRAP(SUPSemEventMultiReset) },
     341    { "SUPSemEventMultiWait",                   (void *)UNWIND_WRAP(SUPSemEventMultiWait) },
     342    { "SUPSemEventMultiWaitNoResume",           (void *)UNWIND_WRAP(SUPSemEventMultiWaitNoResume) },
    318343    { "SUPR0GetPagingMode",                     (void *)UNWIND_WRAP(SUPR0GetPagingMode) },
    319344    { "SUPR0EnableVTx",                         (void *)SUPR0EnableVTx },
    … …  
    649674        if (!rc)
    650675        {
    651             Assert(pSession->Spinlock != NIL_RTSPINLOCK);
    652             pSession->pDevExt           = pDevExt;
    653             pSession->u32Cookie         = BIRD_INV;
    654             /*pSession->pLdrUsage         = NULL;
    655             pSession->pVM               = NULL;
    656             pSession->pUsage            = NULL;
    657             pSession->pGip              = NULL;
    658             pSession->fGipReferenced    = false;
    659             pSession->Bundle.cUsed      = 0; */
    660             pSession->Uid               = NIL_RTUID;
    661             pSession->Gid               = NIL_RTGID;
    662             if (fUser)
    663             {
    664                 pSession->Process       = RTProcSelf();
    665                 pSession->R0Process     = RTR0ProcHandleSelf();
    666             }
    667             else
    668             {
    669                 pSession->Process       = NIL_RTPROCESS;
    670                 pSession->R0Process     = NIL_RTR0PROCESS;
    671             }
    672 
    673             LogFlow(("Created session %p initial cookie=%#x\n", pSession, pSession->u32Cookie));
    674             return VINF_SUCCESS;
    675         }
    676 
     676            rc = RTHandleTableCreateEx(&pSession->hHandleTable,
     677                                       RTHANDLETABLE_FLAGS_LOCKED | RTHANDLETABLE_FLAGS_CONTEXT,
     678                                       1 /*uBase*/, 32768 /*cMax*/, supdrvSessionObjHandleRetain, pSession);
     679            if (RT_SUCCESS(rc))
     680            {
     681                Assert(pSession->Spinlock != NIL_RTSPINLOCK);
     682                pSession->pDevExt           = pDevExt;
     683                pSession->u32Cookie         = BIRD_INV;
     684                /*pSession->pLdrUsage         = NULL;
     685                pSession->pVM               = NULL;
     686                pSession->pUsage            = NULL;
     687                pSession->pGip              = NULL;
     688                pSession->fGipReferenced    = false;
     689                pSession->Bundle.cUsed      = 0; */
     690                pSession->Uid               = NIL_RTUID;
     691                pSession->Gid               = NIL_RTGID;
     692                if (fUser)
     693                {
     694                    pSession->Process       = RTProcSelf();
     695                    pSession->R0Process     = RTR0ProcHandleSelf();
     696                }
     697                else
     698                {
     699                    pSession->Process       = NIL_RTPROCESS;
     700                    pSession->R0Process     = NIL_RTR0PROCESS;
     701                }
     702
     703                LogFlow(("Created session %p initial cookie=%#x\n", pSession, pSession->u32Cookie));
     704                return VINF_SUCCESS;
     705            }
     706
     707            RTSpinlockDestroy(pSession->Spinlock);
     708        }
    677709        RTMemFree(pSession);
    678710        *ppSession = NULL;
    … …  
    721753void VBOXCALL supdrvCleanupSession(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
    722754{
     755    int                 rc;
    723756    PSUPDRVBUNDLE       pBundle;
    724757    LogFlow(("supdrvCleanupSession: pSession=%p\n", pSession));
    … …  
    728761     */
    729762    RTLogSetDefaultInstanceThread(NULL, (uintptr_t)pSession);
     763
     764    /*
     765     * Destroy the handle table.
     766     */
     767    rc = RTHandleTableDestroy(pSession->hHandleTable, supdrvSessionObjHandleDelete, pSession);
     768    AssertRC(rc);
     769    pSession->hHandleTable = NIL_RTHANDLETABLE;
    730770
    731771    /*
    … …  
    915955    }
    916956    Log2(("umapping GIP - done\n"));
     957}
     958
     959
     960/**
     961 * RTHandleTableDestroy callback used by supdrvCleanupSession.
     962 *
     963 * @returns IPRT status code, see SUPR0ObjAddRef.
     964 * @param   hHandleTable    The handle table handle. Ignored.
     965 * @param   pvObj           The object pointer.
     966 * @param   pvCtx           Context. NULL.
     967 * @param   pvUser          Session pointer.
     968 */
     969static DECLCALLBACK(int) supdrvSessionObjHandleRetain(RTHANDLETABLE hHandleTable, void *pvObj, void *pvCtx, void *pvUser)
     970{
     971    Assert(!pvCtx);
     972    NOREF(pvCtx);
     973    NOREF(hHandleTable);
     974    return SUPR0ObjAddRef(pvObj, (PSUPDRVSESSION)pvUser);
     975}
     976
     977
     978/**
     979 * RTHandleTableDestroy callback used by supdrvCleanupSession.
     980 *
     981 * @param   hHandleTable    The handle table handle. Ignored.
     982 * @param   h               The handle value. Ignored.
     983 * @param   pvObj           The object pointer.
     984 * @param   pvCtx           Context. NULL.
     985 * @param   pvUser          Session pointer.
     986 */
     987static DECLCALLBACK(void) supdrvSessionObjHandleDelete(RTHANDLETABLE hHandleTable, uint32_t h, void *pvObj, void *pvCtx, void *pvUser)
     988{
     989    Assert(!pvCtx);
     990    NOREF(pvCtx);
     991    NOREF(h);
     992    NOREF(hHandleTable);
     993    SUPR0ObjRelease(pvObj, (PSUPDRVSESSION)pvUser);
    917994}
    918995
    … …  
    31803257        RTSemFastMutexRelease(pSession->pDevExt->mtxComponentFactory);
    31813258    }
     3259    return rc;
     3260}
     3261
     3262
     3263/**
     3264 * Destructor for objects created by SUPSemEventCreate.
     3265 *
     3266 * @param   pvObj               The object handle.
     3267 * @param   pvUser1             The IPRT event handle.
     3268 * @param   pvUser2             NULL.
     3269 */
     3270static DECLCALLBACK(void) supR0SemEventDestructor(void *pvObj, void *pvUser1, void *pvUser2)
     3271{
     3272    Assert(pvUser2 == NULL);
     3273    NOREF(pvObj);
     3274    RTSemEventDestroy((RTSEMEVENT)pvUser1);
     3275}
     3276
     3277
     3278SUPDECL(int) SUPSemEventCreate(PSUPDRVSESSION pSession, PSUPSEMEVENT phEvent)
     3279{
     3280    int         rc;
     3281    RTSEMEVENT  hEventReal;
     3282
     3283    /*
     3284     * Input validation.
     3285     */
     3286    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     3287    AssertPtrReturn(phEvent, VERR_INVALID_POINTER);
     3288
     3289    /*
     3290     * Create the event semaphore object.
     3291     */
     3292    rc = RTSemEventCreate(&hEventReal);
     3293    if (RT_SUCCESS(rc))
     3294    {
     3295        void *pvObj = SUPR0ObjRegister(pSession, SUPDRVOBJTYPE_SEM_EVENT, supR0SemEventDestructor, hEventReal, NULL);
     3296        if (pvObj)
     3297        {
     3298            uint32_t h32;
     3299            rc = RTHandleTableAllocWithCtx(pSession->hHandleTable, pvObj, SUPDRV_HANDLE_CTX_EVENT, &h32);
     3300            if (RT_SUCCESS(rc))
     3301            {
     3302                *phEvent = (SUPSEMEVENT)(uintptr_t)h32;
     3303                return VINF_SUCCESS;
     3304            }
     3305            SUPR0ObjRelease(pvObj, pSession);
     3306        }
     3307        else
     3308            RTSemEventDestroy(hEventReal);
     3309    }
     3310    return rc;
     3311}
     3312
     3313
     3314SUPDECL(int) SUPSemEventClose(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent)
     3315{
     3316    uint32_t    h32;
     3317    PSUPDRVOBJ  pObj;
     3318
     3319    /*
     3320     * Input validation.
     3321     */
     3322    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     3323    if (hEvent == NIL_SUPSEMEVENT)
     3324        return VINF_SUCCESS;
     3325    h32 = (uint32_t)(uintptr_t)hEvent;
     3326    if (h32 != (uintptr_t)hEvent)
     3327        return VERR_INVALID_HANDLE;
     3328
     3329    /*
     3330     * Do the job.
     3331     */
     3332    pObj = (PSUPDRVOBJ)RTHandleTableFreeWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT);
     3333    if (!pObj)
     3334        return VERR_INVALID_HANDLE;
     3335
     3336    Assert(pObj->cUsage >= 2);
     3337    SUPR0ObjRelease(pObj, pSession);        /* The free call above. */
     3338    return SUPR0ObjRelease(pObj, pSession); /* The handle table reference. */
     3339}
     3340
     3341
     3342SUPDECL(int) SUPSemEventSignal(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent)
     3343{
     3344    int         rc;
     3345    uint32_t    h32;
     3346    PSUPDRVOBJ  pObj;
     3347
     3348    /*
     3349     * Input validation.
     3350     */
     3351    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     3352    h32 = (uint32_t)(uintptr_t)hEvent;
     3353    if (h32 != (uintptr_t)hEvent)
     3354        return VERR_INVALID_HANDLE;
     3355    pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT);
     3356    if (!pObj)
     3357        return VERR_INVALID_HANDLE;
     3358
     3359    /*
     3360     * Do the job.
     3361     */
     3362    rc = RTSemEventSignal((RTSEMEVENT)pObj->pvUser1);
     3363
     3364    SUPR0ObjRelease(pObj, pSession);
     3365    return rc;
     3366}
     3367
     3368
     3369SUPDECL(int) SUPSemEventWait(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies)
     3370{
     3371    int         rc;
     3372    uint32_t    h32;
     3373    PSUPDRVOBJ  pObj;
     3374
     3375    /*
     3376     * Input validation.
     3377     */
     3378    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     3379    h32 = (uint32_t)(uintptr_t)hEvent;
     3380    if (h32 != (uintptr_t)hEvent)
     3381        return VERR_INVALID_HANDLE;
     3382    pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT);
     3383    if (!pObj)
     3384        return VERR_INVALID_HANDLE;
     3385
     3386    /*
     3387     * Do the job.
     3388     */
     3389    rc = RTSemEventWait((RTSEMEVENT)pObj->pvUser1, cMillies);
     3390
     3391    SUPR0ObjRelease(pObj, pSession);
     3392    return rc;
     3393}
     3394
     3395
     3396SUPDECL(int) SUPSemEventWaitNoResume(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies)
     3397{
     3398    int         rc;
     3399    uint32_t    h32;
     3400    PSUPDRVOBJ  pObj;
     3401
     3402    /*
     3403     * Input validation.
     3404     */
     3405    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     3406    h32 = (uint32_t)(uintptr_t)hEvent;
     3407    if (h32 != (uintptr_t)hEvent)
     3408        return VERR_INVALID_HANDLE;
     3409    pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT);
     3410    if (!pObj)
     3411        return VERR_INVALID_HANDLE;
     3412
     3413    /*
     3414     * Do the job.
     3415     */
     3416    rc = RTSemEventWaitNoResume((RTSEMEVENT)pObj->pvUser1, cMillies);
     3417
     3418    SUPR0ObjRelease(pObj, pSession);
     3419    return rc;
     3420}
     3421
     3422
     3423/**
     3424 * Destructor for objects created by SUPSemEventMultiCreate.
     3425 *
     3426 * @param   pvObj               The object handle.
     3427 * @param   pvUser1             The IPRT event handle.
     3428 * @param   pvUser2             NULL.
     3429 */
     3430static DECLCALLBACK(void) supR0SemEventMultiDestructor(void *pvObj, void *pvUser1, void *pvUser2)
     3431{
     3432    Assert(pvUser2 == NULL);
     3433    NOREF(pvObj);
     3434    RTSemEventMultiDestroy((RTSEMEVENTMULTI)pvUser1);
     3435}
     3436
     3437
     3438SUPDECL(int) SUPSemEventMultiCreate(PSUPDRVSESSION pSession, PSUPSEMEVENTMULTI phEventMulti)
     3439{
     3440    int             rc;
     3441    RTSEMEVENTMULTI hEventMultReal;
     3442
     3443    /*
     3444     * Input validation.
     3445     */
     3446    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     3447    AssertPtrReturn(phEventMulti, VERR_INVALID_POINTER);
     3448
     3449    /*
     3450     * Create the event semaphore object.
     3451     */
     3452    rc = RTSemEventMultiCreate(&hEventMultReal);
     3453    if (RT_SUCCESS(rc))
     3454    {
     3455        void *pvObj = SUPR0ObjRegister(pSession, SUPDRVOBJTYPE_SEM_EVENT_MULTI, supR0SemEventMultiDestructor, hEventMultReal, NULL);
     3456        if (pvObj)
     3457        {
     3458            uint32_t h32;
     3459            rc = RTHandleTableAllocWithCtx(pSession->hHandleTable, pvObj, &h32, SUPDRV_HANDLE_CTX_EVENT_MULTI);
     3460            if (RT_SUCCESS(rc))
     3461            {
     3462                *phEventMulti = (SUPSEMEVENTMULTI)(uintptr_t)h32;
     3463                return VINF_SUCCESS;
     3464            }
     3465            SUPR0ObjRelease(pvObj, pSession);
     3466        }
     3467        else
     3468            RTSemEventMultiDestroy(hEventMultReal);
     3469    }
     3470    return rc;
     3471}
     3472
     3473
     3474SUPDECL(int) SUPSemEventMultiClose(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti)
     3475{
     3476    uint32_t    h32;
     3477    PSUPDRVOBJ  pObj;
     3478
     3479    /*
     3480     * Input validation.
     3481     */
     3482    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     3483    if (hEventMulti == NIL_SUPSEMEVENTMULTI)
     3484        return VINF_SUCCESS;
     3485    h32 = (uint32_t)(uintptr_t)hEventMulti;
     3486    if (h32 != (uintptr_t)hEventMulti)
     3487        return VERR_INVALID_HANDLE;
     3488
     3489    /*
     3490     * Do the job.
     3491     */
     3492    pObj = (PSUPDRVOBJ)RTHandleTableFreeWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT_MULTI);
     3493    if (!pObj)
     3494        return VERR_INVALID_HANDLE;
     3495
     3496    Assert(pObj->cUsage >= 2);
     3497    SUPR0ObjRelease(pObj, pSession);        /* The free call above. */
     3498    return SUPR0ObjRelease(pObj, pSession); /* The handle table reference. */
     3499}
     3500
     3501
     3502SUPDECL(int) SUPSemEventMultiSignal(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti)
     3503{
     3504    int         rc;
     3505    uint32_t    h32;
     3506    PSUPDRVOBJ  pObj;
     3507
     3508    /*
     3509     * Input validation.
     3510     */
     3511    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     3512    h32 = (uint32_t)(uintptr_t)hEventMulti;
     3513    if (h32 != (uintptr_t)hEventMulti)
     3514        return VERR_INVALID_HANDLE;
     3515    pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT_MULTI);
     3516    if (!pObj)
     3517        return VERR_INVALID_HANDLE;
     3518
     3519    /*
     3520     * Do the job.
     3521     */
     3522    rc = RTSemEventMultiSignal((RTSEMEVENTMULTI)pObj->pvUser1);
     3523
     3524    SUPR0ObjRelease(pObj, pSession);
     3525    return rc;
     3526}
     3527
     3528
     3529SUPDECL(int) SUPSemEventMultiReset(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti)
     3530{
     3531    int         rc;
     3532    uint32_t    h32;
     3533    PSUPDRVOBJ  pObj;
     3534
     3535    /*
     3536     * Input validation.
     3537     */
     3538    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     3539    h32 = (uint32_t)(uintptr_t)hEventMulti;
     3540    if (h32 != (uintptr_t)hEventMulti)
     3541        return VERR_INVALID_HANDLE;
     3542    pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT_MULTI);
     3543    if (!pObj)
     3544        return VERR_INVALID_HANDLE;
     3545
     3546    /*
     3547     * Do the job.
     3548     */
     3549    rc = RTSemEventMultiReset((RTSEMEVENTMULTI)pObj->pvUser1);
     3550
     3551    SUPR0ObjRelease(pObj, pSession);
     3552    return rc;
     3553}
     3554
     3555
     3556SUPDECL(int) SUPSemEventMultiWait(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies)
     3557{
     3558    int         rc;
     3559    uint32_t    h32;
     3560    PSUPDRVOBJ  pObj;
     3561
     3562    /*
     3563     * Input validation.
     3564     */
     3565    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     3566    h32 = (uint32_t)(uintptr_t)hEventMulti;
     3567    if (h32 != (uintptr_t)hEventMulti)
     3568        return VERR_INVALID_HANDLE;
     3569    pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT_MULTI);
     3570    if (!pObj)
     3571        return VERR_INVALID_HANDLE;
     3572
     3573    /*
     3574     * Do the job.
     3575     */
     3576    rc = RTSemEventMultiWait((RTSEMEVENTMULTI)pObj->pvUser1, cMillies);
     3577
     3578    SUPR0ObjRelease(pObj, pSession);
     3579    return rc;
     3580}
     3581
     3582
     3583SUPDECL(int) SUPSemEventMultiWaitNoResume(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies)
     3584{
     3585    int         rc;
     3586    uint32_t    h32;
     3587    PSUPDRVOBJ  pObj;
     3588
     3589    /*
     3590     * Input validation.
     3591     */
     3592    AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
     3593    h32 = (uint32_t)(uintptr_t)hEventMulti;
     3594    if (h32 != (uintptr_t)hEventMulti)
     3595        return VERR_INVALID_HANDLE;
     3596    pObj = (PSUPDRVOBJ)RTHandleTableLookupWithCtx(pSession->hHandleTable, h32, SUPDRV_HANDLE_CTX_EVENT_MULTI);
     3597    if (!pObj)
     3598        return VERR_INVALID_HANDLE;
     3599
     3600    /*
     3601     * Do the job.
     3602     */
     3603    rc = RTSemEventMultiWaitNoResume((RTSEMEVENTMULTI)pObj->pvUser1, cMillies);
     3604
     3605    SUPR0ObjRelease(pObj, pSession);
    31823606    return rc;
    31833607}

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

    r19454 r19866  
    309309
    310310
     311/** @name Context values for the per-session handle tables.
     312 * The context value is used to distiguish between the different kinds of
     313 * handles, making the handle table API do all the work.
     314 * @{ */
     315/** Handle context value for single release event handles.  */
     316#define SUPDRV_HANDLE_CTX_EVENT         ((void *)(uintptr_t)(SUPDRVOBJTYPE_SEM_EVENT))
     317/** Handle context value for multiple release event handles.  */
     318#define SUPDRV_HANDLE_CTX_EVENT_MULTI   ((void *)(uintptr_t)(SUPDRVOBJTYPE_SEM_EVENT_MULTI))
     319/** @} */
     320
    311321
    312322/*******************************************************************************
    … …  
    494504    uint32_t                        u32Cookie;
    495505
     506    /** The VM associated with the session. */
     507    PVM                             pVM;
     508    /** Handle table for IPRT semaphore wrapper APIs.
     509     * Programmable from R0 and R3. */
     510    RTHANDLETABLE                   hHandleTable;
    496511    /** Load usage records. (protected by SUPDRVDEVEXT::mtxLdr) */
    497512    PSUPDRVLDRUSAGE volatile        pLdrUsage;
    498     /** The VM associated with the session. */
    499     PVM                             pVM;
    500     /** List of generic usage records. (protected by SUPDRVDEVEXT::SpinLock) */
    501     PSUPDRVUSAGE volatile           pUsage;
    502513
    503514    /** Spinlock protecting the bundles and the GIP members. */
    … …  
    509520    /** Bundle of locked memory objects. */
    510521    SUPDRVBUNDLE                    Bundle;
     522    /** List of generic usage records. (protected by SUPDRVDEVEXT::SpinLock) */
     523    PSUPDRVUSAGE volatile           pUsage;
    511524
    512525    /** The user id of the session. (Set by the OS part.) */

  • trunk/src/VBox/HostDrivers/Support/SUPR0.def

    r19404 r19866  
    5454    SUPR0MemFree
    5555    SUPR0Printf
     56    SUPSemEventCreate
     57    SUPSemEventClose
     58    SUPSemEventSignal
     59    SUPSemEventWait
     60    SUPSemEventWaitNoResume
     61    SUPSemEventMultiCreate
     62    SUPSemEventMultiClose
     63    SUPSemEventMultiSignal
     64    SUPSemEventMultiReset
     65    SUPSemEventMultiWait
     66    SUPSemEventMultiWaitNoResume
    5667    SUPR0GetPagingMode
    5768    SUPR0EnableVTx

  • trunk/src/VBox/HostDrivers/Support/linux/Makefile

    r19455 r19866  
    104104        common/log/logcom.o \
    105105        common/log/logformat.o \
     106        common/misc/handletable.o \
     107        common/misc/handletablectx.o \
    106108        common/string/strformat.o \
    107109        common/string/strformatrt.o \

  • trunk/src/VBox/HostDrivers/Support/linux/files_vboxdrv

    r14645 r19866  
    3737    ${PATH_ROOT}/include/iprt/err.h=>include/iprt/err.h \
    3838    ${PATH_ROOT}/include/iprt/heap.h=>include/iprt/heap.h \
     39    ${PATH_ROOT}/include/iprt/handletable.h=>include/iprt/handletable.h \
    3940    ${PATH_ROOT}/include/iprt/initterm.h=>include/iprt/initterm.h \
    4041    ${PATH_ROOT}/include/iprt/log.h=>include/iprt/log.h \
    … …  
    8182    ${PATH_ROOT}/src/VBox/Runtime/common/math/gcc/udivdi3.c=>math/gcc/udivdi3.c \
    8283    ${PATH_ROOT}/src/VBox/Runtime/common/math/gcc/umoddi3.c=>math/gcc/umoddi3.c \
     84    ${PATH_ROOT}/src/VBox/Runtime/common/misc/handletable.cpp=>common/misc/handletable.c \
     85    ${PATH_ROOT}/src/VBox/Runtime/common/misc/handletable.h=>common/misc/handletable.h \
     86    ${PATH_ROOT}/src/VBox/Runtime/common/misc/handletablectx.cpp=>common/misc/handletablectx.c \
    8387    ${PATH_ROOT}/src/VBox/Runtime/common/string/strformat.cpp=>common/string/strformat.c \
    8488    ${PATH_ROOT}/src/VBox/Runtime/common/string/strformatrt.cpp=>common/string/strformatrt.c \

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

    r19393 r19866  
    7575NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0PageFree
    7676;NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0Printf            - cannot wrap this buster.
     77NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventCreate
     78NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventClose
     79NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventSignal
     80NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventWait
     81NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventWaitNoResume
     82NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventMultiCreate
     83NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventMultiClose
     84NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventMultiSignal
     85NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventMultiReset
     86NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventMultiWait
     87NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPSemEventMultiWaitNoResume
    7788NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, SUPR0GetPagingMode
    7889NtWrapDyn2DrvFunctionWithAllRegParams  supdrvNtWrap, RTMemAlloc
Note: See TracChangeset for help on using the changeset viewer.

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