int main(int argc, char *argv[])
{
PedDevice *device;
PedDisk *disk;
PedPartition *part;
char *name;
if (argc != 2)
error(EXIT_FAILURE, 0, "wrong number!");
device = ped_device_get(argv[1]);
if (!device)
goto error_out;
disk = ped_disk_new(device);
if (!disk)
goto error;
printf("%3s %s %s %s %s\n", "NO.", "Start", "Size", "FS", "NAME");
for (part = ped_disk_next_partition(disk, NULL); part;
part = ped_disk_next_partition(disk, part) )
{
if (part->num < 0)
continue;
name = ped_partition_get_name(part);
printf("%lld %lld %lld %s %s\n", part->num,
part->geom.start, part->geom.length,
(part->fs_type) ? part->fs_type->name : "",
name ? name : "");
}
ped_disk_destroy(disk);
ped_device_destroy(device);
return 0;
error:
ped_device_destroy(device);
error_out:
return 1;
}
PartitionState do_test1(PedDevice *dev, label_type labelType) {
PartitionState state;
//PedGeometry geom;
PedDisk *disk;
PedPartition *part;
PedPartition *grub_partition = 0, *boot_partition = 0, *root_partition = 0;
PedDiskType *type = 0;
PedFileSystemType *ext4 = ped_file_system_type_get("ext4");
bool dirty = false;
PedSector start = 0, end = 0;
/*if (!ped_geometry_init(&geom,dev,0,dev->length)) {
qDebug() << "unable to init geom";
return;
}*/
disk = ped_disk_new(dev);
/*type = ped_disk_probe(dev);
if (type) {
qDebug() << "current partition type:" << type->name;
disk = type->ops->alloc(dev);
if (!type->ops->read(disk)) {
qDebug() << "failed to read gpt tables";
return;
}
}*/
if (!disk) {
qDebug() << "no tables detected";
if (labelType == label_type::gpt) {
type = ped_disk_type_get("gpt");
} else if (labelType == label_type::mbr) {
type = ped_disk_type_get("msdos");
}
disk = ped_disk_new_fresh(dev,type);
ped_disk_commit(disk);
}
if (disk) {
for (part = ped_disk_next_partition(disk,NULL);
part;
part = ped_disk_next_partition(disk,part)) {
if (!ped_partition_is_active(part)) continue;
QString name(ped_partition_get_name(part));
qDebug() << "partition" << part->num << name;
if (name == "boot") boot_partition = part;
if (name == "root") root_partition = part;
if (ped_partition_get_flag(part,PED_PARTITION_BIOS_GRUB)) grub_partition = part;
for (int f = PED_PARTITION_FIRST_FLAG; f < PED_PARTITION_LAST_FLAG; f++) {
if (ped_partition_get_flag(part,(PedPartitionFlag)f)) {
QString flag_name(ped_partition_flag_get_name((PedPartitionFlag)f));
qDebug() << "flag" << flag_name << "is set";
}
}
}
PedConstraint *constraint = ped_constraint_any(dev);
if (!grub_partition) {
start = (1024*1024) / dev->sector_size;
end = ((1024*1024) / dev->sector_size) + start;
qDebug() << "creating" << start << end;
grub_partition = ped_partition_new(disk,PED_PARTITION_NORMAL,ext4,start,end);
if (labelType == label_type::gpt) {
ped_partition_set_name(grub_partition,"bios boot");
ped_partition_set_flag(grub_partition,PED_PARTITION_BIOS_GRUB,1);
}
if (!ped_disk_add_partition(disk,grub_partition,constraint)) {
qDebug() << "error adding partition";
}
dirty = true;
}
if (!boot_partition) {
start = (1024*1024*2) / dev->sector_size;
end = ((1024*1024*128) / dev->sector_size) + start;
qDebug() << "creating" << start << end;
boot_partition = ped_partition_new(disk,PED_PARTITION_NORMAL,NULL,start,end);
if (labelType == label_type::gpt) {
ped_partition_set_name(boot_partition,"boot");
}
//ped_partition_set_flag(boot_partition,PED_PARTITION_BOOT,1);
if (!ped_disk_add_partition(disk,boot_partition,constraint)) {
qDebug() << "error adding partition";
}
dirty = true;
}
if (!root_partition) {
start = (1024*1024*129) / dev->sector_size;
end = dev->length;
qDebug() << "creating" << start << end;
root_partition = ped_partition_new(disk,PED_PARTITION_NORMAL,ext4,start,end);
if (labelType == label_type::gpt) {
ped_partition_set_name(root_partition,"root");
//ped_partition_set_flag(root_partition,PED_PARTITION_ROOT,1);
}
if (!ped_disk_add_partition(disk,root_partition,constraint)) {
qDebug() << "error adding partition";
}
dirty = true;
}
ped_constraint_destroy(constraint);
}
if (dirty) ped_disk_commit(disk);
state.boot_path = ped_partition_get_path(boot_partition);
state.root_path = ped_partition_get_path(root_partition);
return state;
}
static int
dvh_write (const PedDisk* disk)
{
DVHDiskData* dvh_disk_data = disk->disk_specific;
struct volume_header vh;
int i;
PED_ASSERT (dvh_disk_data != NULL);
_flush_stale_flags (disk);
memset (&vh, 0, sizeof (struct volume_header));
vh.vh_magic = PED_CPU_TO_BE32 (VHMAGIC);
vh.vh_rootpt = PED_CPU_TO_BE16 (dvh_disk_data->root - 1);
vh.vh_swappt = PED_CPU_TO_BE16 (dvh_disk_data->swap - 1);
if (dvh_disk_data->boot) {
PedPartition* boot_part;
boot_part = ped_disk_get_partition (disk, dvh_disk_data->boot);
strcpy (vh.vh_bootfile, ped_partition_get_name (boot_part));
}
vh.vh_dp = dvh_disk_data->dev_params;
/* Set up rudimentary device geometry */
vh.vh_dp.dp_cyls
= PED_CPU_TO_BE16 ((short)disk->dev->bios_geom.cylinders);
vh.vh_dp.dp_trks0 = PED_CPU_TO_BE16 ((short)disk->dev->bios_geom.heads);
vh.vh_dp.dp_secs
= PED_CPU_TO_BE16 ((short)disk->dev->bios_geom.sectors);
vh.vh_dp.dp_secbytes = PED_CPU_TO_BE16 ((short)disk->dev->sector_size);
for (i = 0; i < NPARTAB; i++) {
PedPartition* part = ped_disk_get_partition (disk, i + 1);
if (part)
_generate_partition (part, &vh.vh_pt[i]);
}
/* whole disk partition
* This is only ever written here, and never modified
* (or even shown) as it must contain the entire disk,
* and parted does not like overlapping partitions
*/
vh.vh_pt[PNUM_VOLUME].pt_nblks = PED_CPU_TO_BE32 (disk->dev->length);
vh.vh_pt[PNUM_VOLUME].pt_firstlbn = PED_CPU_TO_BE32 (0);
vh.vh_pt[PNUM_VOLUME].pt_type = PED_CPU_TO_BE32 (PTYPE_VOLUME);
for (i = 0; i < NVDIR; i++) {
PedPartition* part = ped_disk_get_partition (disk,
i + 1 + NPARTAB);
if (part)
_generate_boot_file (part, &vh.vh_vd[i]);
}
vh.vh_csum = 0;
vh.vh_csum = PED_CPU_TO_BE32 (_checksum ((uint32_t*) &vh,
sizeof (struct volume_header)));
return (ptt_write_sector (disk, &vh, sizeof vh)
&& ped_device_sync (disk->dev));
}
static int
fill_raw_part (PC98RawPartition* raw_part, const PedPartition* part)
{
PC98PartitionData* pc98_data;
int c, h, s;
const char* name;
PED_ASSERT (raw_part != NULL);
PED_ASSERT (part != NULL);
PED_ASSERT (part->disk_specific != NULL);
pc98_data = part->disk_specific;
raw_part->mid = (pc98_data->system >> 8) & 0xFF;
raw_part->sid = pc98_data->system & 0xFF;
SET_BIT(raw_part->mid, 7, pc98_data->boot);
SET_BIT(raw_part->sid, 7, !pc98_data->hidden);
memset (raw_part->name, ' ', sizeof(raw_part->name));
name = ped_partition_get_name (part);
PED_ASSERT (name != NULL);
PED_ASSERT (strlen (name) <= 16);
if (!strlen (name) && part->fs_type)
name = part->fs_type->name;
memcpy (raw_part->name, name, strlen (name));
sector_to_chs (part->disk->dev, part->geom.start, &c, &h, &s);
raw_part->cyl = PED_CPU_TO_LE16(c);
raw_part->head = h;
raw_part->sector = s;
if (pc98_data->ipl_sector) {
sector_to_chs (part->disk->dev, pc98_data->ipl_sector,
&c, &h, &s);
raw_part->ipl_cyl = PED_CPU_TO_LE16(c);
raw_part->ipl_head = h;
raw_part->ipl_sect = s;
} else {
raw_part->ipl_cyl = raw_part->cyl;
raw_part->ipl_head = raw_part->head;
raw_part->ipl_sect = raw_part->sector;
}
sector_to_chs (part->disk->dev, part->geom.end, &c, &h, &s);
if (h != part->disk->dev->hw_geom.heads - 1
|| s != part->disk->dev->hw_geom.sectors - 1) {
ped_exception_throw (
PED_EXCEPTION_NO_FEATURE,
PED_EXCEPTION_CANCEL,
_("Partition %d isn't aligned to cylinder "
"boundaries. This is still unsupported."),
part->num);
return 0;
}
raw_part->end_cyl = PED_CPU_TO_LE16(c);
#if 0
raw_part->end_head = h;
raw_part->end_sector = s;
#else
raw_part->end_head = 0;
raw_part->end_sector = 0;
#endif
return 1;
}
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;
}
