VirtualBox

Changeset 11131 in vbox for trunk/src/VBox/Frontends


Ignore:
Timestamp:
Aug 5, 2008 11:29:58 AM (16 years ago)
Author:
vboxsync
Message:

Improve error handling/diagnostics for raw disk vmdk creation.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

    r11066 r11131  
    744744    bool fRelative = false;
    745745
     746    uint64_t cbSize = 0;
     747    PVBOXHDD pDisk = NULL;
     748    VBOXHDDRAW RawDescriptor;
     749    HOSTPARTITIONS partitions;
     750    uint32_t uPartitions = 0;
     751
    746752    /* let's have a closer look at the arguments */
    747753    for (int i = 0; i < argc; i++)
     
    810816    if (VBOX_FAILURE(vrc))
    811817    {
    812         RTPrintf("Error opening the raw disk: %Vrc\n", vrc);
    813         return vrc;
    814     }
    815 
    816     uint64_t cbSize = 0;
     818        RTPrintf("Error opening the raw disk '%s': %Vrc\n", rawdisk.raw(), vrc);
     819        goto out;
     820    }
     821
    817822#ifdef RT_OS_WINDOWS
    818823    /* Windows NT has no IOCTL_DISK_GET_LENGTH_INFORMATION ioctl. This was
     
    838843        }
    839844        else
    840             return VERR_MEDIA_NOT_RECOGNIZED;
     845        {
     846            RTPrintf("File '%s' is no fixed medium device\n", rawdisk.raw());
     847            vrc = VERR_INVALID_PARAMETER;
     848            goto out;
     849        }
    841850
    842851        GET_LENGTH_INFORMATION DiskLenInfo;
     
    851860    }
    852861    else
    853         rc = RTErrConvertFromWin32(GetLastError());
     862    {
     863        vrc = RTErrConvertFromWin32(GetLastError());
     864        RTPrintf("Error getting the geometry of the raw disk '%s': %Vrc\n", rawdisk.raw(), vrc);
     865        goto out;
     866    }
    854867#elif defined(RT_OS_LINUX)
    855868    struct stat DevStat;
     
    875888                cbSize = (uint64_t)cBlocks << 9;
    876889            else
    877                 return RTErrConvertFromErrno(errno);
     890            {
     891                vrc = RTErrConvertFromErrno(errno);
     892                RTPrintf("Error getting the size of the raw disk '%s': %Vrc\n", rawdisk.raw(), vrc);
     893                goto out;
     894            }
    878895        }
    879896    }
     
    881898    {
    882899        RTPrintf("File '%s' is no block device\n", rawdisk.raw());
    883         return VERR_INVALID_PARAMETER;
     900        vrc = VERR_INVALID_PARAMETER;
     901        goto out;
    884902    }
    885903#elif defined(RT_OS_DARWIN)
     
    894912                cbSize = cBlocks * cbBlock;
    895913            else
    896                 return RTErrConvertFromErrno(errno);
     914            {
     915                RTPrintf("Cannot get the block size for file '%s': %Vrc", rawdisk.raw(), vrc);
     916                vrc = RTErrConvertFromErrno(errno);
     917                goto out;
     918            }
    897919        }
    898920        else
    899             return RTErrConvertFromErrno(errno);
     921        {
     922            vrc = RTErrConvertFromErrno(errno);
     923            RTPrintf("Cannot get the block count for file '%s': %Vrc", rawdisk.raw(), vrc);
     924            goto out;
     925        }
    900926    }
    901927    else
    902928    {
    903929        RTPrintf("File '%s' is no block device\n", rawdisk.raw());
    904         return VERR_INVALID_PARAMETER;
     930        vrc = VERR_INVALID_PARAMETER;
     931        goto out;
    905932    }
    906933#elif defined(RT_OS_SOLARIS)
     
    913940            cbSize = mediainfo.dki_capacity * mediainfo.dki_lbsize;
    914941        else
    915             return RTErrConvertFromErrno(errno);
     942        {
     943            vrc = RTErrConvertFromErrno(errno);
     944            RTPrintf("Error getting the size of the raw disk '%s': %Vrc\n", rawdisk.raw(), vrc);
     945            goto out;
     946        }
    916947    }
    917948    else
    918949    {
    919950        RTPrintf("File '%s' is no block or char device\n", rawdisk.raw());
    920         return VERR_INVALID_PARAMETER;
     951        vrc = VERR_INVALID_PARAMETER;
     952        goto out;
    921953    }
    922954#else /* all unrecognized OSes */
     
    926958    if (VBOX_FAILURE(vrc))
    927959    {
    928         RTPrintf("Error getting the size of the raw disk: %Vrc\n", vrc);
    929         return vrc;
     960        RTPrintf("Error getting the size of the raw disk '%s': %Vrc\n", rawdisk.raw(), vrc);
     961        goto out;
    930962    }
    931963#endif
     
    935967    {
    936968        RTPrintf("Detected size of raw disk '%s' is %s, an invalid value\n", rawdisk.raw(), cbSize);
    937         return VERR_INVALID_PARAMETER;
    938     }
    939 
    940     PVBOXHDD pDisk = NULL;
    941     VBOXHDDRAW RawDescriptor;
    942     HOSTPARTITIONS partitions;
    943     uint32_t uPartitions = 0;
     969        vrc = VERR_INVALID_PARAMETER;
     970        goto out;
     971    }
    944972
    945973    RawDescriptor.szSignature[0] = 'R';
     
    967995            {
    968996                RTPrintf("Incorrect value in partitions parameter\n");
    969                 return vrc;
     997                goto out;
    970998            }
    971999            uPartitions |= RT_BIT(u32);
     
    9761004            {
    9771005                RTPrintf("Incorrect separator in partitions parameter\n");
    978                 return VERR_INVALID_PARAMETER;
     1006                vrc = VERR_INVALID_PARAMETER;
     1007                goto out;
    9791008            }
    9801009        }
     
    9841013        {
    9851014            RTPrintf("Error reading the partition information from '%s'\n", rawdisk.raw());
    986             return vrc;
     1015            goto out;
    9871016        }
    9881017
     
    10061035        RawDescriptor.pPartitions = (PVBOXHDDRAWPART)RTMemAllocZ(partitions.cPartitions * sizeof(VBOXHDDRAWPART));
    10071036        if (!RawDescriptor.pPartitions)
    1008             return VERR_NO_MEMORY;
     1037        {
     1038            RTPrintf("Out of memory allocating the partition list for '%s'\n", rawdisk.raw());
     1039            vrc = VERR_NO_MEMORY;
     1040            goto out;
     1041        }
    10091042        for (unsigned i = 0; i < partitions.cPartitions; i++)
    10101043        {
     
    10221055                        RTPrintf("Error creating reference to individual partition %u, rc=%Vrc\n",
    10231056                                 partitions.aPartitions[i].uIndex, vrc);
    1024                         return vrc;
     1057                        goto out;
    10251058                    }
    10261059                    RawDescriptor.pPartitions[i].pszRawDevice = pszRawName;
     
    10731106                void *pPartData = RTMemAlloc((size_t)RawDescriptor.pPartitions[i].cbPartitionData);
    10741107                if (!pPartData)
    1075                     return VERR_NO_MEMORY;
     1108                {
     1109                    RTPrintf("Out of memory allocating the partition descriptor for '%s'\n", rawdisk.raw());
     1110                    vrc = VERR_NO_MEMORY;
     1111                    goto out;
     1112                }
    10761113                vrc = RTFileReadAt(RawFile, partitions.aPartitions[i].uPartDataStart * 512, pPartData, (size_t)RawDescriptor.pPartitions[i].cbPartitionData, NULL);
    10771114                if (VBOX_FAILURE(vrc))
    10781115                {
    10791116                    RTPrintf("Cannot read partition data from raw device '%s': %Vrc\n", rawdisk.raw(), vrc);
    1080                     return vrc;
     1117                    goto out;
    10811118                }
    10821119                /* Splice in the replacement MBR code if specified. */
     
    10891126                    {
    10901127                        RTPrintf("Cannot open replacement MBR file '%s' specified with -mbr: %Vrc\n", pszMBRFilename, vrc);
    1091                         return vrc;
     1128                        goto out;
    10921129                    }
    10931130                    vrc = RTFileReadAt(MBRFile, 0, pPartData, 0x1be, NULL);
     
    10961133                    {
    10971134                        RTPrintf("Cannot read replacement MBR file '%s': %Vrc\n", pszMBRFilename, vrc);
    1098                         return vrc;
     1135                        goto out;
    10991136                    }
    11001137                }
     
    11201157    {
    11211158        RTPrintf("Error while creating the virtual disk container: %Vrc\n", vrc);
    1122         return vrc;
     1159        goto out;
    11231160    }
    11241161
     
    11391176    {
    11401177        RTPrintf("Error while creating the raw disk VMDK: %Vrc\n", vrc);
    1141         return vrc;
     1178        goto out;
    11421179    }
    11431180    RTPrintf("RAW host disk access VMDK file %s created successfully.\n", Utf8Str(filename).raw());
     
    11751212
    11761213    return SUCCEEDED(rc) ? 0 : 1;
     1214
     1215out:
     1216    RTPrintf("The raw disk vmdk file was not created\n");
     1217    return VBOX_SUCCESS(vrc) ? 0 : 1;
    11771218}
    11781219
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