static int
dvh_alloc_metadata (PedDisk* disk)
{
PedPartition* part;
PedPartition* extended_part;
PedPartitionType metadata_type;
PED_ASSERT(disk != NULL);
/* We don't need to "protect" the start of the disk from the volume
* header.
*/
extended_part = ped_disk_extended_partition (disk);
if (extended_part && extended_part->geom.start == 0)
metadata_type = PED_PARTITION_METADATA | PED_PARTITION_LOGICAL;
else
metadata_type = PED_PARTITION_METADATA;
part = ped_partition_new (disk, metadata_type, NULL, 0, 0);
if (!part)
goto error;
PedConstraint *constraint_exact
= ped_constraint_exact (&part->geom);
bool ok = ped_disk_add_partition (disk, part, constraint_exact);
ped_constraint_destroy (constraint_exact);
if (ok)
return 1;
ped_partition_destroy (part);
error:
return 0;
}
bool LibPartedPartitionTable::updateGeometry(Report& report, const Partition& partition, qint64 sector_start, qint64 sector_end)
{
Q_ASSERT(partition.devicePath() == QString::fromUtf8(pedDevice()->path));
bool rval = false;
PedPartition* pedPartition = (partition.roles().has(PartitionRole::Extended))
? ped_disk_extended_partition(pedDisk())
: ped_disk_get_partition_by_sector(pedDisk(), partition.firstSector());
if (pedPartition) {
if (PedGeometry* pedGeometry = ped_geometry_new(pedDevice(), sector_start, sector_end - sector_start + 1)) {
if (PedConstraint* pedConstraint = ped_constraint_exact(pedGeometry)) {
if (ped_disk_set_partition_geom(pedDisk(), pedPartition, pedConstraint, sector_start, sector_end))
rval = true;
else
report.line() << xi18nc("@info:progress", "Could not set geometry for partition <filename>%1</filename> while trying to resize/move it.", partition.deviceNode());
ped_constraint_destroy(pedConstraint);
} else
report.line() << xi18nc("@info:progress", "Could not get constraint for partition <filename>%1</filename> while trying to resize/move it.", partition.deviceNode());
ped_geometry_destroy(pedGeometry);
} else
report.line() << xi18nc("@info:progress", "Could not get geometry for partition <filename>%1</filename> while trying to resize/move it.", partition.deviceNode());
} else
report.line() << xi18nc("@info:progress", "Could not open partition <filename>%1</filename> while trying to resize/move it.", partition.deviceNode());
return rval;
}
bool MParted::MParted_Core::calibratePartition(MParted::Partition & partition) {
if (partition.type != MParted::TYPE_PRIMARY && partition.type != MParted::TYPE_LOGICAL && partition.type != MParted::TYPE_EXTENDED)
return true; //nothing to calibrate...
bool success = false;
PedPartition *pedPartition = NULL;
if (openDeviceAndDisk(partition.devicePath)) {
if (partition.type == MParted::TYPE_EXTENDED)
pedPartition = ped_disk_extended_partition(pedDisk);
else
pedPartition = ped_disk_get_partition_by_sector(pedDisk, partition.getSector());
// Check to see if pedPartition->type matches partition.type
if (pedPartition && ((pedPartition->type == PED_PARTITION_NORMAL && partition.type == MParted::TYPE_PRIMARY)
|| (pedPartition->type == PED_PARTITION_LOGICAL && partition.type == MParted::TYPE_LOGICAL)
|| (pedPartition->type == PED_PARTITION_EXTENDED && partition.type == MParted::TYPE_EXTENDED)))
{
// Get partition path
partition.path = Utils::charToStringFree(ped_partition_get_path(pedPartition)); // we have to free the result of ped_partition_get_path()
partition.sector_start = pedPartition->geom.start;
partition.sector_end = pedPartition->geom.end;
if (!partition.path.isEmpty())
success = true;
}
closeDeviceAndDisk();
}
return success;
}
static int
_can_create_logical (const PedDisk* disk)
{
if (!ped_disk_type_check_feature (disk->type, PED_DISK_TYPE_EXTENDED))
return 0;
return ped_disk_extended_partition (disk) != 0;
}
CoreBackendPartition* LibPartedPartitionTable::getExtendedPartition()
{
PedPartition* pedPartition = ped_disk_extended_partition(pedDisk());
if (pedPartition == nullptr)
return nullptr;
return new LibPartedPartition(pedPartition);
}
bool MParted::MParted_Core::resizePartition(MParted::Partition & partition_old, MParted::Partition & partition_new) {
if (partition_new.getSectorLength() == partition_old.getSectorLength()
&& partition_new.sector_start == partition_old.sector_start)
return true; // New and old partition have the same size and position. Hence skipping this operation
bool return_value = false;
PedConstraint *constraint = NULL;
PedPartition *pedPartition = NULL;
if (!openDeviceAndDisk(partition_old.devicePath))
return false;
if (partition_old.type == MParted::TYPE_EXTENDED)
pedPartition = ped_disk_extended_partition(pedDisk);
else
pedPartition = ped_disk_get_partition_by_sector(pedDisk, partition_old.getSector());
if (pedPartition) {
if (partition_new.alignment == MParted::ALIGN_MEBIBYTE) {
PedGeometry *geom = ped_geometry_new(pedDevice,
partition_new.sector_start,
partition_new.getSectorLength());
constraint = ped_constraint_exact(geom);
}
else {
constraint = ped_constraint_any(pedDevice);
}
if (constraint) {
if (ped_disk_set_partition_geom(pedDisk,
pedPartition,
constraint,
partition_new.sector_start,
partition_new.sector_end)
&& commit())
{
partition_new.sector_start = pedPartition->geom.start;
partition_new.sector_end = pedPartition->geom.end;
return_value = true;
}
ped_constraint_destroy(constraint);
}
}
closeDeviceAndDisk();
return return_value;
}
static int
_can_create_extended (const PedDisk* disk)
{
if (!_can_create_primary (disk))
return 0;
if (!ped_disk_type_check_feature (disk->type, PED_DISK_TYPE_EXTENDED))
return 0;
if (ped_disk_extended_partition (disk))
return 0;
return 1;
}
bool MParted::MParted_Core::removePartition(MParted::Partition & partition) {
if (!openDeviceAndDisk(partition.devicePath))
return false;
PedPartition *pedPartition = NULL;
if (partition.type == MParted::TYPE_EXTENDED)
pedPartition = ped_disk_extended_partition(pedDisk);
else
pedPartition = ped_disk_get_partition_by_sector(pedDisk, partition.getSector());
bool success = false;
if (pedPartition != NULL)
success = ped_disk_delete_partition(pedDisk, pedPartition) && commit();
closeDeviceAndDisk();
return success;
}
bool LibPartedPartitionTable::deletePartition(Report& report, const Partition& partition)
{
Q_ASSERT(partition.devicePath() == QString::fromUtf8(pedDevice()->path));
bool rval = false;
PedPartition* pedPartition = partition.roles().has(PartitionRole::Extended)
? ped_disk_extended_partition(pedDisk())
: ped_disk_get_partition_by_sector(pedDisk(), partition.firstSector());
if (pedPartition) {
rval = ped_disk_delete_partition(pedDisk(), pedPartition);
if (!rval)
report.line() << xi18nc("@info:progress", "Could not delete partition <filename>%1</filename>.", partition.deviceNode());
} else
report.line() << xi18nc("@info:progress", "Deleting partition failed: Partition to delete (<filename>%1</filename>) not found on disk.", partition.deviceNode());
return rval;
}
bool MParted::MParted_Core::calculateExactGeom(MParted::Partition & partition_old, MParted::Partition & partition_new) {
bool success = false;
if (!openDeviceAndDisk(partition_old.devicePath))
return false;
PedPartition *pedPartition = NULL;
if (partition_old.type == MParted::TYPE_EXTENDED)
pedPartition = ped_disk_extended_partition(pedDisk);
else
pedPartition = ped_disk_get_partition_by_sector(pedDisk, partition_old.getSector());
if (pedPartition) {
PedConstraint *constraint = NULL;
constraint = ped_constraint_any(pedDevice);
if (constraint) {
if (ped_disk_set_partition_geom(pedDisk,
pedPartition,
constraint,
partition_new.sector_start,
partition_new.sector_end))
{
partition_new.sector_start = pedPartition->geom.start;
partition_new.sector_end = pedPartition->geom.end;
success = true;
}
ped_constraint_destroy(constraint);
}
}
closeDeviceAndDisk() ;
return success;
}
static int
dvh_read (PedDisk* disk)
{
DVHDiskData* dvh_disk_data = disk->disk_specific;
int i;
struct volume_header vh;
char boot_name [BFNAMESIZE + 1];
#ifndef DISCOVER_ONLY
int write_back = 0;
#endif
PED_ASSERT (dvh_disk_data != NULL);
ped_disk_delete_all (disk);
void *s0;
if (!ptt_read_sector (disk->dev, 0, &s0))
return 0;
memcpy (&vh, s0, sizeof vh);
free (s0);
if (_checksum ((uint32_t*) &vh, sizeof (struct volume_header))) {
if (ped_exception_throw (
PED_EXCEPTION_ERROR,
PED_EXCEPTION_IGNORE_CANCEL,
_("Checksum is wrong, indicating the partition "
"table is corrupt."))
== PED_EXCEPTION_CANCEL)
return 0;
}
PED_ASSERT (PED_BE32_TO_CPU (vh.vh_magic) == VHMAGIC);
dvh_disk_data->dev_params = vh.vh_dp;
strncpy (boot_name, vh.vh_bootfile, BFNAMESIZE);
boot_name[BFNAMESIZE] = 0;
/* normal partitions */
for (i = 0; i < NPARTAB; i++) {
PedPartition* part;
if (!vh.vh_pt[i].pt_nblks)
continue;
/* Skip the whole-disk partition, parted disklikes overlap */
if (PED_BE32_TO_CPU (vh.vh_pt[i].pt_type) == PTYPE_VOLUME)
continue;
part = _parse_partition (disk, &vh.vh_pt[i]);
if (!part)
goto error_delete_all;
part->fs_type = ped_file_system_probe (&part->geom);
part->num = i + 1;
if (PED_BE16_TO_CPU (vh.vh_rootpt) == i)
ped_partition_set_flag (part, PED_PARTITION_ROOT, 1);
if (PED_BE16_TO_CPU (vh.vh_swappt) == i)
ped_partition_set_flag (part, PED_PARTITION_SWAP, 1);
PedConstraint *constraint_exact
= ped_constraint_exact (&part->geom);
bool ok = ped_disk_add_partition (disk, part, constraint_exact);
ped_constraint_destroy (constraint_exact);
if (!ok) {
ped_partition_destroy (part);
goto error_delete_all;
}
}
if (!ped_disk_extended_partition (disk)) {
#ifdef DISCOVER_ONLY
return 1;
#else
switch (_handle_no_volume_header (disk)) {
case PED_EXCEPTION_CANCEL:
return 0;
case PED_EXCEPTION_IGNORE:
return 1;
case PED_EXCEPTION_FIX:
write_back = 1;
break;
default:
break;
}
#endif
}
/* boot partitions */
for (i = 0; i < NVDIR; i++) {
PedPartition* part;
if (!vh.vh_vd[i].vd_nbytes)
continue;
part = _parse_boot_file (disk, &vh.vh_vd[i]);
if (!part)
goto error_delete_all;
part->fs_type = ped_file_system_probe (&part->geom);
part->num = NPARTAB + i + 1;
if (!strcmp (boot_name, ped_partition_get_name (part)))
ped_partition_set_flag (part, PED_PARTITION_BOOT, 1);
PedConstraint *constraint_exact
= ped_constraint_exact (&part->geom);
bool ok = ped_disk_add_partition (disk, part, constraint_exact);
ped_constraint_destroy (constraint_exact);
if (!ok) {
ped_partition_destroy (part);
goto error_delete_all;
}
}
#ifndef DISCOVER_ONLY
if (write_back)
dvh_write (disk);
#endif
return 1;
error_delete_all:
ped_disk_delete_all (disk);
return 0;
}
gboolean
part_del_partition (char *device_file, guint64 offset)
{
gboolean ret;
PedDevice *device;
PedDisk *disk;
PedPartition *part;
PartitionTable *p;
gboolean is_extended;
int n;
HAL_INFO (("In part_del_partition: device_file=%s, offset=%lld", device_file, offset));
ret = FALSE;
/* sigh.. one would think that if you passed the sector of where the
* the beginning of the extended partition starts, then _by_sector
* would return the same as _extended_partition.
*
* Sadly it's not so..
*
* So, check if the passed offset actually corresponds to a nested
* partition table...
*/
is_extended = FALSE;
p = part_table_load_from_disk (device_file);
if (p == NULL) {
HAL_INFO (("Cannot load partition table from %s", device_file));
goto out;
}
for (n = 0; n < part_table_get_num_entries (p); n++) {
PartitionTable *nested;
nested = part_table_entry_get_nested (p, n);
if (nested != NULL) {
if (part_table_get_offset (nested) == offset) {
HAL_INFO (("partition to delete is an extended partition"));
is_extended = TRUE;
}
}
}
part_table_free (p);
device = ped_device_get (device_file);
if (device == NULL) {
HAL_INFO (("ped_device_get() failed"));
goto out;
}
HAL_INFO (("got it"));
disk = ped_disk_new (device);
if (disk == NULL) {
HAL_INFO (("ped_disk_new() failed"));
goto out_ped_device;
}
HAL_INFO (("got disk"));
if (is_extended) {
part = ped_disk_extended_partition (disk);
} else {
part = ped_disk_get_partition_by_sector (disk, offset / 512);
}
if (part == NULL) {
HAL_INFO (("ped_disk_get_partition_by_sector() failed"));
goto out_ped_disk;
}
HAL_INFO (("got partition - part->type=%d", part->type));
/* allow only to delete primary, logical and extended partitions */
if (! ((part->type == PED_PARTITION_NORMAL) ||
(part->type == PED_PARTITION_LOGICAL) ||
(part->type == PED_PARTITION_EXTENDED))) {
HAL_INFO (("no data partition at given offset %lld for device %s", offset, device_file));
goto out_ped_disk;
}
if (ped_disk_delete_partition (disk, part) == 0) {
HAL_INFO (("ped_disk_delete_partition() failed"));
goto out_ped_disk;
}
/* use commit_to_dev rather than just commit to avoid
* libparted sending BLKRRPART to the kernel - we want to do
* this ourselves...
*/
if (ped_disk_commit_to_dev (disk) == 0) {
HAL_INFO (("ped_disk_commit_to_dev() failed"));
goto out_ped_disk;
}
HAL_INFO (("committed to disk"));
ret = TRUE;
ped_disk_destroy (disk);
ped_device_destroy (device);
goto out;
out_ped_disk:
ped_disk_destroy (disk);
out_ped_device:
ped_device_destroy (device);
out:
return ret;
}
