VirtualBox

Changeset 75989 in vbox for trunk/src


Ignore:
Timestamp:
Dec 5, 2018 7:46:48 PM (6 years ago)
Author:
vboxsync
Message:

GuestProperty: Handle std::bad_alloc as close as possible to the source.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostServices/GuestProperties/service.cpp

    r75987 r75989  
    213213     * @param   pProp         where to return the property found.  If none is
    214214     *                        found this will be set to nil.
    215      * @throws  can throw std::bad_alloc
     215     * @throws  nothing
    216216     * @thread  HGCM
    217217     */
    … …  
    406406    }
    407407
    408     void setHostVersionProps();
     408    int setHostVersionProps();
    409409    void incrementCounterProp(const char *pszName);
    410410    static DECLCALLBACK(void) svcNotify(void *pvService, HGCMNOTIFYEVENT enmEvent);
    … …  
    581581                {
    582582                    /* Update existing property. */
    583                     pProp->mValue     = papszValues[i];
     583                    rc = pProp->mValue.assignNoThrow(papszValues[i]);
     584                    AssertRCBreak(rc);
    584585                    pProp->mTimestamp = paNsTimestamps[i];
    585586                    pProp->mFlags     = fFlags;
    … …  
    588589                {
    589590                    /* Create a new property */
    590                     pProp = new Property(papszNames[i], papszValues[i], paNsTimestamps[i], fFlags);
    591                     if (!pProp)
     591                    try
    592592                    {
    593                         rc = VERR_NO_MEMORY;
    594                         break;
     593                        pProp = new Property(papszNames[i], papszValues[i], paNsTimestamps[i], fFlags);
     594                    }
     595                    catch (std::bad_alloc &)
     596                    {
     597                        return VERR_NO_MEMORY;
    595598                    }
    596599                    if (RTStrSpaceInsert(&mhProperties, &pProp->mStrCore))
    … …  
    793796        if (pProp)
    794797        {
    795             pProp->mValue = pcszValue;
    796             pProp->mTimestamp = nsTimestamp;
    797             pProp->mFlags = fFlags;
     798            rc = pProp->mValue.assignNoThrow(pcszValue);
     799            if (RT_SUCCESS(rc))
     800            {
     801                pProp->mTimestamp = nsTimestamp;
     802                pProp->mFlags = fFlags;
     803            }
    798804        }
    799805        else if (mcProperties < GUEST_PROP_MAX_PROPS)
    … …  
    10431049
    10441050/** Helper query used by getOldNotification
    1045  * @throws  can throw std::bad_alloc
     1051 * @throws  nothing
    10461052 */
    10471053int Service::getOldNotificationInternal(const char *pszPatterns, uint64_t nsTimestamp, Property *pProp)
    … …  
    10641070        if (base->Matches(pszPatterns))
    10651071        {
    1066             *pProp = *base;
     1072            try
     1073            {
     1074                *pProp = *base;
     1075            }
     1076            catch (std::bad_alloc &)
     1077            {
     1078                rc = VERR_NO_MEMORY;
     1079            }
    10671080            return rc;
    10681081        }
    … …  
    11191132 * @param   paParms     the array of HGCM parameters
    11201133 * @thread  HGCM
    1121  * @throws  can throw std::bad_alloc
     1134 * @throws  nothing
    11221135 */
    11231136int Service::getNotification(uint32_t u32ClientId, VBOXHGCMCALLHANDLE callHandle,
    … …  
    11611174                 * Protection against clients, which cancel and resubmits requests.
    11621175                 */
     1176                uint32_t cPendingWaits = 0;
    11631177                CallList::iterator it = mGuestWaiters.begin();
    11641178                while (it != mGuestWaiters.end())
    11651179                {
    1166                     const char *pszPatternsExisting;
    1167                     uint32_t cchPatternsExisting;
    1168                     int rc3 = HGCMSvcGetCStr(&it->mParms[0], &pszPatternsExisting, &cchPatternsExisting);
    1169 
    1170                     if (   RT_SUCCESS(rc3)
    1171                         && u32ClientId == it->u32ClientId
    1172                         && RTStrCmp(pszPatterns, pszPatternsExisting) == 0)
     1180                    if (u32ClientId == it->u32ClientId)
    11731181                    {
    1174                         /* Complete the old request. */
    1175                         mpHelpers->pfnCallComplete(it->mHandle, VERR_INTERRUPTED);
    1176                         it = mGuestWaiters.erase(it);
     1182                        const char *pszPatternsExisting;
     1183                        uint32_t    cchPatternsExisting;
     1184                        int rc3 = HGCMSvcGetCStr(&it->mParms[0], &pszPatternsExisting, &cchPatternsExisting);
     1185                        if (   RT_SUCCESS(rc3)
     1186                            && RTStrCmp(pszPatterns, pszPatternsExisting) == 0)
     1187                        {
     1188                            /* Complete the old request. */
     1189                            mpHelpers->pfnCallComplete(it->mHandle, VERR_INTERRUPTED);
     1190                            it = mGuestWaiters.erase(it);
     1191                        }
     1192                        //else if (mpHelpers->pfnIsCallCancelled(it->mHandle))
     1193                        //{
     1194                        //    /* Cleanup cancelled request. */
     1195                        //    mpHelpers->pfnCallComplete(it->mHandle, VERR_INTERRUPTED);
     1196                        //    it = mGuestWaiters.erase(it);
     1197                        //}
     1198                        else
     1199                        {
     1200                            /** @todo check if cancelled. */
     1201                            cPendingWaits++;
     1202                            ++it;
     1203                        }
    11771204                    }
    11781205                    else
    … …  
    11801207                }
    11811208
    1182                 mGuestWaiters.push_back(GuestCall(u32ClientId, callHandle, GUEST_PROP_FN_GET_NOTIFICATION,
    1183                                                   cParms, paParms, rc));
    1184                 rc = VINF_HGCM_ASYNC_EXECUTE;
     1209                //if (cPendingWaits < 16)
     1210                {
     1211                    try
     1212                    {
     1213                        mGuestWaiters.push_back(GuestCall(u32ClientId, callHandle, GUEST_PROP_FN_GET_NOTIFICATION,
     1214                                                          cParms, paParms, rc));
     1215                        rc = VINF_HGCM_ASYNC_EXECUTE;
     1216                    }
     1217                    catch (std::bad_alloc &)
     1218                    {
     1219                        rc = VERR_NO_MEMORY;
     1220                    }
     1221                }
     1222                //else
     1223                //{
     1224                //    LogFunc(("Too many pending waits already!\n"));
     1225                //    rc = VERR_OUT_OF_RESOURCES;
     1226                //}
    11851227            }
    11861228            /*
    … …  
    12041246 * Notify the service owner and the guest that a property has been
    12051247 * added/deleted/changed
    1206  * @param pszProperty  the name of the property which has changed
    1207  * @param nsTimestamp  the time at which the change took place
    1208  *
     1248 *
     1249 * @param   pszProperty The name of the property which has changed.
     1250 * @param   nsTimestamp The time at which the change took place.
     1251 * @throws  nothing.
    12091252 * @thread  HGCM service
    12101253 */
    … …  
    12191262
    12201263    /*
     1264     * Don't keep too many changes around.
     1265     */
     1266    if (mGuestNotifications.size() >= GUEST_PROP_MAX_GUEST_NOTIFICATIONS)
     1267        mGuestNotifications.pop_front();
     1268
     1269    /*
    12211270     * Try to find the property.  Create a change event if we find it and a
    12221271     * delete event if we do not.
    12231272     */
    12241273    Property prop;
    1225     prop.mName = pszProperty;
     1274    int rc = prop.mName.assignNoThrow(pszProperty);
     1275    AssertRCReturn(rc, rc);
    12261276    prop.mTimestamp = nsTimestamp;
    12271277    /* prop is currently a delete event for pszProperty */
    … …  
    12301280    {
    12311281        /* Make prop into a change event. */
    1232         prop.mValue = pProp->mValue;
     1282        rc = prop.mValue.assignNoThrow(pProp->mValue);
     1283        AssertRCReturn(rc, rc);
    12331284        prop.mFlags = pProp->mFlags;
    12341285    }
    … …  
    12361287    /* Release guest waiters if applicable and add the event
    12371288     * to the queue for guest notifications */
    1238     int rc = VINF_SUCCESS;
    1239     try
    1240     {
    1241         CallList::iterator it = mGuestWaiters.begin();
     1289    CallList::iterator it = mGuestWaiters.begin();
     1290    if (it != mGuestWaiters.end())
     1291    {
     1292        const char *pszPatterns;
     1293        uint32_t    cchPatterns;
     1294        HGCMSvcGetCStr(&it->mParms[0], &pszPatterns, &cchPatterns);
     1295
    12421296        while (it != mGuestWaiters.end())
    12431297        {
    1244             const char *pszPatterns;
    1245             uint32_t cchPatterns;
    1246             HGCMSvcGetCStr(&it->mParms[0], &pszPatterns, &cchPatterns);
    12471298            if (prop.Matches(pszPatterns))
    12481299            {
    1249                 GuestCall curCall = *it;
    1250                 int rc2 = getNotificationWriteOut(curCall.mParmsCnt, curCall.mParms, prop);
     1300                int rc2 = getNotificationWriteOut(it->mParmsCnt, it->mParms, prop);
    12511301                if (RT_SUCCESS(rc2))
    1252                     rc2 = curCall.mRc;
    1253                 mpHelpers->pfnCallComplete(curCall.mHandle, rc2);
     1302                    rc2 = it->mRc;
     1303                mpHelpers->pfnCallComplete(it->mHandle, rc2);
    12541304                it = mGuestWaiters.erase(it);
    12551305            }
    … …  
    12571307                ++it;
    12581308        }
    1259 
     1309    }
     1310
     1311    try
     1312    {
    12601313        mGuestNotifications.push_back(prop);
    1261 
    1262         /** @todo r=andy This list does not have a purpose but for tracking
    1263           *              the timestamps ... */
    1264         if (mGuestNotifications.size() > GUEST_PROP_MAX_GUEST_NOTIFICATIONS)
    1265             mGuestNotifications.pop_front();
    12661314    }
    12671315    catch (std::bad_alloc &)
    … …  
    13811429                    VBOXHGCMSVCPARM paParms[])
    13821430{
    1383     int rc = VINF_SUCCESS;
     1431    int rc;
    13841432    LogFlowFunc(("u32ClientID = %d, fn = %d, cParms = %d, pparms = %p\n",
    13851433                 u32ClientID, eFunction, cParms, paParms));
    13861434
    1387     try
    1388     {
    1389         switch (eFunction)
    1390         {
    1391             /* The guest wishes to read a property */
    1392             case GUEST_PROP_FN_GET_PROP:
    1393                 LogFlowFunc(("GET_PROP\n"));
    1394                 rc = getProperty(cParms, paParms);
    1395                 break;
    1396 
    1397             /* The guest wishes to set a property */
    1398             case GUEST_PROP_FN_SET_PROP:
    1399                 LogFlowFunc(("SET_PROP\n"));
    1400                 rc = setProperty(cParms, paParms, true);
    1401                 break;
    1402 
    1403             /* The guest wishes to set a property value */
    1404             case GUEST_PROP_FN_SET_PROP_VALUE:
    1405                 LogFlowFunc(("SET_PROP_VALUE\n"));
    1406                 rc = setProperty(cParms, paParms, true);
    1407                 break;
    1408 
    1409             /* The guest wishes to remove a configuration value */
    1410             case GUEST_PROP_FN_DEL_PROP:
    1411                 LogFlowFunc(("DEL_PROP\n"));
    1412                 rc = delProperty(cParms, paParms, true);
    1413                 break;
    1414 
    1415             /* The guest wishes to enumerate all properties */
    1416             case GUEST_PROP_FN_ENUM_PROPS:
    1417                 LogFlowFunc(("ENUM_PROPS\n"));
    1418                 rc = enumProps(cParms, paParms);
    1419                 break;
    1420 
    1421             /* The guest wishes to get the next property notification */
    1422             case GUEST_PROP_FN_GET_NOTIFICATION:
    1423                 LogFlowFunc(("GET_NOTIFICATION\n"));
    1424                 rc = getNotification(u32ClientID, callHandle, cParms, paParms);
    1425                 break;
    1426 
    1427             default:
    1428                 rc = VERR_NOT_IMPLEMENTED;
    1429         }
    1430     }
    1431     catch (std::bad_alloc &)
    1432     {
    1433         rc = VERR_NO_MEMORY;
     1435    switch (eFunction)
     1436    {
     1437        /* The guest wishes to read a property */
     1438        case GUEST_PROP_FN_GET_PROP:
     1439            LogFlowFunc(("GET_PROP\n"));
     1440            rc = getProperty(cParms, paParms);
     1441            break;
     1442
     1443        /* The guest wishes to set a property */
     1444        case GUEST_PROP_FN_SET_PROP:
     1445            LogFlowFunc(("SET_PROP\n"));
     1446            rc = setProperty(cParms, paParms, true);
     1447            break;
     1448
     1449        /* The guest wishes to set a property value */
     1450        case GUEST_PROP_FN_SET_PROP_VALUE:
     1451            LogFlowFunc(("SET_PROP_VALUE\n"));
     1452            rc = setProperty(cParms, paParms, true);
     1453            break;
     1454
     1455        /* The guest wishes to remove a configuration value */
     1456        case GUEST_PROP_FN_DEL_PROP:
     1457            LogFlowFunc(("DEL_PROP\n"));
     1458            rc = delProperty(cParms, paParms, true);
     1459            break;
     1460
     1461        /* The guest wishes to enumerate all properties */
     1462        case GUEST_PROP_FN_ENUM_PROPS:
     1463            LogFlowFunc(("ENUM_PROPS\n"));
     1464            rc = enumProps(cParms, paParms);
     1465            break;
     1466
     1467        /* The guest wishes to get the next property notification */
     1468        case GUEST_PROP_FN_GET_NOTIFICATION:
     1469            LogFlowFunc(("GET_NOTIFICATION\n"));
     1470            rc = getNotification(u32ClientID, callHandle, cParms, paParms);
     1471            break;
     1472
     1473        default:
     1474            rc = VERR_NOT_IMPLEMENTED;
    14341475    }
    14351476    LogFlowFunc(("rc = %Rrc\n", rc));
    14361477    if (rc != VINF_HGCM_ASYNC_EXECUTE)
    1437     {
    1438         mpHelpers->pfnCallComplete (callHandle, rc);
    1439     }
     1478        mpHelpers->pfnCallComplete(callHandle, rc);
    14401479}
    14411480
    … …  
    14901529int Service::hostCall (uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    14911530{
    1492     int rc = VINF_SUCCESS;
    1493 
    1494     LogFlowFunc(("fn = %d, cParms = %d, pparms = %p\n",
    1495                  eFunction, cParms, paParms));
    1496 
    1497     try
    1498     {
    1499         switch (eFunction)
    1500         {
    1501             /* The host wishes to set a block of properties */
    1502             case GUEST_PROP_FN_HOST_SET_PROPS:
    1503                 LogFlowFunc(("SET_PROPS_HOST\n"));
    1504                 rc = setPropertyBlock(cParms, paParms);
    1505                 break;
    1506 
    1507             /* The host wishes to read a configuration value */
    1508             case GUEST_PROP_FN_HOST_GET_PROP:
    1509                 LogFlowFunc(("GET_PROP_HOST\n"));
    1510                 rc = getProperty(cParms, paParms);
    1511                 break;
    1512 
    1513             /* The host wishes to set a configuration value */
    1514             case GUEST_PROP_FN_HOST_SET_PROP:
    1515                 LogFlowFunc(("SET_PROP_HOST\n"));
    1516                 rc = setProperty(cParms, paParms, false);
    1517                 break;
    1518 
    1519             /* The host wishes to set a configuration value */
    1520             case GUEST_PROP_FN_HOST_SET_PROP_VALUE:
    1521                 LogFlowFunc(("SET_PROP_VALUE_HOST\n"));
    1522                 rc = setProperty(cParms, paParms, false);
    1523                 break;
    1524 
    1525             /* The host wishes to remove a configuration value */
    1526             case GUEST_PROP_FN_HOST_DEL_PROP:
    1527                 LogFlowFunc(("DEL_PROP_HOST\n"));
    1528                 rc = delProperty(cParms, paParms, false);
    1529                 break;
    1530 
    1531             /* The host wishes to enumerate all properties */
    1532             case GUEST_PROP_FN_HOST_ENUM_PROPS:
    1533                 LogFlowFunc(("ENUM_PROPS\n"));
    1534                 rc = enumProps(cParms, paParms);
    1535                 break;
    1536 
    1537             /* The host wishes to set global flags for the service */
    1538             case GUEST_PROP_FN_HOST_SET_GLOBAL_FLAGS:
    1539                 LogFlowFunc(("SET_GLOBAL_FLAGS_HOST\n"));
    1540                 if (cParms == 1)
    1541                 {
    1542                     uint32_t fFlags;
    1543                     rc = HGCMSvcGetU32(&paParms[0], &fFlags);
    1544                     if (RT_SUCCESS(rc))
    1545                         mfGlobalFlags = fFlags;
    1546                 }
    1547                 else
    1548                     rc = VERR_INVALID_PARAMETER;
    1549                 break;
    1550 
    1551             default:
    1552                 rc = VERR_NOT_SUPPORTED;
    1553                 break;
    1554         }
    1555     }
    1556     catch (std::bad_alloc &)
    1557     {
    1558         rc = VERR_NO_MEMORY;
     1531    int rc;
     1532    LogFlowFunc(("fn = %d, cParms = %d, pparms = %p\n", eFunction, cParms, paParms));
     1533
     1534    switch (eFunction)
     1535    {
     1536        /* The host wishes to set a block of properties */
     1537        case GUEST_PROP_FN_HOST_SET_PROPS:
     1538            LogFlowFunc(("SET_PROPS_HOST\n"));
     1539            rc = setPropertyBlock(cParms, paParms);
     1540            break;
     1541
     1542        /* The host wishes to read a configuration value */
     1543        case GUEST_PROP_FN_HOST_GET_PROP:
     1544            LogFlowFunc(("GET_PROP_HOST\n"));
     1545            rc = getProperty(cParms, paParms);
     1546            break;
     1547
     1548        /* The host wishes to set a configuration value */
     1549        case GUEST_PROP_FN_HOST_SET_PROP:
     1550            LogFlowFunc(("SET_PROP_HOST\n"));
     1551            rc = setProperty(cParms, paParms, false);
     1552            break;
     1553
     1554        /* The host wishes to set a configuration value */
     1555        case GUEST_PROP_FN_HOST_SET_PROP_VALUE:
     1556            LogFlowFunc(("SET_PROP_VALUE_HOST\n"));
     1557            rc = setProperty(cParms, paParms, false);
     1558            break;
     1559
     1560        /* The host wishes to remove a configuration value */
     1561        case GUEST_PROP_FN_HOST_DEL_PROP:
     1562            LogFlowFunc(("DEL_PROP_HOST\n"));
     1563            rc = delProperty(cParms, paParms, false);
     1564            break;
     1565
     1566        /* The host wishes to enumerate all properties */
     1567        case GUEST_PROP_FN_HOST_ENUM_PROPS:
     1568            LogFlowFunc(("ENUM_PROPS\n"));
     1569            rc = enumProps(cParms, paParms);
     1570            break;
     1571
     1572        /* The host wishes to set global flags for the service */
     1573        case GUEST_PROP_FN_HOST_SET_GLOBAL_FLAGS:
     1574            LogFlowFunc(("SET_GLOBAL_FLAGS_HOST\n"));
     1575            if (cParms == 1)
     1576            {
     1577                uint32_t fFlags;
     1578                rc = HGCMSvcGetU32(&paParms[0], &fFlags);
     1579                if (RT_SUCCESS(rc))
     1580                    mfGlobalFlags = fFlags;
     1581            }
     1582            else
     1583                rc = VERR_INVALID_PARAMETER;
     1584            break;
     1585
     1586        default:
     1587            rc = VERR_NOT_SUPPORTED;
     1588            break;
    15591589    }
    15601590
    … …  
    16231653 * Sets the VBoxVer, VBoxVerExt and VBoxRev properties.
    16241654 */
    1625 void Service::setHostVersionProps()
     1655int Service::setHostVersionProps()
    16261656{
    16271657    uint64_t nsTimestamp = getCurrentTimestamp();
    … …  
    16291659    /* Set the raw VBox version string as a guest property. Used for host/guest
    16301660     * version comparison. */
    1631     setPropertyInternal("/VirtualBox/HostInfo/VBoxVer", VBOX_VERSION_STRING_RAW,
    1632                         GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsTimestamp);
     1661    int rc = setPropertyInternal("/VirtualBox/HostInfo/VBoxVer", VBOX_VERSION_STRING_RAW,
     1662                                 GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsTimestamp);
     1663    AssertRCReturn(rc, rc);
    16331664
    16341665    /* Set the full VBox version string as a guest property. Can contain vendor-specific
    16351666     * information/branding and/or pre-release tags. */
    1636     setPropertyInternal("/VirtualBox/HostInfo/VBoxVerExt", VBOX_VERSION_STRING,
    1637                         GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsTimestamp);
     1667    rc = setPropertyInternal("/VirtualBox/HostInfo/VBoxVerExt", VBOX_VERSION_STRING,
     1668                             GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsTimestamp + 1);
     1669    AssertRCReturn(rc, rc);
    16381670
    16391671    /* Set the VBox SVN revision as a guest property */
    1640     setPropertyInternal("/VirtualBox/HostInfo/VBoxRev", RTBldCfgRevisionStr(),
    1641                         GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsTimestamp);
     1672    rc = setPropertyInternal("/VirtualBox/HostInfo/VBoxRev", RTBldCfgRevisionStr(),
     1673                             GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsTimestamp + 2);
     1674    AssertRCReturn(rc, rc);
     1675    return VINF_SUCCESS;
    16421676}
    16431677
    … …  
    16511685    AssertPtrReturnVoid(pThis);
    16521686
    1653     try
    1654     {
    1655         /* Make sure the host version properties have been touched and are
    1656            up-to-date after a restore: */
    1657         if (   !pThis->m_fSetHostVersionProps
    1658             && (enmEvent == HGCMNOTIFYEVENT_RESUME || enmEvent == HGCMNOTIFYEVENT_POWER_ON))
    1659         {
    1660             pThis->setHostVersionProps();
    1661             pThis->m_fSetHostVersionProps = true;
    1662         }
    1663 
    1664         if (enmEvent == HGCMNOTIFYEVENT_RESUME)
    1665             pThis->incrementCounterProp("/VirtualBox/VMInfo/ResumeCounter");
    1666 
    1667         if (enmEvent == HGCMNOTIFYEVENT_RESET)
    1668             pThis->incrementCounterProp("/VirtualBox/VMInfo/ResetCounter");
    1669     }
    1670     catch (std::bad_alloc &)
    1671     {
    1672         /* ignore */
    1673     }
     1687    /* Make sure the host version properties have been touched and are
     1688       up-to-date after a restore: */
     1689    if (   !pThis->m_fSetHostVersionProps
     1690        && (enmEvent == HGCMNOTIFYEVENT_RESUME || enmEvent == HGCMNOTIFYEVENT_POWER_ON))
     1691    {
     1692        pThis->setHostVersionProps();
     1693        pThis->m_fSetHostVersionProps = true;
     1694    }
     1695
     1696    if (enmEvent == HGCMNOTIFYEVENT_RESUME)
     1697        pThis->incrementCounterProp("/VirtualBox/VMInfo/ResumeCounter");
     1698
     1699    if (enmEvent == HGCMNOTIFYEVENT_RESET)
     1700        pThis->incrementCounterProp("/VirtualBox/VMInfo/ResetCounter");
    16741701}
    16751702
    … …  
    17131740     * Insert standard host properties.
    17141741     */
    1715     try
    1716     {
    1717         /* The host version will but updated again on power on or resume
    1718            (after restore), however we need the properties now for restored
    1719            guest notification/wait calls. */
    1720         setHostVersionProps();
    1721 
    1722         /* Sysprep execution by VBoxService (host is allowed to change these). */
    1723         uint64_t nsNow = getCurrentTimestamp();
    1724         setPropertyInternal("/VirtualBox/HostGuest/SysprepExec", "", GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsNow);
    1725         setPropertyInternal("/VirtualBox/HostGuest/SysprepArgs", "", GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsNow);
    1726 
    1727         /* Resume and reset counters. */
    1728         setPropertyInternal("/VirtualBox/VMInfo/ResumeCounter", "0", GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsNow);
    1729         setPropertyInternal("/VirtualBox/VMInfo/ResetCounter", "0", GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsNow);
    1730     }
    1731     catch (std::bad_alloc &)
    1732     {
    1733         return VERR_NO_MEMORY;
    1734     }
     1742    /* The host version will but updated again on power on or resume
     1743       (after restore), however we need the properties now for restored
     1744       guest notification/wait calls. */
     1745    int rc = setHostVersionProps();
     1746    AssertRCReturn(rc, rc);
     1747
     1748    /* Sysprep execution by VBoxService (host is allowed to change these). */
     1749    uint64_t nsNow = getCurrentTimestamp();
     1750    rc = setPropertyInternal("/VirtualBox/HostGuest/SysprepExec", "", GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsNow);
     1751    AssertRCReturn(rc, rc);
     1752    rc = setPropertyInternal("/VirtualBox/HostGuest/SysprepArgs", "", GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsNow);
     1753    AssertRCReturn(rc, rc);
     1754
     1755    /* Resume and reset counters. */
     1756    rc = setPropertyInternal("/VirtualBox/VMInfo/ResumeCounter", "0", GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsNow);
     1757    AssertRCReturn(rc, rc);
     1758    rc = setPropertyInternal("/VirtualBox/VMInfo/ResetCounter",  "0", GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_RDONLYGUEST, nsNow);
     1759    AssertRCReturn(rc, rc);
    17351760
    17361761    /* The host notification thread and queue. */
    1737     int rc = RTReqQueueCreate(&mhReqQNotifyHost);
     1762    rc = RTReqQueueCreate(&mhReqQNotifyHost);
    17381763    if (RT_SUCCESS(rc))
    17391764    {
    … …  
    17441769                            RTTHREADTYPE_DEFAULT,
    17451770                            RTTHREADFLAGS_WAITABLE,
    1746                             "GSTPROPNTFY");
     1771                            "GstPropNtfy");
    17471772        if (RT_SUCCESS(rc))
    17481773        {
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