VirtualBox

Ticket #11049: vboxmanage_gpt.patch

File vboxmanage_gpt.patch, 11.2 KB (added by Mihai Hanor, 10 years ago)
  • src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

    old new  
    769769        partitioningType = GPT;
    770770        pPart->uPartitioningType = GPT;//partitioningType;
    771771
    772772        if (aBuffer[510] != 0x55 || aBuffer[511] != 0xaa)
    773773            return VERR_INVALID_PARAMETER;
    774774
    775775        rc = RTFileReadAt(File, sector_size, &partitionTableHeader, sector_size, NULL);
    776         if (RT_SUCCESS(rc))
     776
     777        if (RT_FAILURE(rc))
     778            return rc;
     779
     780        const char* l_ppth = (char*)partitionTableHeader;
     781        rc = strncmp(l_ppth, "EFI PART", 8);
     782        if (RT_FAILURE(rc))
     783            return VERR_INVALID_PARAMETER;
     784
     785        /** @todo check GPT Version */
     786
     787        uint64_t firstUsableLBA = RT_MAKE_U64_FROM_U8(partitionTableHeader[40],
     788                                                      partitionTableHeader[41],
     789                                                      partitionTableHeader[42],
     790                                                      partitionTableHeader[43],
     791                                                      partitionTableHeader[44],
     792                                                      partitionTableHeader[45],
     793                                                      partitionTableHeader[46],
     794                                                      partitionTableHeader[47]
     795                                                      );
     796        lastUsableLBA = RT_MAKE_U64_FROM_U8( partitionTableHeader[48],
     797                                                      partitionTableHeader[49],
     798                                                      partitionTableHeader[50],
     799                                                      partitionTableHeader[51],
     800                                                      partitionTableHeader[52],
     801                                                      partitionTableHeader[53],
     802                                                      partitionTableHeader[54],
     803                                                      partitionTableHeader[55]
     804                                                      );
     805        uint32_t partitionsNumber = RT_MAKE_U32_FROM_U8( partitionTableHeader[80],
     806                                                      partitionTableHeader[81],
     807                                                      partitionTableHeader[82],
     808                                                      partitionTableHeader[83]
     809                                                      );
     810        uint32_t partitionEntrySize = RT_MAKE_U32_FROM_U8( partitionTableHeader[84],
     811                                                      partitionTableHeader[85],
     812                                                      partitionTableHeader[86],
     813                                                      partitionTableHeader[87]
     814                                                      );
     815
     816        uint32_t currentEntry = 0;
     817        /* we must read multiple of sector size bytes; maybe we should use aBuffer[] */
     818        uint8_t aBuffer2[512];
     819        /* partition entries begin from LBA2 */
     820        uint64_t disk_offset_last = -1;
     821        while (currentEntry < partitionsNumber)
    777822        {
    778             const char* l_ppth = (char*)partitionTableHeader;
    779             rc = strncmp(l_ppth, "EFI PART", 8);
    780             if (RT_FAILURE(rc))
    781                 return VERR_INVALID_PARAMETER;
    782 
    783             /** @todo check GPT Version */
    784 
    785             uint64_t firstUsableLBA = RT_MAKE_U64_FROM_U8(partitionTableHeader[40],
    786                                                           partitionTableHeader[41],
    787                                                           partitionTableHeader[42],
    788                                                           partitionTableHeader[43],
    789                                                           partitionTableHeader[44],
    790                                                           partitionTableHeader[45],
    791                                                           partitionTableHeader[46],
    792                                                           partitionTableHeader[47]
    793                                                           );
    794             lastUsableLBA = RT_MAKE_U64_FROM_U8( partitionTableHeader[48],
    795                                                           partitionTableHeader[49],
    796                                                           partitionTableHeader[50],
    797                                                           partitionTableHeader[51],
    798                                                           partitionTableHeader[52],
    799                                                           partitionTableHeader[53],
    800                                                           partitionTableHeader[54],
    801                                                           partitionTableHeader[55]
    802                                                           );
    803             uint32_t partitionsNumber = RT_MAKE_U32_FROM_U8( partitionTableHeader[80],
    804                                                           partitionTableHeader[81],
    805                                                           partitionTableHeader[82],
    806                                                           partitionTableHeader[83]
    807                                                           );
    808             uint32_t partitionEntrySize = RT_MAKE_U32_FROM_U8( partitionTableHeader[84],
    809                                                           partitionTableHeader[85],
    810                                                           partitionTableHeader[86],
    811                                                           partitionTableHeader[87]
    812                                                           );
     823            uint64_t partitionEntry_offset = 1024 + currentEntry * partitionEntrySize;
     824            uint64_t disk_offset = (partitionEntry_offset / sector_size) * sector_size;
     825            uint64_t buffer_offset = partitionEntry_offset % sector_size;
    813826
    814             uint32_t currentEntry = 0;
    815             while(currentEntry<partitionsNumber)
     827            if (disk_offset_last == -1 || disk_offset != disk_offset_last)
    816828            {
    817                 uint8_t partitionEntry[128];
     829                rc = RTFileReadAt(File, disk_offset, &aBuffer2, sector_size, NULL);
    818830
    819                 /*partition entries begin from LBA2*/
    820                 rc = RTFileReadAt(File, 1024 + currentEntry*partitionEntrySize, &partitionEntry, partitionEntrySize, NULL);
     831                if (RT_FAILURE(rc))
     832                    return rc;
    821833
    822                 uint64_t start = RT_MAKE_U64_FROM_U8( partitionEntry[32],
    823                                                           partitionEntry[33],
    824                                                           partitionEntry[34],
    825                                                           partitionEntry[35],
    826                                                           partitionEntry[36],
    827                                                           partitionEntry[37],
    828                                                           partitionEntry[38],
    829                                                           partitionEntry[39]
    830                                                           );
    831                 uint64_t end = RT_MAKE_U64_FROM_U8( partitionEntry[40],
    832                                                           partitionEntry[41],
    833                                                           partitionEntry[42],
    834                                                           partitionEntry[43],
    835                                                           partitionEntry[44],
    836                                                           partitionEntry[45],
    837                                                           partitionEntry[46],
    838                                                           partitionEntry[47]
    839                                                           );
    840 
    841                 PHOSTPARTITION pCP = &pPart->aPartitions[pPart->cPartitions++];
    842                 pCP->uIndex = currentEntry + 1;
    843                 pCP->uType = 0;
    844                 pCP->uStartCylinder = 0;
    845                 pCP->uStartHead = 0;
    846                 pCP->uStartSector = 0;
    847                 pCP->uEndCylinder = 0;
    848                 pCP->uEndHead = 0;
    849                 pCP->uEndSector = 0;
    850                 pCP->uPartDataStart = 0;    /* will be filled out later properly. */
    851                 pCP->cPartDataSectors = 0;
    852                 if (start==0 || end==0)
    853                 {
    854                     pCP->uIndex = 0;
    855                     --pPart->cPartitions;
    856                     break;
    857                 }
    858                 else
    859                 {
    860                     pCP->uStart = start;
    861                     pCP->uSize = (end +1) - start;/*+1 LBA because the last address is included*/
    862                 }
     834                disk_offset_last = disk_offset;
     835            }
     836           
     837            uint8_t *pBuffer = aBuffer2 + buffer_offset;
    863838
    864                 ++currentEntry;
     839            uint64_t start = RT_MAKE_U64_FROM_U8( pBuffer[32],
     840                                                  pBuffer[33],
     841                                                  pBuffer[34],
     842                                                  pBuffer[35],
     843                                                  pBuffer[36],
     844                                                  pBuffer[37],
     845                                                  pBuffer[38],
     846                                                  pBuffer[39]
     847                                                  );
     848            uint64_t end = RT_MAKE_U64_FROM_U8( pBuffer[40],
     849                                                  pBuffer[41],
     850                                                  pBuffer[42],
     851                                                  pBuffer[43],
     852                                                  pBuffer[44],
     853                                                  pBuffer[45],
     854                                                  pBuffer[46],
     855                                                  pBuffer[47]
     856                                                  );
     857
     858            PHOSTPARTITION pCP = &pPart->aPartitions[pPart->cPartitions++];
     859            pCP->uIndex = currentEntry + 1;
     860            pCP->uType = 0;
     861            pCP->uStartCylinder = 0;
     862            pCP->uStartHead = 0;
     863            pCP->uStartSector = 0;
     864            pCP->uEndCylinder = 0;
     865            pCP->uEndHead = 0;
     866            pCP->uEndSector = 0;
     867            pCP->uPartDataStart = 0;    /* will be filled out later properly. */
     868            pCP->cPartDataSectors = 0;
     869            if (start==0 || end==0)
     870            {
     871                pCP->uIndex = 0;
     872                --pPart->cPartitions;
     873                break;
    865874            }
     875            else
     876            {
     877                pCP->uStart = start;
     878                pCP->uSize = (end +1) - start; /* +1 LBA because the last address is included */
     879            }
     880
     881            ++currentEntry;
    866882        }
    867883    }
    868884    else
    869885    {
    870886        partitioningType = MBR;
    871887        pPart->uPartitioningType = MBR;//partitioningType;
    872888

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy