VirtualBox

Ignore:
Timestamp:
Aug 11, 2010 1:35:59 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
64672
Message:

Main: combine IVirtualBox::openHardDisk(), openDVDImage(), openFloppyImage() into new IVirtualBox::openMedium(); add new IMedium::setImageUUIDs() method for a rare use case of the old openHardDisk(); optimize client code now that code is mostly the same

Location:
trunk/src/VBox/Frontends/VBoxManage
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

    r31542 r31568  
    14751475    {
    14761476        ComPtr<IMedium> hardDisk;
    1477         CHECK_ERROR(aVirtualBox, OpenHardDisk(filename, AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), hardDisk.asOutParam()));
     1477        CHECK_ERROR(aVirtualBox, OpenMedium(filename, DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam()));
    14781478    }
    14791479

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

    r31562 r31568  
    454454        {
    455455            unknown = true;
    456             rc = a->virtualBox->OpenHardDisk(Bstr(FilenameOrUuid), AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), hardDisk.asOutParam());
     456            rc = a->virtualBox->OpenMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam());
    457457            if (rc == VBOX_E_FILE_ERROR)
    458458            {
    … …  
    464464                    return 1;
    465465                }
    466                 CHECK_ERROR(a->virtualBox, OpenHardDisk(Bstr(szFilenameAbs), AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), hardDisk.asOutParam()));
     466                CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam()));
    467467            }
    468             else if (FAILED(rc))
    469                 CHECK_ERROR(a->virtualBox, OpenHardDisk(Bstr(FilenameOrUuid), AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), hardDisk.asOutParam()));
    470468        }
    471469        if (SUCCEEDED(rc) && hardDisk)
    … …  
    611609    if (FAILED (rc))
    612610    {
    613         rc = a->virtualBox->OpenHardDisk(src, AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), srcDisk.asOutParam());
     611        rc = a->virtualBox->OpenMedium(src, DeviceType_HardDisk, AccessMode_ReadWrite, srcDisk.asOutParam());
    614612        if (rc == VBOX_E_FILE_ERROR)
    615613        {
    … …  
    621619                return 1;
    622620            }
    623             CHECK_ERROR(a->virtualBox, OpenHardDisk(Bstr(szFilenameAbs), AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), srcDisk.asOutParam()));
    624         }
    625         else if (FAILED(rc))
    626             CHECK_ERROR(a->virtualBox, OpenHardDisk(src, AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), srcDisk.asOutParam()));
     621            CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, srcDisk.asOutParam()));
     622        }
    627623        if (SUCCEEDED (rc))
    628624            fSrcUnknown = true;
    … …  
    641637            if (FAILED (rc))
    642638            {
    643                 rc = a->virtualBox->OpenHardDisk(dst, AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), dstDisk.asOutParam());
     639                rc = a->virtualBox->OpenMedium(dst, DeviceType_HardDisk, AccessMode_ReadWrite, dstDisk.asOutParam());
    644640                if (rc == VBOX_E_FILE_ERROR)
    645641                {
    … …  
    651647                        return 1;
    652648                    }
    653                     CHECK_ERROR_BREAK(a->virtualBox, OpenHardDisk(Bstr(szFilenameAbs), AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), dstDisk.asOutParam()));
     649                    CHECK_ERROR_BREAK(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, dstDisk.asOutParam()));
    654650                }
    655                 else if (FAILED(rc))
    656                     CHECK_ERROR_BREAK(a->virtualBox, OpenHardDisk(dst, AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), dstDisk.asOutParam()));
    657651                if (SUCCEEDED (rc))
    658652                    fDstUnknown = true;
    … …  
    11411135    if (FAILED (rc))
    11421136    {
    1143         rc = a->virtualBox->OpenHardDisk(Bstr(FilenameOrUuid), AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), hardDisk.asOutParam());
     1137        rc = a->virtualBox->OpenMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam());
    11441138        if (rc == VBOX_E_FILE_ERROR)
    11451139        {
    … …  
    11511145                return 1;
    11521146            }
    1153             CHECK_ERROR(a->virtualBox, OpenHardDisk(Bstr(szFilenameAbs), AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), hardDisk.asOutParam()));
    1154         }
    1155         else if (FAILED(rc))
    1156             CHECK_ERROR(a->virtualBox, OpenHardDisk(Bstr(FilenameOrUuid), AccessMode_ReadWrite, false, Bstr(""), false, Bstr(""), hardDisk.asOutParam()));
     1147            CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam()));
     1148        }
    11571149        if (SUCCEEDED (rc))
    1158         {
    11591150            unknown = true;
    1160         }
    11611151    }
    11621152    do
    … …  
    12851275    HRESULT rc = S_OK;
    12861276    int vrc;
    1287     enum {
    1288         CMD_NONE,
    1289         CMD_DISK,
    1290         CMD_DVD,
    1291         CMD_FLOPPY
    1292     } cmd = CMD_NONE;
     1277    DeviceType_T devType = DeviceType_Null;
    12931278    const char *Filename = NULL;
    12941279    MediumType_T DiskType = MediumType_Normal;
    … …  
    13121297        {
    13131298            case 'd':   // disk
    1314                 if (cmd != CMD_NONE)
     1299                if (devType != DeviceType_Null)
    13151300                    return errorSyntax(USAGE_OPENMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
    1316                 cmd = CMD_DISK;
     1301                devType = DeviceType_HardDisk;
    13171302                break;
    13181303
    13191304            case 'D':   // DVD
    1320                 if (cmd != CMD_NONE)
     1305                if (devType != DeviceType_Null)
    13211306                    return errorSyntax(USAGE_OPENMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
    1322                 cmd = CMD_DVD;
     1307                devType = DeviceType_DVD;
    13231308                break;
    13241309
    13251310            case 'f':   // floppy
    1326                 if (cmd != CMD_NONE)
     1311                if (devType != DeviceType_Null)
    13271312                    return errorSyntax(USAGE_OPENMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
    1328                 cmd = CMD_FLOPPY;
     1313                devType = DeviceType_Floppy;
    13291314                break;
    13301315
    … …  
    13711356
    13721357    /* check for required options */
    1373     if (cmd == CMD_NONE)
     1358    if (devType == DeviceType_Null)
    13741359        return errorSyntax(USAGE_OPENMEDIUM, "Command variant disk/dvd/floppy required");
    13751360    if (!Filename)
    … …  
    13831368     * cases. This is an ugly hack and needs to be removed whevever we have a
    13841369     * chance to clean up the API semantics. */
    1385     if (cmd == CMD_DISK)
    1386     {
    1387         ComPtr<IMedium> hardDisk;
    1388         Bstr ImageIdStr = BstrFmt("%RTuuid", &ImageId);
    1389         Bstr ParentIdStr = BstrFmt("%RTuuid", &ParentId);
    1390         rc = a->virtualBox->OpenHardDisk(Bstr(Filename), AccessMode_ReadWrite, fSetImageId, ImageIdStr, fSetParentId, ParentIdStr, hardDisk.asOutParam());
    1391         if (rc == VBOX_E_FILE_ERROR)
    1392         {
    1393             char szFilenameAbs[RTPATH_MAX] = "";
    1394             int irc = RTPathAbs(Filename, szFilenameAbs, sizeof(szFilenameAbs));
    1395             if (RT_FAILURE(irc))
    1396             {
    1397                 RTPrintf("Cannot convert filename \"%s\" to absolute path\n", Filename);
    1398                 return 1;
    1399             }
    1400             CHECK_ERROR(a->virtualBox, OpenHardDisk(Bstr(szFilenameAbs), AccessMode_ReadWrite, fSetImageId, ImageIdStr, fSetParentId, ParentIdStr, hardDisk.asOutParam()));
    1401         }
    1402         else if (FAILED(rc))
    1403             CHECK_ERROR(a->virtualBox, OpenHardDisk(Bstr(Filename), AccessMode_ReadWrite, fSetImageId, ImageIdStr, fSetParentId, ParentIdStr, hardDisk.asOutParam()));
    1404         if (SUCCEEDED(rc) && hardDisk)
    1405         {
    1406             /* change the type if requested */
     1370
     1371    ComPtr<IMedium> pMedium;
     1372    rc = a->virtualBox->OpenMedium(Bstr(Filename), devType, AccessMode_ReadWrite, pMedium.asOutParam());
     1373    if (rc == VBOX_E_FILE_ERROR)
     1374    {
     1375        char szFilenameAbs[RTPATH_MAX] = "";
     1376        int irc = RTPathAbs(Filename, szFilenameAbs, sizeof(szFilenameAbs));
     1377        if (RT_FAILURE(irc))
     1378        {
     1379            RTPrintf("Cannot convert filename \"%s\" to absolute path\n", Filename);
     1380            return 1;
     1381        }
     1382        CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), devType, AccessMode_ReadWrite, pMedium.asOutParam()));
     1383    }
     1384    if (SUCCEEDED(rc) && pMedium)
     1385    {
     1386        if (devType == DeviceType_HardDisk)
     1387        {
    14071388            if (DiskType != MediumType_Normal)
    14081389            {
    1409                 CHECK_ERROR(hardDisk, COMSETTER(Type)(DiskType));
     1390                CHECK_ERROR(pMedium, COMSETTER(Type)(DiskType));
    14101391            }
    14111392        }
    1412     }
    1413     else if (cmd == CMD_DVD)
    1414     {
    1415         if (fDiskType || fSetParentId)
    1416             return errorSyntax(USAGE_OPENMEDIUM, "Invalid option for DVD images");
    1417         Bstr ImageIdStr = BstrFmt("%RTuuid", &ImageId);
    1418         ComPtr<IMedium> dvdImage;
    1419         rc = a->virtualBox->OpenDVDImage(Bstr(Filename), ImageIdStr, dvdImage.asOutParam());
    1420         if (rc == VBOX_E_FILE_ERROR)
    1421         {
    1422             char szFilenameAbs[RTPATH_MAX] = "";
    1423             int irc = RTPathAbs(Filename, szFilenameAbs, sizeof(szFilenameAbs));
    1424             if (RT_FAILURE(irc))
    1425             {
    1426                 RTPrintf("Cannot convert filename \"%s\" to absolute path\n", Filename);
    1427                 return 1;
    1428             }
    1429             CHECK_ERROR(a->virtualBox, OpenDVDImage(Bstr(szFilenameAbs), ImageIdStr, dvdImage.asOutParam()));
    1430         }
    1431         else if (FAILED(rc))
    1432             CHECK_ERROR(a->virtualBox, OpenDVDImage(Bstr(Filename), ImageIdStr, dvdImage.asOutParam()));
    1433     }
    1434     else if (cmd == CMD_FLOPPY)
    1435     {
    1436         if (fDiskType || fSetImageId || fSetParentId)
    1437             return errorSyntax(USAGE_OPENMEDIUM, "Invalid option for floppy images");
    1438         Bstr ImageIdStr = BstrFmt("%RTuuid", &ImageId);
    1439         ComPtr<IMedium> floppyImage;
    1440         rc = a->virtualBox->OpenFloppyImage(Bstr(Filename), ImageIdStr, floppyImage.asOutParam());
    1441         if (rc == VBOX_E_FILE_ERROR)
    1442         {
    1443             char szFilenameAbs[RTPATH_MAX] = "";
    1444             int irc = RTPathAbs(Filename, szFilenameAbs, sizeof(szFilenameAbs));
    1445             if (RT_FAILURE(irc))
    1446             {
    1447                 RTPrintf("Cannot convert filename \"%s\" to absolute path\n", Filename);
    1448                 return 1;
    1449             }
    1450             CHECK_ERROR(a->virtualBox, OpenFloppyImage(Bstr(szFilenameAbs), ImageIdStr, floppyImage.asOutParam()));
    1451         }
    1452         else if (FAILED(rc))
    1453             CHECK_ERROR(a->virtualBox, OpenFloppyImage(Bstr(Filename), ImageIdStr, floppyImage.asOutParam()));
     1393        else
     1394        {
     1395            // DVD or floppy image
     1396            if (fDiskType || fSetParentId)
     1397                return errorSyntax(USAGE_OPENMEDIUM, "Invalid option for DVD and floppy images");
     1398        }
     1399        if (fSetImageId || fSetParentId)
     1400        {
     1401            Bstr ImageIdStr = BstrFmt("%RTuuid", &ImageId);
     1402            Bstr ParentIdStr = BstrFmt("%RTuuid", &ParentId);
     1403            CHECK_ERROR(pMedium, SetIDs(fSetImageId, ImageIdStr, fSetParentId, ParentIdStr));
     1404        }
    14541405    }
    14551406

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

    r31562 r31568  
    613613
    614614            case MODIFYVM_HDA: // deprecated
    615             {
     615            case MODIFYVM_HDB: // deprecated
     616            case MODIFYVM_HDD: // deprecated
     617            case MODIFYVM_SATAPORT: // deprecated
     618            {
     619                uint32_t u1, u2 = 0;
     620                Bstr bstrController = L"IDE Controller";
     621
     622                switch (c)
     623                {
     624                    case MODIFYVM_HDA: // deprecated
     625                        u1 = 0;
     626                    break;
     627
     628                    case MODIFYVM_HDB: // deprecated
     629                        u1 = 0;
     630                        u2 = 1;
     631                    break;
     632
     633                    case MODIFYVM_HDD: // deprecated
     634                        u1 = 1;
     635                        u2 = 1;
     636                    break;
     637
     638                    case MODIFYVM_SATAPORT: // deprecated
     639                        u1 = GetOptState.uIndex;
     640                        bstrController = L"SATA";
     641                    break;
     642                }
     643
    616644                if (!strcmp(ValueUnion.psz, "none"))
    617645                {
    618                     machine->DetachDevice(Bstr("IDE Controller"), 0, 0);
     646                    machine->DetachDevice(bstrController, u1, u2);
    619647                }
    620648                else
    … …  
    626654                        /* open the new hard disk object */
    627655                        CHECK_ERROR(a->virtualBox,
    628                                     OpenHardDisk(Bstr(ValueUnion.psz),
    629                                                  AccessMode_ReadWrite, false, Bstr(""),
    630                                                  false, Bstr(""), hardDisk.asOutParam()));
     656                                    OpenMedium(Bstr(ValueUnion.psz),
     657                                               DeviceType_HardDisk,
     658                                               AccessMode_ReadWrite,
     659                                               hardDisk.asOutParam()));
    631660                    }
    632661                    if (hardDisk)
    … …  
    634663                        Bstr uuid;
    635664                        hardDisk->COMGETTER(Id)(uuid.asOutParam());
    636                         CHECK_ERROR(machine, AttachDevice(Bstr("IDE Controller"), 0, 0, DeviceType_HardDisk, uuid));
     665                        CHECK_ERROR(machine, AttachDevice(bstrController, u1, u2, DeviceType_HardDisk, uuid));
    637666                    }
    638667                    else
    … …  
    642671            }
    643672
    644             case MODIFYVM_HDB: // deprecated
    645             {
    646                 if (!strcmp(ValueUnion.psz, "none"))
    647                 {
    648                     machine->DetachDevice(Bstr("IDE Controller"), 0, 1);
    649                 }
    650                 else
    651                 {
    652                     ComPtr<IMedium> hardDisk;
    653                     rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz), DeviceType_HardDisk, hardDisk.asOutParam());
    654                     if (FAILED(rc))
    655                     {
    656                         /* open the new hard disk object */
    657                         CHECK_ERROR(a->virtualBox,
    658                                     OpenHardDisk(Bstr(ValueUnion.psz),
    659                                                  AccessMode_ReadWrite, false, Bstr(""),
    660                                                  false, Bstr(""), hardDisk.asOutParam()));
    661                     }
    662                     if (hardDisk)
    663                     {
    664                         Bstr uuid;
    665                         hardDisk->COMGETTER(Id)(uuid.asOutParam());
    666                         CHECK_ERROR(machine, AttachDevice(Bstr("IDE Controller"), 0, 1, DeviceType_HardDisk, uuid));
    667                     }
    668                     else
    669                         rc = E_FAIL;
    670                 }
    671                 break;
    672             }
    673 
    674             case MODIFYVM_HDD: // deprecated
    675             {
    676                 if (!strcmp(ValueUnion.psz, "none"))
    677                 {
    678                     machine->DetachDevice(Bstr("IDE Controller"), 1, 1);
    679                 }
    680                 else
    681                 {
    682                     ComPtr<IMedium> hardDisk;
    683                     rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz), DeviceType_HardDisk, hardDisk.asOutParam());
    684                     if (FAILED(rc))
    685                     {
    686                         /* open the new hard disk object */
    687                         CHECK_ERROR(a->virtualBox,
    688                                     OpenHardDisk(Bstr(ValueUnion.psz),
    689                                                  AccessMode_ReadWrite, false, Bstr(""),
    690                                                  false, Bstr(""), hardDisk.asOutParam()));
    691                     }
    692                     if (hardDisk)
    693                     {
    694                         Bstr uuid;
    695                         hardDisk->COMGETTER(Id)(uuid.asOutParam());
    696                         CHECK_ERROR(machine, AttachDevice(Bstr("IDE Controller"), 1, 1, DeviceType_HardDisk, uuid));
    697                     }
    698                     else
    699                         rc = E_FAIL;
    700                 }
    701                 break;
    702             }
    703 
    704673            case MODIFYVM_IDECONTROLLER: // deprecated
    705674            {
    … …  
    745714                if (SUCCEEDED(rc) && ValueUnion.u32 > 0)
    746715                    CHECK_ERROR(SataCtl, COMSETTER(PortCount)(ValueUnion.u32));
    747                 break;
    748             }
    749 
    750             case MODIFYVM_SATAPORT: // deprecated
    751             {
    752                 if (!strcmp(ValueUnion.psz, "none"))
    753                 {
    754                     machine->DetachDevice(Bstr("SATA"), GetOptState.uIndex, 0);
    755                 }
    756                 else
    757                 {
    758                     /* first guess is that it's a UUID */
    759                     ComPtr<IMedium> hardDisk;
    760                     rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz), DeviceType_HardDisk, hardDisk.asOutParam());
    761                     if (FAILED(rc))
    762                     {
    763                         /* open the new hard disk object */
    764                         CHECK_ERROR(a->virtualBox,
    765                                     OpenHardDisk(Bstr(ValueUnion.psz), AccessMode_ReadWrite,
    766                                                  false, Bstr(""), false,
    767                                                  Bstr(""), hardDisk.asOutParam()));
    768                     }
    769                     if (hardDisk)
    770                     {
    771                         Bstr uuid;
    772                         hardDisk->COMGETTER(Id)(uuid.asOutParam());
    773                         CHECK_ERROR(machine,
    774                                     AttachDevice(Bstr("SATA"), GetOptState.uIndex,
    775                                                  0, DeviceType_HardDisk, uuid));
    776                     }
    777                     else
    778                         rc = E_FAIL;
    779                 }
    780716                break;
    781717            }
    … …  
    814750                        /* open the new hard disk object */
    815751                        CHECK_ERROR(a->virtualBox,
    816                                      OpenHardDisk(Bstr(ValueUnion.psz),
    817                                                        AccessMode_ReadWrite, false, Bstr(""),
    818                                                        false, Bstr(""), hardDisk.asOutParam()));
     752                                    OpenMedium(Bstr(ValueUnion.psz),
     753                                               DeviceType_HardDisk,
     754                                               AccessMode_ReadWrite,
     755                                               hardDisk.asOutParam()));
    819756                    }
    820757                    if (hardDisk)
    … …  
    940877                        /* not registered, do that on the fly */
    941878                        Bstr emptyUUID;
    942                         CHECK_ERROR(a->virtualBox, OpenDVDImage(Bstr(ValueUnion.psz),
    943                                      emptyUUID, dvdMedium.asOutParam()));
     879                        CHECK_ERROR(a->virtualBox,
     880                                    OpenMedium(Bstr(ValueUnion.psz),
     881                                               DeviceType_DVD,
     882                                               AccessMode_ReadWrite,
     883                                               dvdMedium.asOutParam()));
    944884                    }
    945885                    if (!dvdMedium)
    … …  
    1007947                            Bstr emptyUUID;
    1008948                            CHECK_ERROR(a->virtualBox,
    1009                                          OpenFloppyImage(Bstr(ValueUnion.psz),
    1010                                                          emptyUUID,
    1011                                                          floppyMedium.asOutParam()));
     949                                        OpenMedium(Bstr(ValueUnion.psz),
     950                                                   DeviceType_Floppy,
     951                                                   AccessMode_ReadWrite,
     952                                                   floppyMedium.asOutParam()));
    1012953                        }
    1013954                        if (!floppyMedium)

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageStorageController.cpp

    r31562 r31568  
    455455                        /* not registered, do that on the fly */
    456456                        Bstr emptyUUID;
    457                         CHECK_ERROR(a->virtualBox, OpenDVDImage(Bstr(pszMedium),
    458                                      emptyUUID, dvdMedium.asOutParam()));
     457                        CHECK_ERROR(a->virtualBox,
     458                                    OpenMedium(Bstr(pszMedium),
     459                                               DeviceType_DVD,
     460                                               AccessMode_ReadWrite,
     461                                               dvdMedium.asOutParam()));
    459462                    }
    460463                    if (!dvdMedium)
    … …  
    490493                /* open the new hard disk object */
    491494                CHECK_ERROR(a->virtualBox,
    492                              OpenHardDisk(Bstr(pszMedium),
    493                                           AccessMode_ReadWrite, false, Bstr(""),
    494                                           false, Bstr(""), hardDisk.asOutParam()));
     495                            OpenMedium(Bstr(pszMedium),
     496                                       DeviceType_HardDisk,
     497                                       AccessMode_ReadWrite,
     498                                       hardDisk.asOutParam()));
    495499            }
    496500
    … …  
    540544                    Bstr emptyUUID;
    541545                    CHECK_ERROR(a->virtualBox,
    542                                  OpenFloppyImage(Bstr(pszMedium),
    543                                                  emptyUUID,
    544                                                  floppyMedium.asOutParam()));
     546                                 OpenMedium(Bstr(pszMedium),
     547                                            DeviceType_Floppy,
     548                                            AccessMode_ReadWrite,
     549                                            floppyMedium.asOutParam()));
    545550                }
    546551
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