VirtualBox

Ignore:
Timestamp:
Mar 4, 2010 1:32:45 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
58333
Message:

Guest Additions: memory ballooning for guests without support for RTR0MemObjAllocPhysNC()

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp

    r26999 r27023  
    4848#endif
    4949
     50const size_t cbChangeMemBalloonReq = RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[VMMDEV_MEMORY_BALLOON_CHUNK_PAGES]);
    5051
    5152
    … …  
    259260{
    260261    VMMDevReportGuestInfo *pReq;
    261     int rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, sizeof(*pReq), VMMDevReq_ReportGuestInfo);
     262    int rc;
     263    rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, sizeof(*pReq), VMMDevReq_ReportGuestInfo);
    262264    if (RT_SUCCESS(rc))
    263265    {
    … …  
    274276}
    275277
     278/**
     279 * Inflate the balloon by one chunk represented by an R0 memory object.
     280 *
     281 * @returns IPRT status code.
     282 * @param   pMemObj     Pointer to the R0 memory object.
     283 * @param   pReq        The pre-allocated request for performing the VMMDev call.
     284 */
     285static int vboxGuestBalloonInflate(PRTR0MEMOBJ pMemObj, VMMDevChangeMemBalloon *pReq)
     286{
     287    uint32_t iPage;
     288    int rc;
     289
     290    for (iPage = 0; iPage < VMMDEV_MEMORY_BALLOON_CHUNK_PAGES; iPage++)
     291    {
     292        RTHCPHYS phys = RTR0MemObjGetPagePhysAddr(*pMemObj, iPage);
     293        pReq->aPhysPage[iPage] = phys;
     294    }
     295
     296    /* Protect this memory from being accessed. Doesn't work on every platform and probably
     297     * doesn't work for R3-provided memory, therefore ignore the return value. Unprotect
     298     * done when object is freed. */
     299    rc = RTR0MemObjProtect(*pMemObj, 0, VMMDEV_MEMORY_BALLOON_CHUNK_SIZE, RTMEM_PROT_NONE);
     300    NOREF(rc);
     301
     302    pReq->fInflate = true;
     303    pReq->header.size = cbChangeMemBalloonReq;
     304    pReq->cPages = VMMDEV_MEMORY_BALLOON_CHUNK_PAGES;
     305
     306    return VbglGRPerform(&pReq->header);
     307}
     308
     309/**
     310 * Deflate the balloon by one chunk represented by an R0 memory object.
     311 *
     312 * @returns IPRT status code.
     313 * @param   pMemObj     Pointer to the R0 memory object.
     314 *                      The memory object will be freed afterwards.
     315 * @param   pReq        The pre-allocated request for performing the VMMDev call.
     316 */
     317static int vboxGuestBalloonDeflate(PRTR0MEMOBJ pMemObj, VMMDevChangeMemBalloon *pReq)
     318{
     319    uint32_t iPage;
     320    int rc;
     321
     322    for (iPage = 0; iPage < VMMDEV_MEMORY_BALLOON_CHUNK_PAGES; iPage++)
     323    {
     324        RTHCPHYS phys = RTR0MemObjGetPagePhysAddr(*pMemObj, iPage);
     325        pReq->aPhysPage[iPage] = phys;
     326    }
     327
     328    pReq->fInflate = false;
     329    pReq->header.size = cbChangeMemBalloonReq;
     330    pReq->cPages = VMMDEV_MEMORY_BALLOON_CHUNK_PAGES;
     331
     332    rc = VbglGRPerform(&pReq->header);
     333    if (RT_FAILURE(rc))
     334        return rc;
     335
     336    rc = RTR0MemObjFree(*pMemObj, true);
     337    if (RT_FAILURE(rc))
     338        return rc;
     339
     340    *pMemObj = NIL_RTR0MEMOBJ;
     341    return VINF_SUCCESS;
     342}
     343
    276344
    277345/**
    … …  
    279347 *
    280348 * @returns VBox status code.
    281  * @param   pDevExt     The device extension
    282  * @param   u32BalloonSize The new size of the balloon in chunks of 1MB.
    283  */
    284 static int vboxGuestSetBalloonSizeKernel(PVBOXGUESTDEVEXT pDevExt, uint32_t u32BalloonSize)
     349 * @param   pDevExt         The device extension
     350 * @param   cBalloonChunks The new size of the balloon in chunks of 1MB.
     351 */
     352static int vboxGuestSetBalloonSizeKernel(PVBOXGUESTDEVEXT pDevExt, uint32_t cBalloonChunks)
    285353{
    286354    int rc = VINF_SUCCESS;
    … …  
    289357    {
    290358        VMMDevChangeMemBalloon *pReq;
    291         uint32_t i, j;
    292         const size_t cbReq = RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[VMMDEV_MEMORY_BALLOON_CHUNK_PAGES]);
    293 
    294         if (u32BalloonSize > pDevExt->MemBalloon.cMaxChunks)
     359        uint32_t i;
     360
     361        if (cBalloonChunks > pDevExt->MemBalloon.cMaxChunks)
    295362        {
    296363            AssertMsgFailed(("vboxGuestSetBalloonSize illegal balloon size %d (max=%d)\n",
    297                              u32BalloonSize, pDevExt->MemBalloon.cMaxChunks));
     364                             cBalloonChunks, pDevExt->MemBalloon.cMaxChunks));
    298365            return VERR_INVALID_PARAMETER;
    299366        }
    300367
    301         if (u32BalloonSize == pDevExt->MemBalloon.cMaxChunks)
     368        if (cBalloonChunks == pDevExt->MemBalloon.cMaxChunks)
    302369            return VINF_SUCCESS;   /* nothing to do */
    303370
    304         rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, cbReq, VMMDevReq_ChangeMemBalloon);
     371        if (   cBalloonChunks > pDevExt->MemBalloon.cChunks
     372            && !pDevExt->MemBalloon.paMemObj)
     373        {
     374            pDevExt->MemBalloon.paMemObj = (RTR0MEMOBJ*)RTMemAllocZ(sizeof(RTR0MEMOBJ) * pDevExt->MemBalloon.cMaxChunks);
     375            if (!pDevExt->MemBalloon.paMemObj)
     376            {
     377                LogRel(("VBoxGuestSetBalloonSizeKernel: no memory for paMemObj!\n"));
     378                return VERR_NO_MEMORY;
     379            }
     380        }
     381
     382        rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, cbChangeMemBalloonReq, VMMDevReq_ChangeMemBalloon);
    305383        if (RT_FAILURE(rc))
    306384            return rc;
    307385
    308         if (u32BalloonSize > pDevExt->MemBalloon.cChunks)
     386        if (cBalloonChunks > pDevExt->MemBalloon.cChunks)
    309387        {
    310388            /* inflate */
    311             for (i = pDevExt->MemBalloon.cChunks; i < u32BalloonSize; i++)
     389            for (i = pDevExt->MemBalloon.cChunks; i < cBalloonChunks; i++)
    312390            {
    313391                rc = RTR0MemObjAllocPhysNC(&pDevExt->MemBalloon.paMemObj[i],
    314                                            VMMDEV_MEMORY_BALLOON_CHUNK_PAGES * PAGE_SIZE, NIL_RTHCPHYS);
     392                                           VMMDEV_MEMORY_BALLOON_CHUNK_SIZE, NIL_RTHCPHYS);
    315393                if (RT_UNLIKELY(rc == VERR_NOT_SUPPORTED))
    316394                {
     395                    /* not supported -- fall back to the R3-allocated memory */
    317396                    pDevExt->MemBalloon.fUseKernelAPI = false;
    318397                    break;
    … …  
    329408                }
    330409
    331                 RTR0MEMOBJ MemObj = pDevExt->MemBalloon.paMemObj[i];
    332                 for (j = 0; j < VMMDEV_MEMORY_BALLOON_CHUNK_PAGES; j++)
    333                 {
    334                     RTHCPHYS phys = RTR0MemObjGetPagePhysAddr(MemObj, j);
    335                     pReq->aPhysPage[j] = phys;
    336                 }
    337 
    338                 pReq->header.size = cbReq;
    339                 pReq->cPages = VMMDEV_MEMORY_BALLOON_CHUNK_PAGES;
    340                 pReq->fInflate = true;
    341 
    342                 rc = VbglGRPerform(&pReq->header);
     410                rc = vboxGuestBalloonInflate(&pDevExt->MemBalloon.paMemObj[i], pReq);
    343411                if (RT_FAILURE(rc))
    344412                {
    345                     Log(("vboxGuestSetBalloonSize(inflate): VbglGRPerform failed, rc=%Rrc!\n", rc));
     413                    Log(("vboxGuestSetBalloonSize(inflate): failed, rc=%Rrc!\n", rc));
    346414                    break;
    347415                }
    … …  
    352420        {
    353421            /* deflate */
    354             for (i = pDevExt->MemBalloon.cChunks; i > u32BalloonSize; i--)
     422            for (i = pDevExt->MemBalloon.cChunks; i-- > cBalloonChunks;)
    355423            {
    356                 RTR0MEMOBJ MemObj = pDevExt->MemBalloon.paMemObj[i];
    357                 for (j = 0; j < VMMDEV_MEMORY_BALLOON_CHUNK_PAGES; j++)
    358                 {
    359                     RTHCPHYS phys = RTR0MemObjGetPagePhysAddr(MemObj, j);
    360                     pReq->aPhysPage[j] = phys;
    361                 }
    362 
    363                 pReq->header.size = cbReq;
    364                 pReq->cPages = VMMDEV_MEMORY_BALLOON_CHUNK_PAGES;
    365                 pReq->fInflate = false;
    366 
    367                 rc = VbglGRPerform(&pReq->header);
     424                rc = vboxGuestBalloonDeflate(&pDevExt->MemBalloon.paMemObj[i], pReq);
    368425                if (RT_FAILURE(rc))
    369426                {
    370                     Log(("vboxGuestSetBalloonSize(deflate): VbglGRPerform failed, rc=%Rrc!\n", rc));
     427                    Log(("vboxGuestSetBalloonSize(deflate): failed, rc=%Rrc!\n", rc));
    371428                    break;
    372429                }
    373 
    374                 rc = RTR0MemObjFree(pDevExt->MemBalloon.paMemObj[i], true);
    375                 if (RT_FAILURE(rc))
    376                 {
    377                     Log(("vboxGuestSetBalloonSize(deflate): RTR0MemObjFree() failed, rc=%Rrc!\n", rc));
    378                     break;
    379                 }
    380                 pDevExt->MemBalloon.paMemObj[i] = NIL_RTR0MEMOBJ;
    381430                pDevExt->MemBalloon.cChunks--;
    382431            }
    … …  
    405454    VMMDevChangeMemBalloon *pReq;
    406455    int rc = VINF_SUCCESS;
    407     uint32_t i, j;
    408     const size_t cbReq = RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[VMMDEV_MEMORY_BALLOON_CHUNK_PAGES]);
     456    uint32_t i;
    409457    PRTR0MEMOBJ pMemObj = NULL;
    410458
    411     if (   fInflate
    412         && pSession->MemBalloon.cChunks > pSession->MemBalloon.cMaxChunks - 1)
    413     {
    414         AssertMsgFailed(("vboxGuestSetBalloonSize: cannot inflate balloon, already have (max=%d)\n",
    415                          pSession->MemBalloon.cChunks, pSession->MemBalloon.cMaxChunks));
    416         return VERR_INVALID_PARAMETER;
    417     }
    418     else if (   !fInflate
    419              && pSession->MemBalloon.cChunks == 0)
    420     {
    421         AssertMsgFailed(("vboxGuestSetBalloonSize: cannot decrease balloon, already at size 0\n"));
    422         return VERR_INVALID_PARAMETER;
     459    if (fInflate)
     460    {
     461        if (pSession->MemBalloon.cChunks > pDevExt->MemBalloon.cMaxChunks - 1)
     462        {
     463            AssertMsgFailed(("vboxGuestSetBalloonSize: cannot inflate balloon, already have (max=%d)\n",
     464                             pSession->MemBalloon.cChunks, pDevExt->MemBalloon.cMaxChunks));
     465            return VERR_INVALID_PARAMETER;
     466        }
     467
     468        if (!pSession->MemBalloon.paMemObj)
     469        {
     470            pSession->MemBalloon.paMemObj = (RTR0MEMOBJ*)RTMemAllocZ(sizeof(RTR0MEMOBJ) * pDevExt->MemBalloon.cMaxChunks);
     471            if (!pSession->MemBalloon.paMemObj)
     472            {
     473                LogRel(("VBoxGuestSetBalloonSizeFromUser: no memory for paMemObj!\n"));
     474                return VERR_NO_MEMORY;
     475            }
     476            for (i = 0; i < pDevExt->MemBalloon.cMaxChunks; i++)
     477                pSession->MemBalloon.paMemObj[i] = NIL_RTR0MEMOBJ;
     478        }
     479    }
     480    else
     481    {
     482        if (pSession->MemBalloon.cChunks == 0)
     483        {
     484            AssertMsgFailed(("vboxGuestSetBalloonSize: cannot decrease balloon, already at size 0\n"));
     485            return VERR_INVALID_PARAMETER;
     486        }
    423487    }
    424488
    … …  
    426490     * Enumerate all memory objects and check if the object is already registered.
    427491     */
    428     for (i = 0; i < pSession->MemBalloon.cMaxChunks; i++)
     492    for (i = 0; i < pDevExt->MemBalloon.cMaxChunks; i++)
    429493    {
    430494        if (   fInflate
    431             && !pSession->MemBalloon.paMemObj[i] == NIL_RTR0MEMOBJ
    432             && !pMemObj)
     495            && !pMemObj
     496            && pSession->MemBalloon.paMemObj[i] == NIL_RTR0MEMOBJ)
    433497            pMemObj = &pSession->MemBalloon.paMemObj[i]; /* found free object pointer */
    434498        if (RTR0MemObjAddressR3(pSession->MemBalloon.paMemObj[i]) == u64ChunkAddr)
    … …  
    448512    }
    449513
    450     rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, cbReq, VMMDevReq_ChangeMemBalloon);
     514    rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, cbChangeMemBalloonReq, VMMDevReq_ChangeMemBalloon);
    451515    if (RT_FAILURE(rc))
    452516        return rc;
    … …  
    456520        if (fInflate)
    457521        {
    458             rc = RTR0MemObjLockUser(pMemObj, u64ChunkAddr, VMMDEV_MEMORY_BALLOON_CHUNK_PAGES * PAGE_SIZE,
     522            rc = RTR0MemObjLockUser(pMemObj, u64ChunkAddr, VMMDEV_MEMORY_BALLOON_CHUNK_SIZE,
    459523                                    RTMEM_PROT_READ | RTMEM_PROT_WRITE, NIL_RTR0PROCESS);
    460524            if (RT_SUCCESS(rc))
    461525            {
    462                 RTR0MEMOBJ MemObj = pDevExt->MemBalloon.paMemObj[i];
    463                 for (j = 0; j < VMMDEV_MEMORY_BALLOON_CHUNK_PAGES; j++)
    464                 {
    465                     RTHCPHYS phys = RTR0MemObjGetPagePhysAddr(MemObj, j);
    466                     pReq->aPhysPage[j] = phys;
    467                 }
    468 
    469                 pReq->header.size = cbReq;
    470                 pReq->cPages = VMMDEV_MEMORY_BALLOON_CHUNK_PAGES;
    471                 pReq->fInflate = true;
    472 
    473                 rc = VbglGRPerform(&pReq->header);
     526                rc = vboxGuestBalloonInflate(pMemObj, pReq);
    474527                if (RT_FAILURE(rc))
    475528                {
    476                     Log(("vboxGuestSetBalloonSize(inflate): VbglGRPerform failed, rc=%Rrc!\n", rc));
     529                    Log(("vboxGuestSetBalloonSize(inflate): failed, rc=%Rrc!\n", rc));
    477530                    break;
    478531                }
    … …  
    482535        else
    483536        {
    484             /* deflate */
    485             for (j = 0; j < VMMDEV_MEMORY_BALLOON_CHUNK_PAGES; j++)
    486             {
    487                 RTHCPHYS phys = RTR0MemObjGetPagePhysAddr(*pMemObj, j);
    488                 pReq->aPhysPage[j] = phys;
    489             }
    490 
    491             pReq->header.size = cbReq;
    492             pReq->cPages = VMMDEV_MEMORY_BALLOON_CHUNK_PAGES;
    493             pReq->fInflate = false;
    494 
    495             rc = VbglGRPerform(&pReq->header);
     537            rc = vboxGuestBalloonDeflate(pMemObj, pReq);
    496538            if (RT_FAILURE(rc))
    497539            {
    498                 Log(("vboxGuestSetBalloonSize(deflate): VbglGRPerform failed, rc=%Rrc!\n", rc));
     540                Log(("vboxGuestSetBalloonSize(deflate): failed, rc=%Rrc!\n", rc));
    499541                break;
    500542            }
    501 
    502             rc = RTR0MemObjFree(*pMemObj, true);
    503             if (RT_FAILURE(rc))
    504             {
    505                 Log(("vboxGuestSetBalloonSize(deflate): RTR0MemObjFree() failed, rc=%Rrc!\n", rc));
    506                 break;
    507             }
    508             *pMemObj = NIL_RTR0MEMOBJ;
    509543            pSession->MemBalloon.cChunks--;
    510544        }
    … …  
    517551
    518552/**
     553 * Cleanup the memory balloon of a session.
     554 */
     555static void vboxGuestCloseSessionMemBalloon(PVBOXGUESTSESSION pSession)
     556{
     557    if (pSession->MemBalloon.paMemObj)
     558    {
     559        VMMDevChangeMemBalloon *pReq;
     560        int rc = VbglGRAlloc((VMMDevRequestHeader **)&pReq, cbChangeMemBalloonReq, VMMDevReq_ChangeMemBalloon);
     561        if (RT_SUCCESS(rc))
     562        {
     563            uint32_t i;
     564            for (i = pSession->MemBalloon.cChunks; i-- > 0;)
     565            {
     566                rc = vboxGuestBalloonDeflate(&pSession->MemBalloon.paMemObj[i], pReq);
     567                if (RT_FAILURE(rc))
     568                {
     569                    Log(("vboxGuestSetBalloonSize(deflate): failed, rc=%Rrc!\n", rc));
     570                    break;
     571                }
     572                pSession->MemBalloon.paMemObj[i] = NIL_RTR0MEMOBJ;
     573                pSession->MemBalloon.cChunks--;
     574            }
     575            VbglGRFree(&pReq->header);
     576        }
     577        RTMemFree(pSession->MemBalloon.paMemObj);
     578        pSession->MemBalloon.paMemObj = NULL;
     579    }
     580}
     581
     582
     583/**
    519584 * Init the variables for memory ballooning
    520585 *
    … …  
    525590    pDevExt->MemBalloon.cChunks = 0;
    526591    pDevExt->MemBalloon.cMaxChunks = 0;
    527 //#ifdef RT_OS_LINUX
    528 //    pDevExt->MemBalloon.fUseKernelAPI = true;
    529 //#else
     592#ifdef RT_OS_LINUX
     593    pDevExt->MemBalloon.fUseKernelAPI = true;
     594#else
    530595    pDevExt->MemBalloon.fUseKernelAPI = false;
    531 //#endif
     596#endif
    532597    pDevExt->MemBalloon.paMemObj = NULL;
    533598}
    … …  
    775840int VBoxGuestCreateUserSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession)
    776841{
    777     unsigned i;
    778842    PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)RTMemAllocZ(sizeof(*pSession));
    779843    if (RT_UNLIKELY(!pSession))
    … …  
    856920    pSession->Process = NIL_RTPROCESS;
    857921    pSession->R0Process = NIL_RTR0PROCESS;
     922    vboxGuestCloseSessionMemBalloon(pSession);
    858923    RTMemFree(pSession);
    859924}
    … …  
    10471112    Log(("VBoxGuestCommonIOCtlFast: iFunction=%#x pDevExt=%p pSession=%p\n", iFunction, pDevExt, pSession));
    10481113
     1114    NOREF(iFunction);
     1115    NOREF(pDevExt);
     1116    NOREF(pSession);
    10491117    return VERR_NOT_SUPPORTED;
    10501118}
    10511119
    10521120
    1053 
     1121/**
     1122 * Return the VMM device port.
     1123 *
     1124 * returns IPRT status code.
     1125 * @param   pDevExt         The device extension.
     1126 * @param   pInfo           The request info.
     1127 * @param   pcbDataReturned (out) contains the number of bytes to return.
     1128 */
    10541129static int VBoxGuestCommonIOCtl_GetVMMDevPort(PVBOXGUESTDEVEXT pDevExt, VBoxGuestPortInfo *pInfo, size_t *pcbDataReturned)
    10551130{
    … …  
    17461821 */
    17471822static int VBoxGuestCommonIOCtl_QueryMemoryBalloon(PVBOXGUESTDEVEXT pDevExt,
    1748                                                    uint32_t *memBalloonSize, size_t *pcbDataReturned)
     1823                                                   VBoxGuestCheckBalloonInfo *pInfo, size_t *pcbDataReturned)
    17491824{
    17501825    VMMDevGetMemBalloonChangeRequest *pReq;
    … …  
    17641839    }
    17651840
    1766     if (   pReq->u32BalloonSize != 0
    1767         && !pDevExt->MemBalloon.paMemObj)
    1768     {
    1769         pDevExt->MemBalloon.cMaxChunks = pReq->u32PhysMemSize;
    1770         pDevExt->MemBalloon.paMemObj = (RTR0MEMOBJ*)RTMemAllocZ(sizeof(RTR0MEMOBJ) * pReq->u32PhysMemSize);
    1771     }
    1772 
    1773     rc = vboxGuestSetBalloonSizeKernel(pDevExt, pReq->u32BalloonSize);
    1774     /* ignore out of memory failures */
     1841    pDevExt->MemBalloon.cMaxChunks = pReq->cPhysMemChunks;
     1842
     1843    rc = vboxGuestSetBalloonSizeKernel(pDevExt, pReq->cBalloonChunks);
     1844    /* Ignore out of memory failures */
    17751845    if (rc == VERR_NO_MEMORY)
    17761846        rc = VINF_SUCCESS;
    17771847
    1778     /* Balloon size in MB */
    1779     *memBalloonSize = pReq->u32BalloonSize;
     1848    /* Return values */
     1849    pInfo->cBalloonChunks = pReq->cBalloonChunks;
     1850    pInfo->fHandleInR3 = false;
     1851    if (rc == VERR_NO_PHYS_MEMORY)
     1852    {
     1853        pInfo->fHandleInR3 = true;
     1854        rc = VINF_SUCCESS;
     1855    }
     1856
    17801857    if (pcbDataReturned)
    1781         *pcbDataReturned = sizeof(*memBalloonSize);
     1858        *pcbDataReturned = sizeof(VBoxGuestCheckBalloonInfo);
    17821859
    17831860    return rc;
    … …  
    18091886static int VBoxGuestCommonIOCtl_Log(const char *pch, size_t cbData, size_t *pcbDataReturned)
    18101887{
     1888    NOREF(pch);
     1889    NOREF(cbData);
    18111890    Log(("%.*s", cbData, pch));
    18121891    if (pcbDataReturned)
    … …  
    19772056
    19782057            case VBOXGUEST_IOCTL_CHECK_BALLOON:
    1979                 CHECKRET_MIN_SIZE("CHECK_MEMORY_BALLOON", sizeof(uint32_t));
    1980                 rc = VBoxGuestCommonIOCtl_QueryMemoryBalloon(pDevExt, (uint32_t *)pvData, pcbDataReturned);
     2058                CHECKRET_MIN_SIZE("CHECK_MEMORY_BALLOON", sizeof(VBoxGuestCheckBalloonInfo));
     2059                rc = VBoxGuestCommonIOCtl_QueryMemoryBalloon(pDevExt, (VBoxGuestCheckBalloonInfo *)pvData, pcbDataReturned);
    19812060                break;
    19822061
Note: See TracChangeset for help on using the changeset viewer.

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