int listparts(PedDisk *disk, int noswap)
{
PedPartition *part = NULL;
PedPartition *extpart = NULL;
if(ped_disk_next_partition(disk, NULL)==NULL)
// no partition detected
return(1);
for(part=ped_disk_next_partition(disk, NULL);
part!=NULL;part=part->next)
{
if((part->num>0) && (part->type != PED_PARTITION_EXTENDED) && !ped_partition_get_flag(part, PED_PARTITION_RAID))
partdetails(part, noswap);
if(part->type == PED_PARTITION_EXTENDED)
for(extpart=part->part_list;
extpart!=NULL;extpart=extpart->next)
if(extpart->num>0 && !ped_partition_get_flag(extpart, PED_PARTITION_RAID))
partdetails(extpart, noswap);
}
return(0);
}
static void
get_partition_info(struct partition *p, PedPartition *part, PedDevice *dev, bool ignore_fs_type)
{
if (PART_SIZE_BYTES(dev, part) > 0)
p->size = PART_SIZE_BYTES(dev, part);
if (!ignore_fs_type && part->fs_type != NULL) {
if (strcmp(part->fs_type->name, "linux-swap") == 0)
p->fstype = strdup("swap");
else
p->fstype = strdup(part->fs_type->name);
} else {
if (ped_partition_is_flag_available(part, PED_PARTITION_LVM) &&
ped_partition_get_flag(part, PED_PARTITION_LVM)) {
p->fstype = strdup("LVM");
}
if (ped_partition_is_flag_available(part, PED_PARTITION_RAID) &&
ped_partition_get_flag(part, PED_PARTITION_RAID)) {
p->fstype = strdup("RAID");
}
}
}
int
main(int argc, char *argv[])
{
PedDevice *dev;
// use "-l" to list all prep partitions found (not just the first one).
int list = (argc == 2 && !strncmp(argv[1], "-l", strlen("-l")));
ped_exception_fetch_all();
ped_device_probe_all();
for (dev = ped_device_get_next(NULL); dev;
dev = ped_device_get_next(dev)) {
PedDisk *disk;
PedPartition *part;
disk = ped_disk_new(dev);
if (!disk)
continue;
for (part = ped_disk_next_partition(disk, NULL); part;
part = ped_disk_next_partition(disk, part)) {
if (ped_partition_is_active(part) &&
ped_partition_get_flag(part, PED_PARTITION_PREP)) {
char *path;
path = ped_partition_get_path(part);
if (path) {
printf("%s\n", path);
if (!list) {
free(path);
return 0;
}
}
free(path);
}
}
}
return 0;
}
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;
}
int
get_all_partitions(struct partition *parts[], const int max_parts, bool ignore_fs_type, PedPartitionFlag require_flag)
{
struct partition *p;
int part_count = 0;
PedDevice *dev = NULL;
PedDisk *disk;
PedPartition *part;
ped_device_probe_all();
while ((dev = ped_device_get_next(dev)) != NULL) {
if (dev->read_only)
continue;
if (strstr(dev->path, "/dev/mtd") == dev->path)
continue;
if (!ped_disk_probe(dev))
continue;
disk = ped_disk_new(dev);
part = NULL;
while ((part = ped_disk_next_partition(disk, part)) != NULL) {
if (part->type & (PED_PARTITION_METADATA | PED_PARTITION_FREESPACE | PED_PARTITION_EXTENDED))
continue;
if (part_count >= max_parts)
break;
#ifndef FIND_PARTS_MAIN
/* allow other udebs to block partitions */
if(block_partition(ped_partition_get_path(part)) != 0)
continue;
#endif
if (require_flag && !ped_partition_get_flag(part, require_flag))
continue;
p = malloc(sizeof(*p));
p->path = ped_partition_get_path(part);
if (strstr(p->path, "/dev/hd") == p->path) {
static char *targets[] = { "master", "slave" };
char drive;
int part;
if (sscanf(p->path, "/dev/hd%c%d", &drive, &part) == 2
&& drive >= 'a' && drive <= 'z')
asprintf(&p->description, "IDE%d %s\\, part. %d",
(drive - 'a') / 2 + 1, targets[(drive - 'a') % 2],
part);
else
p->description = strdup(p->path);
} else if (strstr(p->path, "/dev/sd") == p->path) {
char drive;
int host, bus, target, lun, part;
int done = 0;
if (sscanf(p->path, "/dev/sd%c%d", &drive, &part) == 2
&& drive >= 'a' && drive <= 'z') {
struct stat st;
char *disk, *disk_pos, *sys_device;
disk = strdup(p->path + 5);
for (disk_pos = disk + strlen(disk) - 1; disk_pos > disk;
--disk_pos) {
if (*disk_pos >= '0' && *disk_pos <= '9')
*disk_pos = 0;
else
break;
}
sys_device = malloc(strlen(disk) + 19);
sprintf(sys_device, "/sys/block/%s/device", disk);
/* TODO: device symlinks are allegedly slated to go
* away, but it's not entirely clear what their
* replacement will be yet ...
*/
if (lstat(sys_device, &st) == 0 && S_ISLNK(st.st_mode)) {
char buf[512];
memset(buf, 0, 512);
if (readlink(sys_device, buf, 511) > 0) {
const char *bus_id = basename(buf);
if (sscanf(bus_id, "%d:%d:%d:%d",
&host, &bus, &target, &lun) == 4) {
asprintf(&p->description, "SCSI%d (%d\\,%d\\,%d) part. %d",
host + 1, bus, target, lun, part);
done = 1;
}
}
}
}
if (!done)
p->description = strdup(p->path);
} else
p->description = strdup(p->path);
p->fstype = NULL;
p->fsid = NULL;
p->size = 0L;
p->op.filesystem = NULL;
p->op.mountpoint = NULL;
p->op.done = 0;
test_lvm(p);
test_evms(p);
test_raid(p);
/* FIXME: Other tests? */
get_partition_info(p, part, dev, ignore_fs_type);
parts[part_count++] = p;
}
if (part_count >= max_parts)
break;
}
return part_count;
}
