VirtualBox

Changeset 5965 in vbox for trunk/src/VBox/Frontends/VBoxBFE


Ignore:
Timestamp:
Dec 5, 2007 2:56:09 PM (17 years ago)
Author:
vboxsync
Message:

VBoxBFE: Forward port of the 1.5 branch enhancements (shared folders, savestate, L4 IDL interface)

Location:
trunk/src/VBox/Frontends/VBoxBFE
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VBoxBFE/ConsoleImpl.h

    r4071 r5965  
    103103        enmHKeyState  = HKEYSTATE_NORMAL;
    104104        mfInitialized = false;
     105        mfInputGrab   = false;
    105106    }
    106107    virtual ~Console() {}
    107108
    108109    virtual void     updateTitlebar() = 0;
    109     virtual void     updateTitlebarSave(int iPercent) = 0;
     110    virtual void     updateTitlebarProgress(const char *pszStr, int iPercent) = 0;
    110111
    111112    virtual void     inputGrabStart() = 0;
    112113    virtual void     inputGrabEnd() = 0;
     114    virtual bool     inputGrabbed() { return mfInputGrab; }
    113115    virtual void     resetCursor() {}
    114116
    … …  
    122124    virtual void     eventQuit() = 0;
    123125            bool     initialized() { return mfInitialized; }
     126    virtual void     progressInfo(PVM pVM, unsigned uPercent, void *pvUser) = 0;
     127    virtual void     resetKeys(void) = 0;
    124128
    125129protected:
    126130    HKEYSTATE enmHKeyState;
    127131    bool      mfInitialized;
     132    bool      mfInputGrab;
    128133};
    129134

  • trunk/src/VBox/Frontends/VBoxBFE/DisplayImpl.cpp

    r4512 r5965  
    249249    checkCoordBounds (&x, &y, &w, &h, mpDrv->Connector.cx, mpDrv->Connector.cy);
    250250
     251    if (w == 0 || h == 0)
     252    {
     253        mFramebuffer->Unlock();
     254        return;
     255    }
     256
    251257    // special processing for the internal Framebuffer
    252258    if (mInternalFramebuffer)
    … …  
    489495        /* Continue with normal processing because the status here is ResizeStatus_Void. */
    490496        Assert (pDisplay->mu32ResizeStatus == ResizeStatus_Void);
     497        /* Repaint the display because VM continued to run during the framebuffer resize. */
     498        pDrv->pUpPort->pfnUpdateDisplayAll(pDrv->pUpPort);
     499        /* Ignore the refresh to replay the logic. */
     500        return;
    491501    }
    492502    else if (u32ResizeStatus == ResizeStatus_InProgress)

  • trunk/src/VBox/Frontends/VBoxBFE/DisplayImpl.h

    r4512 r5965  
    5757    void resetFramebuffer();
    5858
     59    void setRunning(void) { mfMachineRunning = true; };
     60
    5961
    6062private:

  • trunk/src/VBox/Frontends/VBoxBFE/Makefile.kmk

    r5586 r5965  
    5252        KeyboardImpl.cpp \
    5353        StatusImpl.cpp \
    54         MachineDebuggerImpl.cpp
     54        MachineDebuggerImpl.cpp \
     55        VMControl.cpp
     56
     57ifdef VBOX_WITH_HGCM
     58VBoxBFE_DEFS += VBOX_HGCM
     59VBoxBFE_SOURCES += \
     60        HGCM.cpp \
     61        HGCMThread.cpp \
     62        HGCMObjects.cpp
     63endif
    5564
    5665VBoxBFE_SOURCES.darwin = \
    … …  
    6069        L4Console.cpp \
    6170        L4Framebuffer.cpp \
     71        L4IDLInterface.cpp \
    6272        EmulCpp.cpp
    6373
    … …  
    94104        /usr/include \
    95105        /usr/local/include
    96 VBoxBFE_INCS.linux = \
    97         $(PATH_BIN)/sdk/include \
    98         $(VBOX_XPCOM_INCS)
    99106
    100107VBoxBFE_LIBS = \
    … …  
    119126        $(L4_LIBDIR)/libl4con-idl.a \
    120127        $(L4_LIBDIR)/libconstream-server.a \
     128        $(L4_LIBDIR)/libvboxctrl-server.a \
    121129        $(L4_LIBDIR)/libl4sys.a
    122130VBoxBFE_LIBS.darwin = \
    123131        $(LIB_SDK_LIBSDL_SDLMAIN)
    124132VBoxBFE_LDFLAGS.darwin = -framework Foundation -framework AppKit
    125 
    126 VBoxBFE_LIBPATH.linux = \
    127         $(LIBPATH_XPCOM) ## why?
    128 
    129133
    130134VBoxBFE_CXXFLAGS.win = \
    … …  
    137141VBoxBFE_CFLAGS.linux += -O ## @todo what's this good for?
    138142
     143VBoxBFE_SDLConsole.cpp_DEPS = $(PATH_VBoxBFE)/Ico64x01.h
     144
    139145
    140146include $(PATH_KBUILD)/footer.kmk
    141147
     148# Convert the pnm-file to a byte array.
     149$(PATH_VBoxBFE)/Ico64x01.h: ico64x01.pnm $(VBOX_BIN2C) | $(call DIRDEP,$(PATH_VBoxBFE))
     150        $(call MSG_TOOL,bin2c,VBoxBFE,$<,$@)
     151        $(QUIET)$(VBOX_BIN2C) Ico64x01 $< $@

  • trunk/src/VBox/Frontends/VBoxBFE/SDLConsole.cpp

    r4861 r5965  
    6464#include "Framebuffer.h"
    6565#include "MachineDebuggerImpl.h"
     66#include "VMControl.h"
    6667
    6768#include "ConsoleImpl.h"
    6869#include "SDLConsole.h"
     70#include "Ico64x01.h"
    6971
    7072/*******************************************************************************
    … …  
    7678    int rc;
    7779
    78     fInputGrab       = false;
     80    mfInputGrab      = false;
    7981    gpDefaultCursor  = NULL;
    8082    gpCustomCursor   = NULL;
    … …  
    8284    gpCustomWMcursor = NULL;
    8385    mfInitialized    = false;
     86    mWMIcon          = NULL;
    8487
    8588    memset(gaModifiersState, 0, sizeof(gaModifiersState));
    … …  
    110113    }
    111114#endif
     115
     116    if (12320 == g_cbIco64x01)
     117    {
     118        mWMIcon = SDL_AllocSurface(SDL_SWSURFACE, 64, 64, 24, 0xff, 0xff00, 0xff0000, 0);
     119        /** @todo make it as simple as possible. No PNM interpreter here... */
     120        if (mWMIcon)
     121        {
     122            memcpy(mWMIcon->pixels, g_abIco64x01+32, g_cbIco64x01-32);
     123            SDL_WM_SetIcon(mWMIcon, NULL);
     124        }
     125    }
    112126
    113127    /*
    … …  
    120134SDLConsole::~SDLConsole()
    121135{
    122     if (fInputGrab)
     136    if (mfInputGrab)
    123137        inputGrabEnd();
     138    if (mWMIcon)
     139    {
     140        SDL_FreeSurface(mWMIcon);
     141        mWMIcon = NULL;
     142    }
    124143}
    125144
    … …  
    129148
    130149    if (SDL_WaitEvent(ev) != 1)
    131       {
    132150        return CONEVENT_QUIT;
    133       }
    134151
    135152    switch (ev->type)
    … …  
    188205                        {
    189206                            /* toggle grabbing state */
    190                             if (!fInputGrab)
    191                             {
     207                            if (!mfInputGrab)
    192208                                inputGrabStart();
    193                             }
    194209                            else
    195                             {
    196210                                inputGrabEnd();
    197                             }
    198211
    199212                            /* SDL doesn't always reset the keystates, correct it */
    … …  
    258271        case SDL_MOUSEMOTION:
    259272        {
    260             if (fInputGrab || gMouse->getAbsoluteCoordinates())
    261             {
     273            if (mfInputGrab || gMouse->getAbsoluteCoordinates())
    262274                mouseSendEvent(0);
    263             }
    264275            break;
    265276        }
    … …  
    272283        {
    273284            SDL_MouseButtonEvent *bev = &ev->button;
    274             if (!fInputGrab && !gMouse->getAbsoluteCoordinates())
     285            if (!mfInputGrab && !gMouse->getAbsoluteCoordinates())
    275286            {
    276287                if (ev->type == SDL_MOUSEBUTTONDOWN && (bev->state & SDL_BUTTON_LMASK))
    … …  
    301312        case SDL_ACTIVEEVENT:
    302313        {
    303             if (fInputGrab && (SDL_GetAppState() & SDL_ACTIVEEVENTMASK) == 0)
     314            if (mfInputGrab && (SDL_GetAppState() & SDL_ACTIVEEVENTMASK) == 0)
    304315            {
    305316                inputGrabEnd();
    … …  
    390401        }
    391402
     403        case SDL_VIDEORESIZE:
     404        {
     405            /* ignore this */
     406            break;
     407        }
     408
    392409        default:
    393410        {
    … …  
    403420 * Push the exit event forcing the main event loop to terminate.
    404421 */
     422void SDLConsole::doEventQuit()
     423{
     424    SDL_Event event;
     425
     426    event.type = SDL_USEREVENT;
     427    event.user.type = SDL_USER_EVENT_TERMINATE;
     428    event.user.code = VBOXSDL_TERM_NORMAL;
     429    SDL_PushEvent(&event);
     430}
     431
    405432void SDLConsole::eventQuit()
    406433{
    407     SDL_Event event;
    408 
    409     event.type = SDL_USEREVENT;
    410     event.user.type  = SDL_USER_EVENT_TERMINATE;
    411     SDL_PushEvent(&event);
     434    doEventQuit();
    412435}
    413436
    … …  
    11161139    // dummy read to avoid moving the mouse
    11171140    SDL_GetRelativeMouseState(NULL, NULL);
    1118     fInputGrab = 1;
     1141    mfInputGrab = true;
    11191142    updateTitlebar();
    11201143}
    … …  
    11311154    DisableGlobalHotKeys(false);
    11321155#endif
    1133     fInputGrab = 0;
     1156    mfInputGrab = false;
    11341157    updateTitlebar();
    11351158}
    … …  
    11491172    bool abs;
    11501173
    1151     abs = (gMouse->getAbsoluteCoordinates() && !fInputGrab) || gMouse->getNeedsHostCursor();
     1174    abs = (gMouse->getAbsoluteCoordinates() && !mfInputGrab) || gMouse->getNeedsHostCursor();
    11521175
    11531176    state = abs ? SDL_GetMouseState(&x, &y) : SDL_GetRelativeMouseState(&x, &y);
    … …  
    12201243}
    12211244
     1245void SDLConsole::progressInfo(PVM pVM, unsigned uPercent, void *pvUser)
     1246{
     1247    if (uPercent != g_uProgressPercent)
     1248    {
     1249        SDL_Event event = {0};
     1250        event.type = SDL_USEREVENT;
     1251        event.user.type  = SDL_USER_EVENT_UPDATE_TITLEBAR;
     1252        SDL_PushEvent(&event);
     1253        g_uProgressPercent = uPercent;
     1254    }
     1255}
     1256
    12221257/**
    12231258 * Build the titlebar string
    … …  
    12251260void SDLConsole::updateTitlebar()
    12261261{
    1227     char title[1024];
    1228 
    1229     strcpy(title, "innotek VirtualBox");
    1230 
    1231     if (machineState == VMSTATE_SUSPENDED)
    1232         strcat(title, " - [Paused]");
    1233 
    1234     if (fInputGrab)
    1235         strcat(title, " - [Input captured]");
     1262    char pszTitle[1024];
     1263
     1264    RTStrPrintf(pszTitle, sizeof(pszTitle),
     1265                "innotek VirtualBox%s%s",
     1266                g_uProgressPercent == ~0U && machineState == VMSTATE_SUSPENDED ? " - [Paused]" : "",
     1267                mfInputGrab                                                    ? " - [Input captured]": "");
     1268
     1269    if (g_uProgressPercent != ~0U)
     1270        RTStrPrintf(pszTitle + strlen(pszTitle), sizeof(pszTitle) - strlen(pszTitle),
     1271                    " - %s: %u%%", g_pszProgressString, g_uProgressPercent);
    12361272
    12371273#if defined(VBOXSDL_ADVANCED_OPTIONS) && defined(DEBUG)
    … …  
    12521288        PRTLOGGER pLogger = RTLogDefaultInstance();
    12531289        bool fEnabled = (pLogger && !(pLogger->fFlags & RTLOGFLAGS_DISABLED));
    1254         RTStrPrintf(title + strlen(title), sizeof(title) - strlen(title),
     1290        RTStrPrintf(pszTitle + strlen(pszTitle), sizeof(pszTitle) - strlen(pszTitle),
    12551291                    " [STEP=%d CS=%d PAT=%d RR0=%d RR3=%d LOG=%d]",
    12561292                    singlestepEnabled == TRUE, csamEnabled == TRUE, patmEnabled == TRUE,
    … …  
    12591295#endif /* DEBUG */
    12601296
    1261     SDL_WM_SetCaption(title, "innotek VirtualBox");
     1297    SDL_WM_SetCaption(pszTitle, "innotek VirtualBox");
    12621298}
    12631299
    … …  
    12661302 * @param   iPercent    Percentage.
    12671303 */
    1268 void SDLConsole::updateTitlebarSave(int iPercent)
     1304void SDLConsole::updateTitlebarProgress(const char *pszStr, int iPercent)
    12691305{
    12701306    char szTitle[256];
    12711307    AssertMsg(iPercent >= 0 && iPercent <= 100, ("%d\n", iPercent));
    1272     RTStrPrintf(szTitle, sizeof(szTitle), "innotek VirtualBox - Saving %d%%...", iPercent);
     1308    RTStrPrintf(szTitle, sizeof(szTitle), "innotek VirtualBox - %s %d%%...", pszStr, iPercent);
    12731309    SDL_WM_SetCaption(szTitle, "innotek VirtualBox");
    12741310}
    … …  
    15261562        case SDLK_f:
    15271563        {
    1528             if (gfAllowFullscreenToggle)
    1529             {
    1530                 gFramebuffer->setFullscreen(!gFramebuffer->getFullscreen());
    1531 
    1532                 /*
    1533                  * We have switched from/to fullscreen, so request a full
    1534                  * screen repaint, just to be sure.
    1535                  */
    1536                 gDisplay->InvalidateAndUpdate();
    1537             }
     1564            VMCtrlToggleFullscreen();
    15381565            break;
    15391566        }
    … …  
    15451572        {
    15461573            if (machineState == VMSTATE_RUNNING)
    1547             {
    1548                 if (fInputGrab)
    1549                     inputGrabEnd();
    1550 
    1551                 PVMREQ pReq;
    1552                 int rcVBox = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT,
    1553                                          (PFNRT)VMR3Suspend, 1, pVM);
    1554                 AssertRC(rcVBox);
    1555                 if (VBOX_SUCCESS(rcVBox))
    1556                 {
    1557                     rcVBox = pReq->iStatus;
    1558                     VMR3ReqFree(pReq);
    1559                 }
    1560             }
     1574                VMCtrlPause();
    15611575            else
    1562             if (machineState == VMSTATE_SUSPENDED)
    1563             {
    1564                 PVMREQ pReq;
    1565                 int rcVBox = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT,
    1566                                          (PFNRT)VMR3Resume, 1, pVM);
    1567                 AssertRC(rcVBox);
    1568                 if (VBOX_SUCCESS(rcVBox))
    1569                 {
    1570                     rcVBox = pReq->iStatus;
    1571                     VMR3ReqFree(pReq);
    1572                 }
    1573             }
     1576                VMCtrlResume();
    15741577            updateTitlebar();
    15751578            break;
    … …  
    15811584        case SDLK_r:
    15821585        {
    1583             PVMREQ pReq;
    1584             int rcVBox = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT,
    1585                                      (PFNRT)VMR3Reset, 1, pVM);
    1586             AssertRC(rcVBox);
    1587             if (VBOX_SUCCESS(rcVBox))
    1588             {
    1589                 rcVBox = pReq->iStatus;
    1590                 VMR3ReqFree(pReq);
    1591             }
     1586            VMCtrlReset();
    15921587            break;
    15931588        }
    … …  
    16071602        case SDLK_h:
    16081603        {
    1609             PPDMIBASE pBase;
    1610             int vrc = PDMR3QueryDeviceLun (pVM, "acpi", 0, 0, &pBase);
    1611             if (VBOX_SUCCESS (vrc))
    1612             {
    1613                 Assert (pBase);
    1614                 PPDMIACPIPORT pPort =
    1615                     (PPDMIACPIPORT) pBase->pfnQueryInterface(pBase, PDMINTERFACE_ACPI_PORT);
    1616                 vrc = pPort ? pPort->pfnPowerButtonPress(pPort) : VERR_INVALID_POINTER;
    1617             }
     1604            VMCtrlACPIButton();
    16181605            break;
    16191606        }
    16201607
    1621 #if 0
    16221608        /*
    16231609         * Save the machine's state and exit
    … …  
    16251611        case SDLK_s:
    16261612        {
    1627             resetKeys();
    1628             RTThreadYield();
    1629             if (fInputGrab)
    1630                 inputGrabEnd();
    1631             RTThreadYield();
    1632             updateTitlebarSave(0);
    1633             gProgress = NULL;
    1634             int rc = gConsole->SaveState(gProgress.asOutParam());
    1635             if (rc != S_OK)
    1636             {
    1637                 RTPrintf("Error saving state! rc = 0x%x\n", rc);
    1638                 return VINF_EM_TERMINATE;
    1639             }
    1640             Assert(gProgress);
    1641 
    1642             /*
    1643              * Wait for the operation to be completed and work
    1644              * the title bar in the mean while.
    1645              */
    1646             LONG    cPercent = 0;
    1647             for (;;)
    1648             {
    1649                 BOOL    fCompleted;
    1650                 rc = gProgress->COMGETTER(Completed)(&fCompleted);
    1651                 if (FAILED(rc) || fCompleted)
    1652                     break;
    1653                 LONG cPercentNow;
    1654                 rc = gProgress->COMGETTER(Percent)(&cPercentNow);
    1655                 if (FAILED(rc))
    1656                     break;
    1657                 if (cPercentNow != cPercent)
    1658                 {
    1659                     UpdateTitlebarSave(cPercent);
    1660                     cPercent = cPercentNow;
    1661                 }
    1662 
    1663                 /* wait */
    1664                 rc = gProgress->WaitForCompletion(100);
    1665                 if (FAILED(rc))
    1666                     break;
    1667                 /// @todo process gui events.
    1668             }
    1669 
    1670             /*
    1671              * What's the result of the operation?
    1672              */
    1673             HRESULT lrc;
    1674             rc = gProgress->COMGETTER(ResultCode)(&lrc);
    1675             if (FAILED(rc))
    1676                 lrc = ~0;
    1677             if (!lrc)
    1678             {
    1679                 UpdateTitlebarSave(100);
    1680                 RTThreadYield();
    1681                 RTPrintf("Saved the state successfully.\n");
    1682             }
    1683             else
    1684                 RTPrintf("Error saving state, lrc=%d (%#x)\n", lrc, lrc);
    1685             return VINF_EM_TERMINATE;
    1686         }
    1687 #endif
     1613            VMCtrlSave(doEventQuit);
     1614            break;
     1615        }
     1616
    16881617        /*
    16891618         * Not a host key combination.

  • trunk/src/VBox/Frontends/VBoxBFE/SDLConsole.h

    r4071 r5965  
    9595
    9696    virtual void     updateTitlebar();
    97     virtual void     updateTitlebarSave(int iPercent);
     97    virtual void     updateTitlebarProgress(const char *pszStr, int iPercent);
    9898
    9999    virtual void     inputGrabStart();
    … …  
    105105                                 uint32_t yHot, uint32_t width,
    106106                                 uint32_t height, void *pShape);
     107    virtual void     progressInfo(PVM pVM, unsigned uPercent, void *pvUser);
    107108
    108109    virtual CONEVENT eventWait();
    109110    virtual void     eventQuit();
    110111    virtual void     resetCursor();
     112    virtual void     resetKeys(void);
    111113
    112114private:
    … …  
    116118    void    processKey(SDL_KeyboardEvent *ev);
    117119    void    setPointerShape (const PointerShapeChangeData *data);
    118 
    119     void    resetKeys(void);
    120 
    121     /** flag whether keyboard/mouse events are grabbed */
    122     bool fInputGrab;
     120    static void doEventQuit(void);
    123121
    124122    /** modifier keypress status (scancode as index) */
    … …  
    129127    /** Custom window manager cursor? */
    130128    WMcursor *gpCustomWMcursor;
     129    /** the application Icon */
     130    SDL_Surface *mWMIcon;
    131131#ifdef VBOXBFE_WITH_X11
    132132    SDL_SysWMinfo gSdlInfo;

  • trunk/src/VBox/Frontends/VBoxBFE/VBoxBFE.cpp

    r5698 r5965  
    3535#include <VBox/types.h>
    3636#include <VBox/err.h>
     37#include <VBox/log.h>
    3738#include <VBox/param.h>
    3839#include <VBox/pdm.h>
    … …  
    4142# include <VBox/vusb.h>
    4243#endif
    43 #include <VBox/log.h>
     44#ifdef VBOX_HGCM
     45# include <VBox/shflsvc.h>
     46#endif
     47#include <iprt/alloca.h>
     48#include <iprt/assert.h>
     49#include <iprt/ctype.h>
     50#include <iprt/file.h>
    4451#include <iprt/path.h>
    45 #include <iprt/string.h>
    4652#include <iprt/runtime.h>
    47 #include <iprt/assert.h>
    4853#include <iprt/semaphore.h>
    4954#include <iprt/stream.h>
     55#include <iprt/string.h>
    5056#include <iprt/thread.h>
    5157#include <iprt/uuid.h>
    52 #include <iprt/file.h>
    53 #include <iprt/alloca.h>
    54 #include <iprt/ctype.h>
    5558
    5659#include "VBoxBFE.h"
    … …  
    6568#include <sys/ioctl.h>
    6669#include <linux/if_tun.h>
    67 #endif
    68 
    69 #ifndef RT_OS_L4
    70 #include <vector>
    7170#endif
    7271
    … …  
    9190#include "L4Console.h"
    9291#include "L4Framebuffer.h"
     92#include "L4IDLInterface.h"
    9393#endif
    9494
    9595#ifdef RT_OS_L4
    96 # ifndef L4API_l4v2onv4
    97 #  include <l4/sys/ktrace.h>
    98 # endif
     96# include <l4/sys/ktrace.h>
    9997# include <l4/vboxserver/file.h>
    10098#endif
    … …  
    122120*******************************************************************************/
    123121
    124 PVM              pVM              = NULL;
    125 Mouse           *gMouse           = NULL;
    126 VMDisplay       *gDisplay         = NULL;
    127 Keyboard        *gKeyboard        = NULL;
    128 VMMDev          *gVMMDev          = NULL;
    129 Framebuffer     *gFramebuffer     = NULL;
    130 MachineDebugger *gMachineDebugger = NULL;
    131 VMStatus        *gStatus          = NULL;
    132 Console         *gConsole         = NULL;
     122PVM                pVM              = NULL;
     123Mouse             *gMouse           = NULL;
     124VMDisplay         *gDisplay         = NULL;
     125Keyboard          *gKeyboard        = NULL;
     126VMMDev            *gVMMDev          = NULL;
     127Framebuffer       *gFramebuffer     = NULL;
     128MachineDebugger   *gMachineDebugger = NULL;
     129VMStatus          *gStatus          = NULL;
     130Console           *gConsole         = NULL;
    133131#ifdef VBOXBFE_WITH_USB
    134 HostUSB         *gHostUSB         = NULL;
     132HostUSB           *gHostUSB         = NULL;
    135133#endif
    136134
    137135VMSTATE machineState = VMSTATE_CREATING;
    138136
    139 PPDMLED     mapFDLeds[2]      = {0};
    140 PPDMLED     mapIDELeds[4]     = {0};
     137static PPDMLED     mapFDLeds[2]   = {0};
    141138
    142139/** flag whether keyboard/mouse events are grabbed */
    143140#ifdef RT_OS_L4
    144141/** see <l4/input/macros.h> for key definitions */
    145 int gHostKey; /* not used */
    146 int gHostKeySym = KEY_RIGHTCTRL;
     142int                gHostKey; /* not used */
     143int                gHostKeySym = KEY_RIGHTCTRL;
    147144#elif defined (DEBUG_dmik)
    148145// my mini kbd doesn't have RCTRL...
    149 int gHostKey    = KMOD_RSHIFT;
    150 int gHostKeySym = SDLK_RSHIFT;
     146int                gHostKey    = KMOD_RSHIFT;
     147int                gHostKeySym = SDLK_RSHIFT;
    151148#else
    152 int gHostKey    = KMOD_RCTRL;
    153 int gHostKeySym = SDLK_RCTRL;
     149int                gHostKey    = KMOD_RCTRL;
     150int                gHostKeySym = SDLK_RCTRL;
    154151#endif
    155152bool gfAllowFullscreenToggle = true;
    156153
    157 static bool g_fIOAPIC = false;
    158 static bool g_fACPI   = true;
    159 static bool g_fAudio  = false;
     154static bool        g_fIOAPIC = false;
     155static bool        g_fACPI   = true;
     156static bool        g_fAudio  = false;
    160157#ifdef VBOXBFE_WITH_USB
    161 static bool g_fUSB    = false;
    162 #endif
    163 static char *g_pszHdaFile   = NULL;
    164 static bool g_fHdaSpf = false;
    165 static char *g_pszHdbFile   = NULL;
    166 static bool g_fHdbSpf = false;
    167 static char *g_pszCdromFile = NULL;
    168 static char *g_pszFdaFile   = NULL;
    169 static const char *pszBootDevice = "IDE";
    170 static uint32_t g_u32MemorySizeMB = 128;
    171 static uint32_t g_u32VRamSize = 4 * _1M;
     158static bool        g_fUSB    = false;
     159#endif
     160static char       *g_pszHdaFile   = NULL;
     161static bool        g_fHdaSpf = false;
     162static char       *g_pszHdbFile   = NULL;
     163static bool        g_fHdbSpf = false;
     164static char       *g_pszCdromFile = NULL;
     165static char       *g_pszFdaFile   = NULL;
     166       const char *g_pszStateFile = NULL;
     167static const char *g_pszBootDevice = "IDE";
     168static uint32_t    g_u32MemorySizeMB = 128;
     169static uint32_t    g_u32VRamSize = 4 * _1M;
    172170#ifdef VBOXSDL_ADVANCED_OPTIONS
    173 static bool g_fRawR0 = true;
    174 static bool g_fRawR3 = true;
    175 static bool g_fPATM  = true;
    176 static bool g_fCSAM  = true;
    177 #endif
    178 static bool g_fPreAllocRam = false;
    179 static int  g_iBootMenu = 2;
    180 static bool g_fReleaseLog = true; /**< Set if we should open the release. */
     171static bool        g_fRawR0 = true;
     172static bool        g_fRawR3 = true;
     173static bool        g_fPATM  = true;
     174static bool        g_fCSAM  = true;
     175#endif
     176static bool        g_fRestoreState = false;
     177static const char *g_pszShareDir[MaxSharedFolders];
     178static const char *g_pszShareName[MaxSharedFolders];
     179static unsigned    g_uNumShares;
     180static bool        g_fPreAllocRam = false;
     181static int         g_iBootMenu = 2;
     182static bool        g_fReleaseLog = true; /**< Set if we should open the release. */
     183       const char *g_pszProgressString;
     184       unsigned    g_uProgressPercent = ~0U;
    181185
    182186
    … …  
    216220
    217221/**
     222 */
     223bool fActivateHGCM()
     224{
     225    return !!(g_uNumShares > 0);
     226}
     227
     228/**
    218229 * Converts the passed in network option
    219230 *
    … …  
    241252}
    242253
    243 
    244254/**
    245255 *  Generates a new unique MAC address based on our vendor ID and
    … …  
    269279    return VINF_SUCCESS;
    270280}
    271 
    272281
    273282/**
    … …  
    306315}
    307316
     317/**
     318 * Start progress display.
     319 */
     320void startProgressInfo(const char *pszStr)
     321{
     322    g_pszProgressString = pszStr;
     323    g_uProgressPercent = 0;
     324}
     325
     326/**
     327 * Update progress display.
     328 */
     329void callProgressInfo(PVM pVM, unsigned uPercent, void *pvUser)
     330{
     331    if (gConsole)
     332        gConsole->progressInfo(pVM, uPercent, pvUser);
     333}
     334
     335/**
     336 * End progress display.
     337 */
     338void endProgressInfo(void)
     339{
     340    g_uProgressPercent = ~0U;
     341}
     342
    308343
    309344/**
    … …  
    323358             "  -prealloc          Force RAM pre-allocation\n"
    324359             "  -fullscreen        Start VM in fullscreen mode\n"
     360             "  -statefile <file>  Define the file name for VM save/restore\n"
     361             "  -restore           Restore the VM if the statefile exists, normal start otherwise\n"
    325362             "  -nofstoggle        Forbid switching to/from fullscreen mode\n"
     363             "  -share <dir><name> Share directory <dir> as name <name>\n"
    326364             "  -nohostkey         Disable hostkey\n"
    327365             "  -[no]acpi          Enable or disable ACPI (default: enabled)\n"
    … …  
    438476                case 'a':
    439477                {
    440                     pszBootDevice = "FLOPPY";
     478                    g_pszBootDevice = "FLOPPY";
    441479                    break;
    442480                }
    … …  
    444482                case 'c':
    445483                {
    446                     pszBootDevice = "IDE";
     484                    g_pszBootDevice = "IDE";
    447485                    break;
    448486                }
    … …  
    450488                case 'd':
    451489                {
    452                     pszBootDevice = "DVD";
     490                    g_pszBootDevice = "DVD";
    453491                    break;
    454492                }
    … …  
    486524                return SyntaxError("bad video ram size: %s (error %Vrc)\n",
    487525                                   argv[curArg], rc);
     526        }
     527        else if (strcmp(pszArg, "-statefile") == 0)
     528        {
     529            if (++curArg >= argc)
     530                return SyntaxError("missing argument for restore!\n");
     531            g_pszStateFile = argv[curArg];
     532        }
     533        else if (strcmp(pszArg, "-restore") == 0)
     534            g_fRestoreState = true;
     535        else if (strcmp(pszArg, "-share") == 0)
     536        {
     537            if (g_uNumShares >= MaxSharedFolders)
     538                return SyntaxError("too many shared folders specified!\n");
     539            if (++curArg >= argc)
     540                return SyntaxError("missing 1s argument for share!\n");
     541            g_pszShareDir[g_uNumShares] = argv[curArg];
     542            if (++curArg >= argc)
     543                return SyntaxError("missing 2nd argument for share!\n");
     544            g_pszShareName[g_uNumShares] = argv[curArg];
     545            g_uNumShares++;
    488546        }
    489547        else if (strcmp(pszArg, "-fullscreen") == 0)
    … …  
    778836    }
    779837
     838#ifdef RT_OS_L4
     839    /* Start the external IDL interface */
     840    L4CtrlInit();
     841#endif
     842
    780843    /* loop until the powerup processing is done */
    781844    do
    … …  
    796859                break;
    797860
     861            case CONEVENT_USR_TITLEBARUPDATE:
     862                gConsole->updateTitlebar();
     863                break;
     864
    798865            case CONEVENT_USR_QUIT:
    799866                RTPrintf("Error: failed to power up VM! No error text available.\n");
    … …  
    826893                       * (gDisplay->getBitsPerPixel() / 8))
    827894        gDisplay->SetVideoModeHint(gFramebuffer->getHostXres(), gFramebuffer->getHostYres(), 0, 0);
     895
    828896    /* Limit the VRAM of the guest to the amount of memory we got actually
    829897     * mapped from the L4 console. */
    830898    u32MaxVRAM = (gFramebuffer->getHostYres() + 18) /* don't omit the status bar */
    831899               * gFramebuffer->getHostXres()
    832                * (gDisplay->getBitsPerPixel() / 8);
     900               * (gFramebuffer->getHostBitsPerPixel() / 8);
    833901    if (g_u32VRamSize > u32MaxVRAM)
    834902    {
    … …  
    10961164    }
    10971165
     1166#ifdef VBOX_HGCM
     1167    /*
     1168     * Add shared folders to the VM
     1169     */
     1170    if (fActivateHGCM() && gVMMDev->isShFlActive())
     1171    {
     1172        for (unsigned i=0; i<g_uNumShares; i++)
     1173        {
     1174            VBOXHGCMSVCPARM  parms[2];
     1175            SHFLSTRING      *pFolderName, *pMapName;
     1176            int              cbString;
     1177            PRTUCS2          aHostPath, aMapName;
     1178            int              rc;
     1179
     1180            rc = RTStrUtf8ToUcs2(&aHostPath, g_pszShareDir[i]);
     1181            AssertRC(rc);
     1182            rc = RTStrUtf8ToUcs2(&aMapName, g_pszShareName[i]);
     1183            AssertRC(rc);
     1184
     1185            cbString = (RTStrUcs2Len (aHostPath) + 1) * sizeof (RTUCS2);
     1186            pFolderName = (SHFLSTRING *) RTMemAllocZ (sizeof (SHFLSTRING) + cbString);
     1187            Assert (pFolderName);
     1188            memcpy (pFolderName->String.ucs2, aHostPath, cbString);
     1189
     1190            pFolderName->u16Size   = cbString;
     1191            pFolderName->u16Length = cbString - sizeof(RTUCS2);
     1192
     1193            parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
     1194            parms[0].u.pointer.addr = pFolderName;
     1195            parms[0].u.pointer.size = sizeof (SHFLSTRING) + cbString;
     1196
     1197            cbString = (RTStrUcs2Len (aMapName) + 1) * sizeof (RTUCS2);
     1198            pMapName = (SHFLSTRING *) RTMemAllocZ (sizeof(SHFLSTRING) + cbString);
     1199            Assert (pMapName);
     1200            memcpy (pMapName->String.ucs2, aMapName, cbString);
     1201
     1202            pMapName->u16Size   = cbString;
     1203            pMapName->u16Length = cbString - sizeof (RTUCS2);
     1204
     1205            parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
     1206            parms[1].u.pointer.addr = pMapName;
     1207            parms[1].u.pointer.size = sizeof (SHFLSTRING) + cbString;
     1208
     1209            rc = gVMMDev->hgcmHostCall ("VBoxSharedFolders",
     1210                                        SHFL_FN_ADD_MAPPING, 2, &parms[0]);
     1211            AssertRC(rc);
     1212            LogRel(("Added share %s: (%s)\n", g_pszShareName[i], g_pszShareDir[i]));
     1213            RTMemFree (pFolderName);
     1214            RTMemFree (pMapName);
     1215            RTStrUcs2Free (aHostPath);
     1216            RTStrUcs2Free (aMapName);
     1217        }
     1218    }
     1219#endif
     1220
    10981221#ifdef VBOXBFE_WITH_USB
    10991222    /*
    … …  
    11201243    {
    11211244        PVMREQ pReq;
    1122         rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)VMR3PowerOn, 1, pVM);
    1123         if (VBOX_SUCCESS(rc))
    1124         {
    1125             rc = pReq->iStatus;
    1126             AssertRC(rc);
    1127             VMR3ReqFree(pReq);
     1245
     1246        if (   g_fRestoreState
     1247            && g_pszStateFile
     1248            && *g_pszStateFile
     1249            && RTPathExists(g_pszStateFile))
     1250        {
     1251            startProgressInfo("Restoring");
     1252            rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT,
     1253                             (PFNRT)VMR3Load, 4, pVM, g_pszStateFile, &callProgressInfo, NULL);
     1254            endProgressInfo();
     1255            if (VBOX_SUCCESS(rc))
     1256            {
     1257                VMR3ReqFree(pReq);
     1258                rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT,
     1259                                 (PFNRT)VMR3Resume, 1, pVM);
     1260                if (VBOX_SUCCESS(rc))
     1261                {
     1262                    rc = pReq->iStatus;
     1263                    VMR3ReqFree(pReq);
     1264                }
     1265                gDisplay->setRunning();
     1266            }
     1267            else
     1268                AssertMsgFailed(("VMR3Load failed, rc=%Vrc\n", rc));
    11281269        }
    11291270        else
    1130             AssertMsgFailed(("VMR3PowerOn failed, rc=%Vrc\n", rc));
     1271        {
     1272            rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)VMR3PowerOn, 1, pVM);
     1273            if (VBOX_SUCCESS(rc))
     1274            {
     1275                rc = pReq->iStatus;
     1276                AssertRC(rc);
     1277                VMR3ReqFree(pReq);
     1278            }
     1279            else
     1280                AssertMsgFailed(("VMR3PowerOn failed, rc=%Vrc\n", rc));
     1281        }
    11311282    }
    11321283
    … …  
    12611412    rc = CFGMR3InsertNode(pInst,    "Config",         &pCfg);                       UPDATE_RC();
    12621413    rc = CFGMR3InsertInteger(pCfg,  "RamSize",        g_u32MemorySizeMB * _1M);     UPDATE_RC();
    1263     rc = CFGMR3InsertString(pCfg,   "BootDevice0",    pszBootDevice);               UPDATE_RC();
     1414    rc = CFGMR3InsertString(pCfg,   "BootDevice0",    g_pszBootDevice);             UPDATE_RC();
    12641415    rc = CFGMR3InsertString(pCfg,   "BootDevice1",    "NONE");                      UPDATE_RC();
    12651416    rc = CFGMR3InsertString(pCfg,   "BootDevice2",    "NONE");                      UPDATE_RC();

  • trunk/src/VBox/Frontends/VBoxBFE/VBoxBFE.h

    r4071 r5965  
    2525#define VBOXSDL_ADVANCED_OPTIONS
    2626
    27 /** @todo fix this */
    28 #define NetworkAdapterCount    4
     27enum
     28{
     29 NetworkAdapterCount = 4,
     30 MaxSharedFolders = 16,
     31};
    2932
    3033
    … …  
    3841/** @} */
    3942
    40 extern VMSTATE machineState;
    41 extern PVM pVM;
    42 extern int gHostKey;
    43 extern int gHostKeySym;
    44 extern bool gfAllowFullscreenToggle;
     43extern VMSTATE     machineState;
     44extern PVM         pVM;
     45extern int         gHostKey;
     46extern int         gHostKeySym;
     47extern bool        gfAllowFullscreenToggle;
     48extern const char *g_pszStateFile;
     49extern const char *g_pszProgressString;
     50extern unsigned    g_uProgressPercent;
     51
     52void   startProgressInfo(const char *pszStr);
     53void   callProgressInfo(PVM pVM, unsigned uPercent, void *pvUser);
     54void   endProgressInfo();
     55bool   fActivateHGCM();
    4556
    4657#endif // __H_VBOXBFE

  • trunk/src/VBox/Frontends/VBoxBFE/VMMDevInterface.cpp

    r4071 r5965  
    3838#include "DisplayImpl.h"
    3939#include "ConsoleImpl.h"
     40#ifdef VBOX_HGCM
     41#include "HGCM.h"
     42#endif
    4043
    4144#ifdef RT_OS_L4
    … …  
    5558    /** Our VMM device connector interface. */
    5659    PDMIVMMDEVCONNECTOR         Connector;
     60
     61#ifdef VBOX_HGCM
     62    /** Pointer to the HGCM port interface of the driver/device above us. */
     63    PPDMIHGCMPORT               pHGCMPort;
     64    /** Our HGCM connector interface. */
     65    PDMIHGCMCONNECTOR           HGCMConnector;
     66#endif
    5767} DRVMAINVMMDEV, *PDRVMAINVMMDEV;
    5868
    5969/** Converts PDMIVMMDEVCONNECTOR pointer to a DRVMAINVMMDEV pointer. */
    6070#define PDMIVMMDEVCONNECTOR_2_MAINVMMDEV(pInterface) ( (PDRVMAINVMMDEV) ((uintptr_t)pInterface - RT_OFFSETOF(DRVMAINVMMDEV, Connector)) )
     71
     72#ifdef VBOX_HGCM
     73/** Converts PDMIHGCMCONNECTOR pointer to a DRVMAINVMMDEV pointer. */
     74#define PDMIHGCMCONNECTOR_2_MAINVMMDEV(pInterface) ( (PDRVMAINVMMDEV) ((uintptr_t)pInterface - RT_OFFSETOF(DRVMAINVMMDEV, HGCMConnector)) )
     75#endif
     76
     77VMMDev::VMMDev() : mpDrv(NULL)
     78{
     79#ifdef VBOX_HGCM
     80    int rc = VINF_SUCCESS;
     81    if (fActivateHGCM())
     82        rc = HGCMHostInit();
     83    AssertRC(rc);
     84#endif
     85}
     86
     87VMMDev::~VMMDev()
     88{
     89#ifdef VBOX_HGCM
     90    if (fActivateHGCM())
     91        HGCMHostShutdown ();
     92#endif /* VBOX_HGCM */
     93}
    6194
    6295
    … …  
    216249}
    217250
     251#ifdef VBOX_HGCM
     252
     253/* HGCM connector interface */
     254
     255static DECLCALLBACK(int) iface_hgcmConnect (PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, PHGCMSERVICELOCATION pServiceLocation, uint32_t *pu32ClientID)
     256{
     257    LogSunlover(("Enter\n"));
     258
     259    PDRVMAINVMMDEV pDrv = PDMIHGCMCONNECTOR_2_MAINVMMDEV(pInterface);
     260   
     261    if (    !pServiceLocation
     262        || (   pServiceLocation->type != VMMDevHGCMLoc_LocalHost
     263            && pServiceLocation->type != VMMDevHGCMLoc_LocalHost_Existing))
     264    {
     265        return VERR_INVALID_PARAMETER;
     266    }
     267
     268    return HGCMGuestConnect (pDrv->pHGCMPort, pCmd, pServiceLocation->u.host.achName, pu32ClientID);
     269}
     270
     271static DECLCALLBACK(int) iface_hgcmDisconnect (PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID)
     272{
     273    LogSunlover(("Enter\n"));
     274
     275    PDRVMAINVMMDEV pDrv = PDMIHGCMCONNECTOR_2_MAINVMMDEV(pInterface);
     276
     277    return HGCMGuestDisconnect (pDrv->pHGCMPort, pCmd, u32ClientID);
     278}
     279
     280static DECLCALLBACK(int) iface_hgcmCall (PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID, uint32_t u32Function,
     281                                         uint32_t cParms, PVBOXHGCMSVCPARM paParms)
     282{
     283    LogSunlover(("Enter\n"));
     284
     285    PDRVMAINVMMDEV pDrv = PDMIHGCMCONNECTOR_2_MAINVMMDEV(pInterface);
     286
     287    return HGCMGuestCall (pDrv->pHGCMPort, pCmd, u32ClientID, u32Function, cParms, paParms);
     288}
     289
     290/**
     291 * Execute state save operation.
     292 *
     293 * @returns VBox status code.
     294 * @param   pDrvIns         Driver instance of the driver which registered the data unit.
     295 * @param   pSSM            SSM operation handle.
     296 */
     297static DECLCALLBACK(int) iface_hgcmSave(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM)
     298{
     299    LogSunlover(("Enter\n"));
     300    return HGCMHostSaveState (pSSM);
     301}
     302
     303
     304/**
     305 * Execute state load operation.
     306 *
     307 * @returns VBox status code.
     308 * @param   pDrvIns         Driver instance of the driver which registered the data unit.
     309 * @param   pSSM            SSM operation handle.
     310 * @param   u32Version      Data layout version.
     311 */
     312static DECLCALLBACK(int) iface_hgcmLoad(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t u32Version)
     313{
     314    LogFlowFunc(("Enter\n"));
     315
     316    if (u32Version != HGCM_SSM_VERSION)
     317        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
     318
     319    return HGCMHostLoadState (pSSM);
     320}
     321
     322int VMMDev::hgcmLoadService (const char *pszServiceName, const char *pszServiceLibrary)
     323{
     324    return HGCMHostLoad (pszServiceName, pszServiceLibrary);
     325}
     326
     327int VMMDev::hgcmHostCall (const char *pszServiceName, uint32_t u32Function,
     328                          uint32_t cParms, PVBOXHGCMSVCPARM paParms)
     329{
     330    return HGCMHostCall (pszServiceName, u32Function, cParms, paParms);
     331}
     332#endif /* HGCM */
     333
    218334/**
    219335 * Queries an interface to the driver.
    … …  
    234350        case PDMINTERFACE_VMMDEV_CONNECTOR:
    235351            return &pDrv->Connector;
     352#ifdef VBOX_HGCM
     353        case PDMINTERFACE_HGCM_CONNECTOR:
     354            if (fActivateHGCM())
     355                return &pDrv->HGCMConnector;
     356            else
     357                return NULL;
     358#endif
    236359        default:
    237360            return NULL;
    … …  
    297420    pData->Connector.pfnQueryVisibleRegion      = iface_QueryVisibleRegion;
    298421
     422#ifdef VBOX_HGCM
     423    if (fActivateHGCM())
     424    {
     425        pData->HGCMConnector.pfnConnect         = iface_hgcmConnect;
     426        pData->HGCMConnector.pfnDisconnect      = iface_hgcmDisconnect;
     427        pData->HGCMConnector.pfnCall            = iface_hgcmCall;
     428    }
     429#endif
     430
    299431    /*
    300432     * Get the IVMMDevPort interface of the above driver/device.
    … …  
    306438        return VERR_PDM_MISSING_INTERFACE_ABOVE;
    307439    }
     440
     441#ifdef VBOX_HGCM
     442    if (fActivateHGCM())
     443    {
     444        pData->pHGCMPort = (PPDMIHGCMPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_HGCM_PORT);
     445        if (!pData->pHGCMPort)
     446        {
     447            AssertMsgFailed(("Configuration error: No HGCM port interface above!\n"));
     448            return VERR_PDM_MISSING_INTERFACE_ABOVE;
     449        }
     450    }
     451#endif
    308452
    309453    /*
    … …  
    320464    pData->pVMMDev = (VMMDev*)pv;        /** @todo Check this cast! */
    321465    pData->pVMMDev->mpDrv = pData;
     466
     467#ifdef VBOX_HGCM
     468    if (fActivateHGCM())
     469    {
     470        rc = pData->pVMMDev->hgcmLoadService ("VBoxSharedFolders", "VBoxSharedFolders");
     471        pData->pVMMDev->fSharedFolderActive = VBOX_SUCCESS(rc);
     472        if (VBOX_SUCCESS(rc))
     473            LogRel(("Shared Folders service loaded.\n"));
     474        else
     475            LogRel(("Failed to load Shared Folders service %Vrc\n", rc));
     476
     477        pDrvIns->pDrvHlp->pfnSSMRegister(pDrvIns, "HGCM", 0, HGCM_SSM_VERSION, 4096/* bad guess */, NULL, iface_hgcmSave, NULL, NULL, iface_hgcmLoad, NULL);
     478    }
     479#endif /* VBOX_HGCM */
     480   
    322481    return VINF_SUCCESS;
    323482}

  • trunk/src/VBox/Frontends/VBoxBFE/VMMDevInterface.h

    r4071 r5965  
    2525{
    2626public:
    27     VMMDev() : mpDrv(NULL) {};
     27    VMMDev();
     28    ~VMMDev();
    2829    static const PDMDRVREG  DrvReg;
    2930
    3031    /** Pointer to the associated VMMDev driver. */
    3132    struct DRVMAINVMMDEV *mpDrv;
     33
     34    bool fSharedFolderActive;
     35    bool isShFlActive()
     36    {
     37        return fSharedFolderActive;
     38    }
    3239
    3340    PPDMIVMMDEVPORT getVMMDevPort();
    … …  
    3643    int  SetMouseCapabilities(uint32_t mouseCaps);
    3744    int  SetAbsoluteMouse(uint32_t mouseXAbs, uint32_t mouseYAbs);
     45
     46    int hgcmLoadService (const char *pszServiceName, const char *pszServiceLibrary);
     47    int hgcmHostCall (const char *pszServiceName, uint32_t u32Function, uint32_t cParms, PVBOXHGCMSVCPARM paParms);
    3848
    3949private:
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