VirtualBox

Changeset 44725 in vbox for trunk/src/VBox/Devices/VMMDev


Ignore:
Timestamp:
Feb 15, 2013 7:31:12 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
83826
Message:

Moving the backdoor logging and timesync down so the request handling is in one big block at the top of the file, rather than split by three I/O handlers. Documented the IRQ related functions, realizing that the _EMT bits no longer applies (and wasn't a requirement since a very long time (PIC/PCI IRQ raising was only done by EMT at some point). The critsect takes care of serialization. VMMDevState * -> PVMMDEV.

Location:
trunk/src/VBox/Devices/VMMDev
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

    r44723 r44725  
    129129 */
    130130
    131 static void vmmdevSetIRQ_Legacy_EMT(VMMDevState *pThis)
     131
     132/* -=-=-=-=- Misc Helpers -=-=-=-=- */
     133
     134
     135/**
     136 * Sets the IRQ (raise it or lower it) for 1.03 additions.
     137 *
     138 * @param   pThis       The VMMDev state.
     139 * @thread  Any.
     140 * @remarks Must be called owning the critical section.
     141 */
     142static void vmmdevSetIRQ_Legacy(PVMMDEV pThis)
    132143{
    133144    if (!pThis->fu32AdditionsOk)
    … …  
    137148    }
    138149
    139     uint32_t u32IRQLevel = 0;
    140 
    141150    /* Filter unsupported events */
    142     uint32_t u32EventFlags =
    143         pThis->u32HostEventFlags
    144         & pThis->pVMMDevRAMR3->V.V1_03.u32GuestEventMask;
    145 
    146     Log(("vmmdevSetIRQ: u32EventFlags = 0x%08X, "
    147          "pThis->u32HostEventFlags = 0x%08X, "
    148          "pThis->pVMMDevRAMR3->u32GuestEventMask = 0x%08X\n",
    149          u32EventFlags,
    150          pThis->u32HostEventFlags,
    151          pThis->pVMMDevRAMR3->V.V1_03.u32GuestEventMask));
     151    uint32_t u32EventFlags = pThis->u32HostEventFlags
     152                           & pThis->pVMMDevRAMR3->V.V1_03.u32GuestEventMask;
     153
     154    Log(("vmmdevSetIRQ: u32EventFlags=%#010x, u32HostEventFlags=%#010x, u32GuestEventMask=%#010x.\n",
     155         u32EventFlags, pThis->u32HostEventFlags, pThis->pVMMDevRAMR3->V.V1_03.u32GuestEventMask));
    152156
    153157    /* Move event flags to VMMDev RAM */
    154158    pThis->pVMMDevRAMR3->V.V1_03.u32HostEvents = u32EventFlags;
    155159
     160    uint32_t u32IRQLevel = 0;
    156161    if (u32EventFlags)
    157162    {
    158163        /* Clear host flags which will be delivered to guest. */
    159164        pThis->u32HostEventFlags &= ~u32EventFlags;
    160         Log(("vmmdevSetIRQ: pThis->u32HostEventFlags = 0x%08X\n",
    161              pThis->u32HostEventFlags));
     165        Log(("vmmdevSetIRQ: u32HostEventFlags=%#010x\n", pThis->u32HostEventFlags));
    162166        u32IRQLevel = 1;
    163167    }
    164168
    165     /* Set IRQ level for pin 0 */
     169    /* Set IRQ level for pin 0 (see NoWait comment in vmmdevMaybeSetIRQ). */
    166170    /** @todo make IRQ pin configurable, at least a symbolic constant */
    167171    PPDMDEVINS pDevIns = pThis->pDevIns;
    … …  
    170174}
    171175
    172 static void vmmdevMaybeSetIRQ_EMT(VMMDevState *pThis)
    173 {
    174     Log3(("vmmdevMaybeSetIRQ_EMT: u32HostEventFlags = 0x%08X, u32GuestFilterMask = 0x%08X.\n",
     176/**
     177 * Sets the IRQ if there are events to be delivered.
     178 *
     179 * @param   pThis       The VMMDev state.
     180 * @thread  Any.
     181 * @remarks Must be called owning the critical section.
     182 */
     183static void vmmdevMaybeSetIRQ(PVMMDEV pThis)
     184{
     185    Log3(("vmmdevMaybeSetIRQ: u32HostEventFlags=%#010x, u32GuestFilterMask=%#010x.\n",
    175186          pThis->u32HostEventFlags, pThis->u32GuestFilterMask));
    176187
    177188    if (pThis->u32HostEventFlags & pThis->u32GuestFilterMask)
    178189    {
     190        /*
     191         * Note! No need to wait for the IRQs to be set (if we're not luck
     192         *       with the locks, etc).  It is a notification about something,
     193         *       which has already happened.
     194         */
    179195        pThis->pVMMDevRAMR3->V.V1_04.fHaveEvents = true;
    180196        PDMDevHlpPCISetIrqNoWait(pThis->pDevIns, 0, 1);
    181         Log3(("vmmdevMaybeSetIRQ_EMT: IRQ set.\n"));
    182     }
    183 }
    184 
    185 static void vmmdevNotifyGuest_EMT(VMMDevState *pThis, uint32_t u32EventMask)
    186 {
    187     Log3(("VMMDevNotifyGuest_EMT: u32EventMask = 0x%08X.\n", u32EventMask));
     197        Log3(("vmmdevMaybeSetIRQ: IRQ set.\n"));
     198    }
     199}
     200
     201/**
     202 * Notifies the guest about new events (@a fAddEvents).
     203 *
     204 * @param   pThis           The VMMDev state.
     205 * @param   fAddEvents      New events to add.
     206 * @thread  Any.
     207 * @remarks Must be called owning the critical section.
     208 */
     209static void vmmdevNotifyGuestWorker(PVMMDEV pThis, uint32_t fAddEvents)
     210{
     211    Log3(("vmmdevNotifyGuestWorker: fAddEvents=%#010x.\n", fAddEvents));
     212    Assert(PDMCritSectIsOwner(&pThis->CritSect));
    188213
    189214    if (VBOX_GUEST_INTERFACE_VERSION_1_03(pThis))
    190215    {
    191         Log3(("VMMDevNotifyGuest_EMT: Old additions detected.\n"));
    192 
    193         pThis->u32HostEventFlags |= u32EventMask;
    194         vmmdevSetIRQ_Legacy_EMT(pThis);
     216        Log3(("vmmdevNotifyGuestWorker: Old additions detected.\n"));
     217
     218        pThis->u32HostEventFlags |= fAddEvents;
     219        vmmdevSetIRQ_Legacy(pThis);
    195220    }
    196221    else
    197222    {
    198         Log3(("VMMDevNotifyGuest_EMT: New additions detected.\n"));
     223        Log3(("vmmdevNotifyGuestWorker: New additions detected.\n"));
    199224
    200225        if (!pThis->fu32AdditionsOk)
    201226        {
    202             pThis->u32HostEventFlags |= u32EventMask;
    203             Log(("vmmdevNotifyGuest_EMT: IRQ is not generated, guest has not yet reported to us.\n"));
     227            pThis->u32HostEventFlags |= fAddEvents;
     228            Log(("vmmdevNotifyGuestWorker: IRQ is not generated, guest has not yet reported to us.\n"));
    204229            return;
    205230        }
    206231
    207         const bool fHadEvents =
    208             (pThis->u32HostEventFlags & pThis->u32GuestFilterMask) != 0;
    209 
    210         Log3(("VMMDevNotifyGuest_EMT: fHadEvents = %d, u32HostEventFlags = 0x%08X, u32GuestFilterMask = 0x%08X.\n",
     232        const bool fHadEvents = (pThis->u32HostEventFlags & pThis->u32GuestFilterMask) != 0;
     233
     234        Log3(("vmmdevNotifyGuestWorker: fHadEvents=%d, u32HostEventFlags=%#010x, u32GuestFilterMask=%#010x.\n",
    211235              fHadEvents, pThis->u32HostEventFlags, pThis->u32GuestFilterMask));
    212236
    213         pThis->u32HostEventFlags |= u32EventMask;
     237        pThis->u32HostEventFlags |= fAddEvents;
    214238
    215239        if (!fHadEvents)
    216             vmmdevMaybeSetIRQ_EMT (pThis);
    217     }
    218 }
    219 
    220 void VMMDevCtlSetGuestFilterMask (VMMDevState *pThis,
    221                                   uint32_t u32OrMask,
    222                                   uint32_t u32NotMask)
    223 {
    224     PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
    225 
    226     const bool fHadEvents =
    227         (pThis->u32HostEventFlags & pThis->u32GuestFilterMask) != 0;
    228 
    229     Log(("VMMDevCtlSetGuestFilterMask: u32OrMask = 0x%08X, u32NotMask = 0x%08X, fHadEvents = %d.\n", u32OrMask, u32NotMask, fHadEvents));
    230     if (fHadEvents)
    231     {
    232         if (!pThis->fNewGuestFilterMask)
    233             pThis->u32NewGuestFilterMask = pThis->u32GuestFilterMask;
    234 
    235         pThis->u32NewGuestFilterMask |= u32OrMask;
    236         pThis->u32NewGuestFilterMask &= ~u32NotMask;
    237         pThis->fNewGuestFilterMask = true;
    238     }
    239     else
    240     {
    241         pThis->u32GuestFilterMask |= u32OrMask;
    242         pThis->u32GuestFilterMask &= ~u32NotMask;
    243         vmmdevMaybeSetIRQ_EMT (pThis);
    244     }
    245     PDMCritSectLeave(&pThis->CritSect);
    246 }
    247 
    248 void VMMDevNotifyGuest (VMMDevState *pThis, uint32_t u32EventMask)
    249 {
    250     PPDMDEVINS pDevIns = pThis->pDevIns;
    251 
    252     Log3(("VMMDevNotifyGuest: u32EventMask = 0x%08X.\n", u32EventMask));
     240            vmmdevMaybeSetIRQ(pThis);
     241    }
     242}
     243
     244
     245
     246/* -=-=-=-=- Interfaces shared with VMMDevHGCM.cpp  -=-=-=-=- */
     247
     248/**
     249 * Notifies the guest about new events (@a fAddEvents).
     250 *
     251 * This is used by VMMDev.cpp as well as VMMDevHGCM.cpp.
     252 *
     253 * @param   pThis           The VMMDev state.
     254 * @param   fAddEvents      New events to add.
     255 * @thread  Any.
     256 */
     257void VMMDevNotifyGuest(PVMMDEV pThis, uint32_t fAddEvents)
     258{
     259    Log3(("VMMDevNotifyGuest: fAddEvents=%#010x\n", fAddEvents));
    253260
    254261    /*
    255262     * Drop notifications if the VM is not running yet/anymore.
    256263     */
    257     VMSTATE enmVMState = PDMDevHlpVMState(pDevIns);
     264    VMSTATE enmVMState = PDMDevHlpVMState(pThis->pDevIns);
    258265    if (    enmVMState != VMSTATE_RUNNING
    259266        &&  enmVMState != VMSTATE_RUNNING_LS)
    … …  
    261268
    262269    PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
    263     /* No need to wait for the completion of this request. It is a notification
    264      * about something, which has already happened.
    265      */
    266     vmmdevNotifyGuest_EMT(pThis, u32EventMask);
     270    vmmdevNotifyGuestWorker(pThis, fAddEvents);
    267271    PDMCritSectLeave(&pThis->CritSect);
    268272}
    269273
    270274/**
    271  * Port I/O Handler for OUT operations.
     275 * Code shared by VMMDevReq_CtlGuestFilterMask and HGCM for controlling the
     276 * events the guest are interested in.
    272277 *
    273  * @returns VBox status code.
     278 * @param   pThis           The VMMDev state.
     279 * @param   fOrMask         Events to add (VMMDEV_EVENT_XXX). Pass 0 for no
     280 *                          change.
     281 * @param   fNotMask        Events to remove (VMMDEV_EVENT_XXX). Pass 0 for no
     282 *                          change.
    274283 *
    275  * @param   pDevIns     The device instance.
    276  * @param   pvUser      User argument - ignored.
    277  * @param   uPort       Port number used for the IN operation.
    278  * @param   u32         The value to output.
    279  * @param   cb          The value size in bytes.
    280  */
    281 static DECLCALLBACK(int) vmmdevBackdoorLog(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
    282 {
    283     VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
    284 
    285     if (!pThis->fBackdoorLogDisabled && cb == 1 && Port == RTLOG_DEBUG_PORT)
    286     {
    287 
    288         /* The raw version. */
    289         switch (u32)
    290         {
    291             case '\r': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <return>\n")); break;
    292             case '\n': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <newline>\n")); break;
    293             case '\t': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <tab>\n")); break;
    294             default:   LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: %c (%02x)\n", u32, u32)); break;
    295         }
    296 
    297         /* The readable, buffered version. */
    298         if (u32 == '\n' || u32 == '\r')
    299         {
    300             pThis->szMsg[pThis->iMsg] = '\0';
    301             if (pThis->iMsg)
    302                 LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("Guest Log: %s\n", pThis->szMsg));
    303             pThis->iMsg = 0;
    304         }
    305         else
    306         {
    307             if (pThis->iMsg >= sizeof(pThis->szMsg)-1)
    308             {
    309                 pThis->szMsg[pThis->iMsg] = '\0';
    310                 LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("Guest Log: %s\n", pThis->szMsg));
    311                 pThis->iMsg = 0;
    312             }
    313             pThis->szMsg[pThis->iMsg] = (char )u32;
    314             pThis->szMsg[++pThis->iMsg] = '\0';
    315         }
    316     }
    317     return VINF_SUCCESS;
    318 }
    319 
    320 #ifdef TIMESYNC_BACKDOOR
    321 /**
    322  * Port I/O Handler for OUT operations.
    323  *
    324  * @returns VBox status code.
    325  *
    326  * @param   pDevIns     The device instance.
    327  * @param   pvUser      User argument - ignored.
    328  * @param   uPort       Port number used for the IN operation.
    329  * @param   u32         The value to output.
    330  * @param   cb          The value size in bytes.
    331  */
    332 static DECLCALLBACK(int) vmmdevTimesyncBackdoorWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
    333 {
    334     NOREF(pvUser);
    335     if (cb == 4)
    336     {
    337         VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
    338         switch (u32)
    339         {
    340             case 0:
    341                 pThis->fTimesyncBackdoorLo = false;
    342                 break;
    343             case 1:
    344                 pThis->fTimesyncBackdoorLo = true;
    345         }
    346         return VINF_SUCCESS;
    347 
    348     }
    349     return VINF_SUCCESS;
    350 }
    351 
    352 /**
    353  * Port I/O Handler for backdoor timesync IN operations.
    354  *
    355  * @returns VBox status code.
    356  *
    357  * @param   pDevIns     The device instance.
    358  * @param   pvUser      User argument - ignored.
    359  * @param   uPort       Port number used for the IN operation.
    360  * @param   pu32        Where to store the result.
    361  * @param   cb          Number of bytes read.
    362  */
    363 static DECLCALLBACK(int) vmmdevTimesyncBackdoorRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
    364 {
    365     int rc;
    366     NOREF(pvUser);
    367     if (cb == 4)
    368     {
    369         VMMDevState *pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
    370         RTTIMESPEC now;
    371 
    372         if (pThis->fTimesyncBackdoorLo)
    373             *pu32 = (uint32_t)pThis->hostTime;
    374         else
    375         {
    376             pThis->hostTime = RTTimeSpecGetMilli(PDMDevHlpTMUtcNow(pDevIns, &now));
    377             *pu32 = (uint32_t)(pThis->hostTime >> 32);
    378         }
    379         rc = VINF_SUCCESS;
     284 * @remarks When HGCM will automatically enable VMMDEV_EVENT_HGCM when the guest
     285 *          starts submitting HGCM requests.  Otherwise, the events are
     286 *          controlled by the guest.
     287 */
     288void VMMDevCtlSetGuestFilterMask(PVMMDEV pThis, uint32_t fOrMask, uint32_t fNotMask)
     289{
     290    PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
     291
     292    const bool fHadEvents = (pThis->u32HostEventFlags & pThis->u32GuestFilterMask) != 0;
     293
     294    Log(("VMMDevCtlSetGuestFilterMask: fOrMask=%#010x, u32NotMask=%#010x, fHadEvents=%d.\n", fOrMask, fNotMask, fHadEvents));
     295    if (fHadEvents)
     296    {
     297        if (!pThis->fNewGuestFilterMask)
     298            pThis->u32NewGuestFilterMask = pThis->u32GuestFilterMask;
     299
     300        pThis->u32NewGuestFilterMask |= fOrMask;
     301        pThis->u32NewGuestFilterMask &= ~fNotMask;
     302        pThis->fNewGuestFilterMask = true;
    380303    }
    381304    else
    382         rc = VERR_IOM_IOPORT_UNUSED;
    383     return rc;
    384 }
    385 #endif /* TIMESYNC_BACKDOOR */
     305    {
     306        pThis->u32GuestFilterMask |= fOrMask;
     307        pThis->u32GuestFilterMask &= ~fNotMask;
     308        vmmdevMaybeSetIRQ(pThis);
     309    }
     310
     311    PDMCritSectLeave(&pThis->CritSect);
     312}
     313
     314
     315
     316/* -=-=-=-=- Request processing functions. -=-=-=-=- */
    386317
    387318/**
    … …  
    439370 * @param   pRequestHeader  The header of the request to handle.
    440371 */
    441 static int vmmdevReqHandler_ReportGuestInfo2(VMMDevState *pThis, VMMDevRequestHeader *pRequestHeader)
     372static int vmmdevReqHandler_ReportGuestInfo2(PVMMDEV pThis, VMMDevRequestHeader *pRequestHeader)
    442373{
    443374    AssertMsgReturn(pRequestHeader->size == sizeof(VMMDevReportGuestInfo2), ("%u\n", pRequestHeader->size), VERR_INVALID_PARAMETER);
    … …  
    546477 */
    547478static PVMMDEVFACILITYSTATUSENTRY
    548 vmmdevAllocFacilityStatusEntry(VMMDevState *pThis, uint32_t uFacility, bool fFixed, PCRTTIMESPEC pTimeSpecNow)
     479vmmdevAllocFacilityStatusEntry(PVMMDEV pThis, uint32_t uFacility, bool fFixed, PCRTTIMESPEC pTimeSpecNow)
    549480{
    550481    /* If full, expunge one inactive entry. */
    … …  
    609540 * @param   uFacility       The facility type code - VBoxGuestFacilityType.
    610541 */
    611 static PVMMDEVFACILITYSTATUSENTRY vmmdevGetFacilityStatusEntry(VMMDevState *pThis, uint32_t uFacility)
     542static PVMMDEVFACILITYSTATUSENTRY vmmdevGetFacilityStatusEntry(PVMMDEV pThis, uint32_t uFacility)
    612543{
    613544    /** @todo change to binary search. */
    … …  
    630561 * @param   pRequestHeader  The header of the request to handle.
    631562 */
    632 static int vmmdevReqHandler_ReportGuestStatus(VMMDevState *pThis, VMMDevRequestHeader *pRequestHeader)
     563static int vmmdevReqHandler_ReportGuestStatus(PVMMDEV pThis, VMMDevRequestHeader *pRequestHeader)
    633564{
    634565    /*
    … …  
    757688 * @param   pReq            Pointer to the request.
    758689 */
    759 static int vmmdevReqHandler_GetPageSharingStatus(VMMDevState *pThis, VMMDevPageSharingStatusRequest *pReq)
     690static int vmmdevReqHandler_GetPageSharingStatus(PVMMDEV pThis, VMMDevPageSharingStatusRequest *pReq)
    760691{
    761692    AssertMsgReturn(pReq->header.size == sizeof(VMMDevPageSharingStatusRequest),
    … …  
    801732static DECLCALLBACK(int) vmmdevRequestHandler(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
    802733{
    803     VMMDevState *pThis = (VMMDevState*)pvUser;
     734    PVMMDEV pThis = (VMMDevState*)pvUser;
    804735    int rcRet = VINF_SUCCESS;
    805736    PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
    … …  
    17081639                if (VBOX_GUEST_INTERFACE_VERSION_1_03(pThis))
    17091640                {
    1710                     vmmdevSetIRQ_Legacy_EMT(pThis);
     1641                    vmmdevSetIRQ_Legacy(pThis);
    17111642                }
    17121643                else
    … …  
    17211652
    17221653                    pAckRequest = (VMMDevEvents *)pRequestHeader;
    1723                     pAckRequest->events =
    1724                         pThis->u32HostEventFlags & pThis->u32GuestFilterMask;
     1654                    pAckRequest->events = pThis->u32HostEventFlags & pThis->u32GuestFilterMask;
    17251655
    17261656                    pThis->u32HostEventFlags &= ~pThis->u32GuestFilterMask;
    … …  
    25622492
    25632493
     2494
     2495/* -=-=-=-=-=- Backdoor Logging and Time Sync. -=-=-=-=-=- */
     2496
     2497/**
     2498 * @callback_method_impl{FNIOMIOPORTOUT, Backdoor Logging.}
     2499 */
     2500static DECLCALLBACK(int) vmmdevBackdoorLog(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
     2501{
     2502    PVMMDEV pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
     2503
     2504    if (!pThis->fBackdoorLogDisabled && cb == 1 && Port == RTLOG_DEBUG_PORT)
     2505    {
     2506
     2507        /* The raw version. */
     2508        switch (u32)
     2509        {
     2510            case '\r': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <return>\n")); break;
     2511            case '\n': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <newline>\n")); break;
     2512            case '\t': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <tab>\n")); break;
     2513            default:   LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: %c (%02x)\n", u32, u32)); break;
     2514        }
     2515
     2516        /* The readable, buffered version. */
     2517        if (u32 == '\n' || u32 == '\r')
     2518        {
     2519            pThis->szMsg[pThis->iMsg] = '\0';
     2520            if (pThis->iMsg)
     2521                LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("Guest Log: %s\n", pThis->szMsg));
     2522            pThis->iMsg = 0;
     2523        }
     2524        else
     2525        {
     2526            if (pThis->iMsg >= sizeof(pThis->szMsg)-1)
     2527            {
     2528                pThis->szMsg[pThis->iMsg] = '\0';
     2529                LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("Guest Log: %s\n", pThis->szMsg));
     2530                pThis->iMsg = 0;
     2531            }
     2532            pThis->szMsg[pThis->iMsg] = (char )u32;
     2533            pThis->szMsg[++pThis->iMsg] = '\0';
     2534        }
     2535    }
     2536    return VINF_SUCCESS;
     2537}
     2538
     2539#ifdef VMMDEV_WITH_ALT_TIMESYNC
     2540
     2541/**
     2542 * @callback_method_impl{FNIOMIOPORTOUT, Alternative time synchronization.}
     2543 */
     2544static DECLCALLBACK(int) vmmdevAltTimeSyncWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
     2545{
     2546    PVMMDEV pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
     2547    if (cb == 4)
     2548    {
     2549        /* Selects high (0) or low (1) DWORD. The high has to be read first. */
     2550        switch (u32)
     2551        {
     2552            case 0:
     2553                pThis->fTimesyncBackdoorLo = false;
     2554                break;
     2555            case 1:
     2556                pThis->fTimesyncBackdoorLo = true;
     2557                break;
     2558            default:
     2559                Log(("vmmdevAltTimeSyncWrite: Invalid access cb=%#x u32=%#x\n", cb, u32));
     2560                break;
     2561        }
     2562    }
     2563    else
     2564        Log(("vmmdevAltTimeSyncWrite: Invalid access cb=%#x u32=%#x\n", cb, u32));
     2565    return VINF_SUCCESS;
     2566}
     2567
     2568/**
     2569 * @callback_method_impl{FNIOMIOPORTOUT, Alternative time synchronization.}
     2570 */
     2571static DECLCALLBACK(int) vmmdevAltTimeSyncRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
     2572{
     2573    PVMMDEV pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
     2574    int     rc;
     2575    if (cb == 4)
     2576    {
     2577        if (pThis->fTimesyncBackdoorLo)
     2578            *pu32 = (uint32_t)pThis->hostTime;
     2579        else
     2580        {
     2581            /* Reading the high dword gets and saves the current time. */
     2582            RTTIMESPEC Now;
     2583            pThis->hostTime = RTTimeSpecGetMilli(PDMDevHlpTMUtcNow(pDevIns, &Now));
     2584            *pu32 = (uint32_t)(pThis->hostTime >> 32);
     2585        }
     2586        rc = VINF_SUCCESS;
     2587    }
     2588    else
     2589    {
     2590        Log(("vmmdevAltTimeSyncRead: Invalid access cb=%#x\n", cb));
     2591        rc = VERR_IOM_IOPORT_UNUSED;
     2592    }
     2593    return rc;
     2594}
     2595
     2596#endif /* VMMDEV_WITH_ALT_TIMESYNC */
     2597
     2598
    25642599/* -=-=-=-=-=- IBase -=-=-=-=-=- */
    25652600
    … …  
    32213256 * @param   pThis           Pointer to the VMMDev instance data.
    32223257 */
    3223 static void vmmdevInitRam(VMMDevState *pThis)
     3258static void vmmdevInitRam(PVMMDEV pThis)
    32243259{
    32253260    memset(pThis->pVMMDevRAMR3, 0, sizeof(VMMDevMemory));
    … …  
    35333568     * Register the backdoor logging port
    35343569     */
    3535     rc = PDMDevHlpIOPortRegister(pDevIns, RTLOG_DEBUG_PORT, 1, NULL, vmmdevBackdoorLog, NULL, NULL, NULL, "VMMDev backdoor logging");
     3570    rc = PDMDevHlpIOPortRegister(pDevIns, RTLOG_DEBUG_PORT, 1, NULL, vmmdevBackdoorLog,
     3571                                 NULL, NULL, NULL, "VMMDev backdoor logging");
    35363572    AssertRCReturn(rc, rc);
    35373573
    3538 #ifdef TIMESYNC_BACKDOOR
     3574#ifdef VMMDEV_WITH_ALT_TIMESYNC
    35393575    /*
    3540      * Alternative timesync source (temporary!)
     3576     * Alternative timesync source.
     3577     *
     3578     * This was orignally added for creating a simple time sync service in an
     3579     * OpenBSD guest without requiring VBoxGuest and VBoxService to be ported
     3580     * first.  We keep it in case it comes in handy.
    35413581     */
    3542     rc = PDMDevHlpIOPortRegister(pDevIns, 0x505, 1, NULL, vmmdevTimesyncBackdoorWrite, vmmdevTimesyncBackdoorRead, NULL, NULL, "VMMDev timesync backdoor");
     3582    rc = PDMDevHlpIOPortRegister(pDevIns, 0x505, 1, NULL,
     3583                                 vmmdevAltTimeSyncWrite, vmmdevAltTimeSyncRead,
     3584                                 NULL, NULL, "VMMDev timesync backdoor");
    35433585    AssertRCReturn(rc, rc);
    35443586#endif

  • trunk/src/VBox/Devices/VMMDev/VMMDevHGCM.cpp

    r44723 r44725  
    119119};
    120120
    121 static int vmmdevHGCMCmdListLock (VMMDevState *pThis)
     121static int vmmdevHGCMCmdListLock (PVMMDEV pThis)
    122122{
    123123    int rc = RTCritSectEnter (&pThis->critsectHGCMCmdList);
    … …  
    126126}
    127127
    128 static void vmmdevHGCMCmdListUnlock (VMMDevState *pThis)
     128static void vmmdevHGCMCmdListUnlock (PVMMDEV pThis)
    129129{
    130130    int rc = RTCritSectLeave (&pThis->critsectHGCMCmdList);
    … …  
    132132}
    133133
    134 static int vmmdevHGCMAddCommand (VMMDevState *pThis, PVBOXHGCMCMD pCmd, RTGCPHYS GCPhys, uint32_t cbSize, VBOXHGCMCMDTYPE enmCmdType)
     134static int vmmdevHGCMAddCommand (PVMMDEV pThis, PVBOXHGCMCMD pCmd, RTGCPHYS GCPhys, uint32_t cbSize, VBOXHGCMCMDTYPE enmCmdType)
    135135{
    136136    /* PPDMDEVINS pDevIns = pThis->pDevIns; */
    … …  
    181181}
    182182
    183 static int vmmdevHGCMRemoveCommand (VMMDevState *pThis, PVBOXHGCMCMD pCmd)
     183static int vmmdevHGCMRemoveCommand (PVMMDEV pThis, PVBOXHGCMCMD pCmd)
    184184{
    185185    /* PPDMDEVINS pDevIns = pThis->pDevIns; */
    … …  
    238238 *                          for.
    239239 */
    240 DECLINLINE(PVBOXHGCMCMD) vmmdevHGCMFindCommandLocked (VMMDevState *pThis, RTGCPHYS GCPhys)
     240DECLINLINE(PVBOXHGCMCMD) vmmdevHGCMFindCommandLocked (PVMMDEV pThis, RTGCPHYS GCPhys)
    241241{
    242242    for (PVBOXHGCMCMD pCmd = pThis->pHGCMCmdList;
    … …  
    483483}
    484484
    485 int vmmdevHGCMConnect (VMMDevState *pThis, VMMDevHGCMConnect *pHGCMConnect, RTGCPHYS GCPhys)
     485int vmmdevHGCMConnect (PVMMDEV pThis, VMMDevHGCMConnect *pHGCMConnect, RTGCPHYS GCPhys)
    486486{
    487487    int rc = VINF_SUCCESS;
    … …  
    517517}
    518518
    519 static int vmmdevHGCMConnectSaved (VMMDevState *pThis, VMMDevHGCMConnect *pHGCMConnect, RTGCPHYS GCPhys, bool *pfHGCMCalled, VBOXHGCMCMD *pSavedCmd, VBOXHGCMCMD **ppCmd)
     519static int vmmdevHGCMConnectSaved (PVMMDEV pThis, VMMDevHGCMConnect *pHGCMConnect, RTGCPHYS GCPhys, bool *pfHGCMCalled, VBOXHGCMCMD *pSavedCmd, VBOXHGCMCMD **ppCmd)
    520520{
    521521    int rc = VINF_SUCCESS;
    … …  
    556556}
    557557
    558 int vmmdevHGCMDisconnect (VMMDevState *pThis, VMMDevHGCMDisconnect *pHGCMDisconnect, RTGCPHYS GCPhys)
     558int vmmdevHGCMDisconnect (PVMMDEV pThis, VMMDevHGCMDisconnect *pHGCMDisconnect, RTGCPHYS GCPhys)
    559559{
    560560    int rc = VINF_SUCCESS;
    … …  
    582582}
    583583
    584 static int vmmdevHGCMDisconnectSaved (VMMDevState *pThis, VMMDevHGCMDisconnect *pHGCMDisconnect, RTGCPHYS GCPhys, bool *pfHGCMCalled, VBOXHGCMCMD *pSavedCmd, VBOXHGCMCMD **ppCmd)
     584static int vmmdevHGCMDisconnectSaved (PVMMDEV pThis, VMMDevHGCMDisconnect *pHGCMDisconnect, RTGCPHYS GCPhys, bool *pfHGCMCalled, VBOXHGCMCMD *pSavedCmd, VBOXHGCMCMD **ppCmd)
    585585{
    586586    int rc = VINF_SUCCESS;
    … …  
    616616}
    617617
    618 int vmmdevHGCMCall (VMMDevState *pThis, VMMDevHGCMCall *pHGCMCall, uint32_t cbHGCMCall, RTGCPHYS GCPhys, bool f64Bits)
     618int vmmdevHGCMCall (PVMMDEV pThis, VMMDevHGCMCall *pHGCMCall, uint32_t cbHGCMCall, RTGCPHYS GCPhys, bool f64Bits)
    619619{
    620620    int rc = VINF_SUCCESS;
    … …  
    11281128
    11291129
    1130 static int vmmdevHGCMCallSaved (VMMDevState *pThis, VMMDevHGCMCall *pHGCMCall, RTGCPHYS GCPhys, uint32_t cbHGCMCall, bool f64Bits, bool *pfHGCMCalled, VBOXHGCMCMD *pSavedCmd, VBOXHGCMCMD **ppCmd)
     1130static int vmmdevHGCMCallSaved (PVMMDEV pThis, VMMDevHGCMCall *pHGCMCall, RTGCPHYS GCPhys, uint32_t cbHGCMCall, bool f64Bits, bool *pfHGCMCalled, VBOXHGCMCMD *pSavedCmd, VBOXHGCMCMD **ppCmd)
    11311131{
    11321132    int rc = VINF_SUCCESS;
    … …  
    16841684 * @thread EMT
    16851685 */
    1686 int vmmdevHGCMCancel (VMMDevState *pThis, VMMDevHGCMCancel *pHGCMCancel, RTGCPHYS GCPhys)
     1686int vmmdevHGCMCancel (PVMMDEV pThis, VMMDevHGCMCancel *pHGCMCancel, RTGCPHYS GCPhys)
    16871687{
    16881688    NOREF(pHGCMCancel);
    … …  
    17031703 * @thread EMT
    17041704 */
    1705 int vmmdevHGCMCancel2 (VMMDevState *pThis, RTGCPHYS GCPhys)
     1705int vmmdevHGCMCancel2 (PVMMDEV pThis, RTGCPHYS GCPhys)
    17061706{
    17071707    if (    GCPhys == 0
    … …  
    17721772DECLCALLBACK(void) hgcmCompletedWorker (PPDMIHGCMPORT pInterface, int32_t result, PVBOXHGCMCMD pCmd)
    17731773{
    1774     VMMDevState *pThis = PDMIHGCMPORT_2_VMMDEVSTATE(pInterface);
     1774    PVMMDEV pThis = PDMIHGCMPORT_2_VMMDEVSTATE(pInterface);
    17751775#ifdef VBOX_WITH_DTRACE
    17761776    uint32_t idFunction = 0;
    … …  
    22212221DECLCALLBACK(void) hgcmCompleted (PPDMIHGCMPORT pInterface, int32_t result, PVBOXHGCMCMD pCmd)
    22222222{
    2223     VMMDevState *pThis = PDMIHGCMPORT_2_VMMDEVSTATE(pInterface);
     2223    PVMMDEV pThis = PDMIHGCMPORT_2_VMMDEVSTATE(pInterface);
    22242224
    22252225    VBOXDD_HGCMCALL_COMPLETED_REQ(pCmd, result);
    … …  
    22342234
    22352235/* @thread EMT */
    2236 int vmmdevHGCMSaveState(VMMDevState *pThis, PSSMHANDLE pSSM)
     2236int vmmdevHGCMSaveState(PVMMDEV pThis, PSSMHANDLE pSSM)
    22372237{
    22382238    /* Save information about pending requests.
    … …  
    23542354
    23552355/** @thread EMT(0) */
    2356 int vmmdevHGCMLoadState(VMMDevState *pThis, PSSMHANDLE pSSM, uint32_t uVersion)
     2356int vmmdevHGCMLoadState(PVMMDEV pThis, PSSMHANDLE pSSM, uint32_t uVersion)
    23572357{
    23582358    int rc = VINF_SUCCESS;
    … …  
    25222522
    25232523/* @thread EMT */
    2524 int vmmdevHGCMLoadStateDone(VMMDevState *pThis, PSSMHANDLE pSSM)
     2524int vmmdevHGCMLoadStateDone(PVMMDEV pThis, PSSMHANDLE pSSM)
    25252525{
    25262526    LogFlowFunc(("\n"));

  • trunk/src/VBox/Devices/VMMDev/VMMDevState.h

    r44722 r44725  
    2323#include <VBox/vmm/pdmifs.h>
    2424
    25 #define TIMESYNC_BACKDOOR
     25#define VMMDEV_WITH_ALT_TIMESYNC
    2626
    2727typedef struct DISPLAYCHANGEINFO
    … …  
    165165    /** Current host side event flags */
    166166    uint32_t u32HostEventFlags;
    167     /** Mask of events guest is interested in. Note that the HGCM events
    168      *  are enabled automatically by the VMMDev device when guest issues
    169      *  HGCM commands.
    170      */
     167    /** Mask of events guest is interested in.
     168     * @note The HGCM events are enabled automatically by the VMMDev device when
     169     *       guest issues HGCM commands. */
    171170    uint32_t u32GuestFilterMask;
    172171    /** Delayed mask of guest events */
    … …  
    246245    uint32_t uVRDPExperienceLevel;
    247246
    248 #ifdef TIMESYNC_BACKDOOR
     247#ifdef VMMDEV_WITH_ALT_TIMESYNC
    249248    uint64_t hostTime;
    250249    bool fTimesyncBackdoorLo;
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