VirtualBox

Ignore:
Timestamp:
Aug 18, 2017 3:31:04 PM (7 years ago)
Author:
vboxsync
Message:

vboxhgcm.c: Use VbglR3HGCM* APIs.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c

    r68458 r68472  
    3939#include <iprt/thread.h>
    4040
    41 #if 1 /** @todo Try use the Vbgl interface instead of talking directly to the driver? */
    42 # include <VBox/VBoxGuest.h>
    43 #else
    44 # include <VBox/VBoxGuestLib.h>
    45 #endif
     41#include <VBox/VBoxGuestLib.h>
    4642#include <VBox/HostServices/VBoxCrOpenGLSvc.h>
    4743
    … …  
    180176    CRNetCloseFuncList   *close_list;
    181177#ifdef RT_OS_WINDOWS
    182     HANDLE               hGuestDrv;
    183178    LPDIRECTDRAW         pDirectDraw;
    184 #else
    185     int                  iGuestDrv;
    186179#endif
    187180#ifdef IN_GUEST
    … …  
    588581 * @param   cbData      Data size
    589582 */
    590 /** @todo use vbglR3DoIOCtl here instead */
    591 static int crVBoxHGCMCall(CRConnection *conn, void *pvData, unsigned cbData)
     583static int crVBoxHGCMCall(CRConnection *conn, VBoxGuestHGCMCallInfo *pData, unsigned cbData)
    592584{
    593585#ifdef IN_GUEST
    … …  
    595587    RT_NOREF(conn);
    596588# else
     589    int rc;
    597590    PCRVBOXHGSMI_CLIENT pClient = g_crvboxhgcm.bHgsmiOn ? _crVBoxHGSMIClientGet(conn) : NULL;
    598591    if (pClient)
    599     {
    600         return VBoxCrHgsmiCtlConCall(pClient->pHgsmi, (struct VBoxGuestHGCMCallInfo *)pvData, cbData);
    601     }
     592        rc = VBoxCrHgsmiCtlConCall(pClient->pHgsmi, pData, cbData);
    602593    else
    603594# endif
    604     {
    605 # ifdef RT_OS_WINDOWS
    606     DWORD cbReturned, lerr;
    607 
    608     if (DeviceIoControl (g_crvboxhgcm.hGuestDrv,
    609                          VBOXGUEST_IOCTL_HGCM_CALL(cbData),
    610                          pvData, cbData,
    611                          pvData, cbData,
    612                          &cbReturned,
    613                          NULL))
    614     {
    615         return VINF_SUCCESS;
    616     }
    617     lerr=GetLastError();
    618     crDebug("vboxCall failed with %x\n", lerr);
    619     /*On windows if we exceed max buffer len, we only get ERROR_GEN_FAILURE, and parms.hdr.result isn't changed.
    620      *Before every call here we set it to VERR_WRONG_ORDER, so checking it here as well.
    621      */
    622     if (ERROR_GEN_FAILURE==lerr && VERR_WRONG_ORDER==((VBoxGuestHGCMCallInfo*)pvData)->result)
    623     {
    624         return VERR_OUT_OF_RANGE;
    625     }
    626     else
    627     {
    628         return VERR_NOT_SUPPORTED;
    629     }
    630 # else
    631     int rc;
    632 #  if defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)
    633     VBGLBIGREQ Hdr;
    634     Hdr.u32Magic = VBGLBIGREQ_MAGIC;
    635     Hdr.cbData = cbData;
    636     Hdr.pvDataR3 = pvData;
    637 #   if HC_ARCH_BITS == 32
    638     Hdr.u32Padding = 0;
    639 #   endif
    640     rc = ioctl(g_crvboxhgcm.iGuestDrv, VBOXGUEST_IOCTL_HGCM_CALL(cbData), &Hdr);
    641 #  else
    642     rc = ioctl(g_crvboxhgcm.iGuestDrv, VBOXGUEST_IOCTL_HGCM_CALL(cbData), pvData);
    643 #  endif
    644 #  ifdef RT_OS_LINUX
    645     if (rc == 0)
    646 #  else
    647     if (rc >= 0)
    648 #  endif
    649     {
    650         return VINF_SUCCESS;
    651     }
    652 #  ifdef RT_OS_LINUX
    653     if (rc >= 0) /* positive values are negated VBox error status codes. */
    654     {
    655         crWarning("vboxCall failed with VBox status code %d\n", -rc);
    656         if (rc==VINF_INTERRUPTED)
    657         {
    658             RTMSINTERVAL sl;
    659             int i;
    660 
    661             for (i=0, sl=50; i<6; i++, sl=sl*2)
     595    {       
     596        rc = VbglR3HGCMCall(pData, cbData);
     597        if (RT_SUCCESS(rc))
     598        { /* likely */ }
     599        else
     600        {
     601            crWarning("vboxCall failed with VBox status code %Rrc\n", rc);
     602# if 1//ndef RT_OS_WINDOWS
     603            if (rc == VERR_INTERRUPTED)
    662604            {
    663                 RTThreadSleep(sl);
    664                 rc = ioctl(g_crvboxhgcm.iGuestDrv, VBOXGUEST_IOCTL_HGCM_CALL(cbData), pvData);
    665                 if (rc==0)
     605                /* Not sure why we're doing the sleep stuff here.  The original coder didn't
     606                   bother to mention why he thought it necessary.  :-( */
     607                RTMSINTERVAL msSleep;
     608                int i;
     609                for (i = 0, msSleep = 50; i < 6; i++, msSleep = msSleep * 2)
    666610                {
    667                     crWarning("vboxCall retry(%i) succeeded", i+1);
    668                     return VINF_SUCCESS;
    669                 }
    670                 else if (rc==VINF_INTERRUPTED)
    671                 {
    672                     continue;
    673                 }
    674                 else
    675                 {
    676                     crWarning("vboxCall retry(%i) failed with VBox status code %d", i+1, -rc);
    677                     break;
     611                    RTThreadSleep(msSleep);
     612                    rc = VbglR3HGCMCall(pData, cbData);
     613                    if (rc != VERR_INTERRUPTED)
     614                    {
     615                        if (RT_SUCCESS(rc))
     616                            crWarning("vboxCall retry(%i) succeeded", i + 1);
     617                        else
     618                            crWarning("vboxCall retry(%i) failed with VBox status code %Rrc", i + 1, rc);
     619                        break;
     620                    }
    678621                }
    679622            }
    680         }
    681         return -rc;
    682     }
    683     else
    684623#  endif
    685         crWarning("vboxCall failed with %x\n", errno);
    686     return VERR_NOT_SUPPORTED;
    687 # endif /*#ifdef RT_OS_WINDOWS*/
    688     }
     624        }
     625    }
     626    return rc;
    689627
    690628#else  /* IN_GUEST */
    691     RT_NOREF(conn, pvData, cbData);
     629    RT_NOREF(conn, pData, cbData);
    692630    crError("crVBoxHGCMCall called on host side!");
    693631    CRASSERT(FALSE);
    … …  
    766704        parms.pBuffer.u.Pointer.u.linearAddr = (uintptr_t) buf;
    767705
    768         rc = crVBoxHGCMCall(conn, &parms, sizeof(parms));
     706        rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
    769707        callRes = parms.hdr.result;
    770708    }
    … …  
    780718        parms.pBuffer.u.Pointer.u.linearAddr = (uintptr_t) buf;
    781719
    782         rc = crVBoxHGCMCall(conn, &parms, sizeof(parms));
     720        rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
    783721        callRes = parms.hdr.result;
    784722    }
    … …  
    819757    parms.cbBuffer.u.value32 = 0;
    820758
    821     rc = crVBoxHGCMCall(conn, &parms, sizeof(parms));
     759    rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
    822760
    823761    if (RT_FAILURE(rc) || RT_FAILURE(parms.hdr.result))
    … …  
    863801    parms.cbWriteback.u.value32 = 0;
    864802
    865     rc = crVBoxHGCMCall(conn, &parms, sizeof(parms));
     803    rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
    866804
    867805#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS)
    … …  
    896834            crDebug("SHCRGL_GUEST_FN_WRITE_BUFFER, offset=%u, size=%u", wbParms.ui32Offset.u.value32, wbParms.pBuffer.u.Pointer.size);
    897835
    898             rc = crVBoxHGCMCall(conn, &wbParms, sizeof(wbParms));
     836            rc = crVBoxHGCMCall(conn, &wbParms.hdr, sizeof(wbParms));
    899837            if (RT_FAILURE(rc) || RT_FAILURE(wbParms.hdr.result))
    900838            {
    … …  
    918856            crMemcpy(&wrbParms.cbWriteback, &parms.cbWriteback, sizeof(HGCMFunctionParameter));
    919857
    920             rc = crVBoxHGCMCall(conn, &wrbParms, sizeof(wrbParms));
     858            rc = crVBoxHGCMCall(conn, &wrbParms.hdr, sizeof(wrbParms));
    921859
    922860            /*bit of hack to reuse code below*/
    … …  
    1051989    parms.cbBuffer.u.value32 = 0;
    1052990
    1053     rc = crVBoxHGCMCall(conn, &parms, sizeof(parms));
     991    rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
    1054992
    1055993    if (RT_FAILURE(rc) || RT_FAILURE(parms.hdr.result))
    … …  
    12521190    parms.vMinor.u.value32 = CR_PROTOCOL_VERSION_MINOR;
    12531191
    1254     rc = crVBoxHGCMCall(conn, &parms, sizeof(parms));
     1192    rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
    12551193
    12561194    if (RT_SUCCESS(rc))
    … …  
    12841222    caps.Caps.u.value32  = 0;
    12851223
    1286     rc = crVBoxHGCMCall(conn, &caps, sizeof(caps));
     1224    rc = crVBoxHGCMCall(conn, &caps.hdr, sizeof(caps));
    12871225
    12881226    if (RT_SUCCESS(rc))
    … …  
    13161254    parms.u64PID.u.value64 = pid;
    13171255
    1318     rc = crVBoxHGCMCall(conn, &parms, sizeof(parms));
     1256    rc = crVBoxHGCMCall(conn, &parms.hdr, sizeof(parms));
    13191257
    13201258    if (RT_FAILURE(rc) || RT_FAILURE(parms.hdr.result))
    … …  
    13321270 * Servers go through crVBoxHGCMAccept;
    13331271 */
    1334 /*@todo use vbglR3Something here */
    13351272static int crVBoxHGCMDoConnect( CRConnection *conn )
    13361273{
    13371274#ifdef IN_GUEST
    1338     VBoxGuestHGCMConnectInfo info;
    1339 
    1340 #ifdef RT_OS_WINDOWS
    1341     DWORD cbReturned;
    1342 
     1275            int rc;
    13431276    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    1344 
    1345     if (g_crvboxhgcm.hGuestDrv == INVALID_HANDLE_VALUE)
    1346     {
    1347         /* open VBox guest driver */
    1348         g_crvboxhgcm.hGuestDrv = CreateFile(VBOXGUEST_DEVICE_NAME,
    1349                                         GENERIC_READ | GENERIC_WRITE,
    1350                                         FILE_SHARE_READ | FILE_SHARE_WRITE,
    1351                                         NULL,
    1352                                         OPEN_EXISTING,
    1353                                         FILE_ATTRIBUTE_NORMAL,
    1354                                         NULL);
    1355 
    1356         /* @todo check if we could rollback to softwareopengl */
    1357         if (g_crvboxhgcm.hGuestDrv == INVALID_HANDLE_VALUE)
    1358         {
    1359             crWarning("could not open VBox Guest Additions driver! rc = %d\n", GetLastError());
    1360             VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    1361             return FALSE;
    1362         }
    1363     }
    1364 #else
    1365     VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    1366     if (g_crvboxhgcm.iGuestDrv == INVALID_HANDLE_VALUE)
    1367     {
    1368         g_crvboxhgcm.iGuestDrv = open(VBOXGUEST_USER_DEVICE_NAME, O_RDWR, 0);
    1369         if (g_crvboxhgcm.iGuestDrv == INVALID_HANDLE_VALUE)
    1370         {
    1371             crDebug("could not open Guest Additions kernel module! rc = %d\n", errno);
    1372             VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    1373             return FALSE;
    1374         }
    1375     }
    1376 #endif
    1377 
    1378     memset (&info, 0, sizeof (info));
    1379     info.Loc.type = VMMDevHGCMLoc_LocalHost_Existing;
    1380     strcpy (info.Loc.u.host.achName, "VBoxSharedCrOpenGL");
    1381 
    1382 #ifdef RT_OS_WINDOWS
    1383     if (DeviceIoControl(g_crvboxhgcm.hGuestDrv,
    1384                         VBOXGUEST_IOCTL_HGCM_CONNECT,
    1385                         &info, sizeof (info),
    1386                         &info, sizeof (info),
    1387                         &cbReturned,
    1388                         NULL))
    1389 #elif defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)
    1390     VBGLBIGREQ Hdr;
    1391     Hdr.u32Magic = VBGLBIGREQ_MAGIC;
    1392     Hdr.cbData = sizeof(info);
    1393     Hdr.pvDataR3 = &info;
    1394 # if HC_ARCH_BITS == 32
    1395     Hdr.u32Padding = 0;
    1396 # endif
    1397     if (ioctl(g_crvboxhgcm.iGuestDrv, VBOXGUEST_IOCTL_HGCM_CONNECT, &Hdr) >= 0)
    1398 #else
    1399     if (ioctl(g_crvboxhgcm.iGuestDrv, VBOXGUEST_IOCTL_HGCM_CONNECT, &info, sizeof (info)) == 0)
    1400 #endif
    1401     {
    1402         if (info.result == VINF_SUCCESS)
    1403         {
    1404             int rc;
    1405             conn->u32ClientID = info.u32ClientID;
     1277    rc = VbglR3InitUser();
     1278    if (RT_SUCCESS(rc))
     1279    {
     1280        uint32_t idClient;
     1281        rc = VbglR3HGCMConnect("VBoxSharedCrOpenGL", &idClient);
     1282        if (RT_SUCCESS(rc))
     1283        {
     1284            conn->u32ClientID = idClient;
    14061285            crDebug("HGCM connect was successful: client id =0x%x\n", conn->u32ClientID);
    14071286
    … …  
    14191298            if (RT_FAILURE(rc))
    14201299            {
    1421                 WARN(("crVBoxHGCMSetPID failed %d", rc));
     1300                WARN(("crVBoxHGCMSetPID failed %Rrc", rc));
    14221301                return FALSE;
    14231302            }
    … …  
    14281307                if (RT_FAILURE(rc))
    14291308                {
    1430                     WARN(("VBoxCrHgsmiCtlConGetHostCaps failed %d", rc));
     1309                    WARN(("VBoxCrHgsmiCtlConGetHostCaps failed %Rrc", rc));
    14311310                    g_crvboxhgcm.u32HostCaps = 0;
    14321311                }
    … …  
    14341313                /* host may not support it, ignore any failures */
    14351314                g_crvboxhgcm.fHostCapsInitialized = true;
    1436                 rc = VINF_SUCCESS;
    14371315            }
    14381316
    … …  
    14451323
    14461324            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    1447             return RT_SUCCESS(rc);
    1448         }
    1449         crDebug("HGCM connect failed with rc=0x%x\n", info.result);
    1450 
    1451         VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    1452         return FALSE;
    1453     }
    1454 #ifdef RT_OS_WINDOWS
    1455     {
    1456         DWORD winEr = GetLastError();
    1457         crDebug("IOCTL for HGCM connect failed with rc=0x%x\n", winEr);
    1458     }
    1459 #else
    1460     crDebug("IOCTL for HGCM connect failed with rc=0x%x\n", errno);
    1461 #endif
     1325            return TRUE;
     1326        }
     1327
     1328        crDebug("HGCM connect failed: %Rrc\n", rc);
     1329        VbglR3Term();
     1330    }
     1331    else
     1332        crDebug("Failed to initialize VbglR3 library: %Rrc\n", rc);
     1333
    14621334    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    14631335    return FALSE;
    14641336
    1465 #else /*#ifdef IN_GUEST*/
     1337#else  /* !IN_GUEST */
    14661338    crError("crVBoxHGCMDoConnect called on host side!");
    14671339    CRASSERT(FALSE);
    14681340    return FALSE;
    1469 #endif
     1341#endif /* !IN_GUEST */
    14701342}
    14711343
    … …  
    15071379static void crVBoxHGCMDoDisconnect( CRConnection *conn )
    15081380{
    1509 #ifdef IN_GUEST
    1510     VBoxGuestHGCMDisconnectInfo info;
    1511 # ifdef RT_OS_WINDOWS
    1512     DWORD cbReturned;
    1513 # endif
    1514 #endif
    15151381    bool fHasActiveCons = false;
    15161382
    … …  
    15291395    if (conn->u32ClientID)
    15301396    {
    1531         memset (&info, 0, sizeof (info));
    1532         info.u32ClientID = conn->u32ClientID;
    1533 
    1534 # ifdef RT_OS_WINDOWS
    1535         if ( !DeviceIoControl(g_crvboxhgcm.hGuestDrv,
    1536                                VBOXGUEST_IOCTL_HGCM_DISCONNECT,
    1537                                &info, sizeof (info),
    1538                                &info, sizeof (info),
    1539                                &cbReturned,
    1540                                NULL) )
    1541         {
    1542             crDebug("Disconnect failed with %x\n", GetLastError());
    1543         }
    1544 # elif defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)
    1545         VBGLBIGREQ Hdr;
    1546         Hdr.u32Magic = VBGLBIGREQ_MAGIC;
    1547         Hdr.cbData = sizeof(info);
    1548         Hdr.pvDataR3 = &info;
    1549 #  if HC_ARCH_BITS == 32
    1550         Hdr.u32Padding = 0;
    1551 #  endif
    1552         if (ioctl(g_crvboxhgcm.iGuestDrv, VBOXGUEST_IOCTL_HGCM_DISCONNECT, &Hdr) >= 0)
    1553 # else
    1554         if (ioctl(g_crvboxhgcm.iGuestDrv, VBOXGUEST_IOCTL_HGCM_DISCONNECT, &info, sizeof (info)) < 0)
    1555         {
    1556             crDebug("Disconnect failed with %x\n", errno);
    1557         }
    1558 # endif
    1559 
     1397        int rc = VbglR3HGCMDisconnect(conn->u32ClientID);
     1398        if (RT_FAILURE(rc))
     1399            crDebug("Disconnect failed with %Rrc\n", rc);
    15601400        conn->u32ClientID = 0;
    1561     }
    1562 
    1563     /* close guest additions driver*/
    1564     if (!fHasActiveCons)
    1565     {
    1566 # ifdef RT_OS_WINDOWS
    1567         CloseHandle(g_crvboxhgcm.hGuestDrv);
    1568         g_crvboxhgcm.hGuestDrv = INVALID_HANDLE_VALUE;
    1569 # else
    1570         close(g_crvboxhgcm.iGuestDrv);
    1571         g_crvboxhgcm.iGuestDrv = INVALID_HANDLE_VALUE;
    1572 # endif
     1401
     1402        VbglR3Term();
    15731403    }
    15741404#endif /* IN_GUEST */
    … …  
    23622192
    23632193#ifdef RT_OS_WINDOWS
    2364     g_crvboxhgcm.hGuestDrv = INVALID_HANDLE_VALUE;
    23652194    g_crvboxhgcm.pDirectDraw = NULL;
    2366 #else
    2367     g_crvboxhgcm.iGuestDrv = INVALID_HANDLE_VALUE;
    23682195#endif
    23692196
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