int main(int argc, char* argv[])
{
PedDevice* device;
PedDisk* disk;
if(argc != 2)
error(EXIT_FAILURE, 0, "wrong number of argument");
device = ped_device_get(argv[1]);
if(device == NULL)
error(EXIT_FAILURE, 0, "error getting the device");
disk = ped_disk_new(device);
if(disk == NULL)
{
ped_device_destroy(device);
error(EXIT_FAILURE, 0, "error getting the disk");
}
ped_disk_delete_all(disk);
ped_disk_commit(disk);
ped_disk_destroy(disk);
ped_device_destroy(device);
return 0;
}
int
main (int argc, char **argv)
{
atexit (close_stdout);
set_program_name (argv[0]);
if (argc != 2)
return EXIT_FAILURE;
char const *dev_name = argv[1];
PedDevice *dev = ped_device_get (dev_name);
if (dev == NULL)
return EXIT_FAILURE;
PedDisk *disk = ped_disk_new (dev);
if (disk == NULL)
return EXIT_FAILURE;
PedSector max_length = ped_disk_max_partition_length (disk);
PedSector max_start_sector = ped_disk_max_partition_start_sector (disk);
printf ("max len: %llu\n", (unsigned long long) max_length);
printf ("max start sector: %llu\n", (unsigned long long) max_start_sector);
ped_disk_destroy (disk);
ped_device_destroy (dev);
return EXIT_SUCCESS;
}
void MParted::MParted_Core::closeDeviceAndDisk() {
closeDisk() ;
if (pedDevice)
ped_device_destroy(pedDevice);
pedDevice = NULL;
}
int main(int argc, char* argv[])
{
PedDevice* device;
PedDisk* disk_old;
PedDisk* disk;
PedDiskType* type;
if(argc != 3)
error(EXIT_FAILURE, 0, "wrong number of arguments");
device = ped_device_get(argv[1]);
if(device == NULL)
return -1;
type = ped_disk_type_get(argv[2]);
if(type == NULL)
{
ped_device_destroy(device);
error(EXIT_FAILURE, 0, "invalid type");
return -1;
}
disk_old = ped_disk_new(device);
printf("disk type: %s \n",disk_old->type->name);
disk = ped_disk_new_fresh(device, disk_old->type);
if(disk == NULL)
{
ped_device_destroy(device);
error(EXIT_FAILURE, 0, "error formating disk");
return -1;
}
if(!ped_disk_commit(disk))
{
ped_disk_destroy(disk);
error(EXIT_FAILURE, 0, "error writing a new partition table");
return -1;
}
ped_disk_destroy(disk);
ped_device_destroy(device);
return 0;
}
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;
}
int main(int argc, char *argv[])
{
PedDevice *dev;
PedDisk *disk;
PedPartition *part;
PedConstraint *constraint;
/*
* argv [1] device
* [2] udv_name
* [3] start
* [4] end
*/
dev = ped_device_get(argv[1]);
if (!dev)
{
perror("get_device");
return -1;
}
//disk = _create_disk_label(dev, ped_disk_type_get("gpt"));
disk = ped_disk_new(dev);
if (!disk)
{
fprintf(stderr, "fail to create disk label gpt\n");
return -2;
}
constraint = ped_constraint_any(dev);
// part1: 17.4Kb ~ 15MB
/*
part = ped_partition_new(disk, PED_PARTITION_NORMAL,
NULL,
34, 29296);
ped_disk_add_partition(disk, part, constraint);
*/
// part2: 15MB ~ 35MB
part = ped_partition_new(disk, PED_PARTITION_NORMAL,
NULL,
(int)(atoll(argv[3])/512),
(int)(atoll(argv[4])/512));
ped_partition_set_name(part, argv[2]);
ped_disk_add_partition(disk, part, constraint);
ped_disk_commit(disk);
ped_constraint_destroy(constraint);
ped_disk_destroy(disk);
ped_device_destroy(dev);
return 0;
}
int main (int argc, char* argv[])
{
PedDevice* device = NULL;
PedDisk* disk = NULL;
PedDiskType* type = NULL;
PedPartition* part = NULL;
int return_code = EXIT_FAILURE;
if (argc != 2){
printf("wrong number of arguments\n");
return EXIT_FAILURE;
}
device = ped_device_get (argv[1]);
printf("device:%s\n",argv[1]);
if (device == NULL)
goto error_exit;
type = ped_disk_probe (device);
if (type == NULL)
goto error_destroy_device;
printf("Disk Type:%s\n",type->name);
disk = ped_disk_new (device);
if (disk == NULL)
goto error_destroy_device;
do
{
part = ped_disk_next_partition (disk, part);
if ((part != NULL) && (part->num > -1)){
printf("%d %s %s\n",part->num,ped_partition_type_get_name(part->type),ped_unit_format (device,part->geom.length));
}
}while( part );
ped_disk_destroy (disk);
return_code = EXIT_SUCCESS;
// Fall through to clean up
error_destroy_device:
ped_device_destroy (device);
error_exit:
return return_code;
}
/**
* Creates the boot- and the linux partition and formats the linux
* partition with an ext2 filesystem
*
*/
int create_partitions(const char* dev, unsigned long bootsector_size) {
PedDisk* disk;
PedDevice* device;
PedPartition* boot_part;
PedPartition* linux_part;
PedFileSystemType* fs_type;
PedTimer* timer;
// get device from string e.g. "/dev/sdd"
device = ped_device_get(dev);
if(device == NULL) {
return 0;
}
// create new partition table
disk = ped_disk_new_fresh(device, ped_disk_type_get("msdos"));
if(disk == NULL) {
ped_device_destroy(device);
return 0;
}
// get file system type (ext2)
fs_type = ped_file_system_type_get(FILE_SYSTEM);
// create partitions
boot_part = ped_partition_new(disk, PED_PARTITION_NORMAL, fs_type, 0, bootsector_size / device->sector_size);
linux_part = ped_partition_new(disk, PED_PARTITION_NORMAL, fs_type, bootsector_size / device->sector_size, device->length - 1);
// add partitions to partition table
PedConstraint* constraint = ped_constraint_any(device);
ped_disk_add_partition(disk, linux_part, constraint);
ped_disk_add_partition(disk, boot_part, constraint);
ped_constraint_destroy(constraint);
// create timer
timer = ped_timer_new(create_ext2_timer, NULL);
// create filesystem
ped_file_system_create(&linux_part->geom, fs_type, timer);
// commit to hardware
ped_disk_commit_to_dev(disk);
ped_disk_commit_to_os(disk);
return 1;
}
void
gnome_format_create_partition(gchar *block_dev, gchar *fs, GError **error) {
PedDevice *device;
PedDisk *disk;
PedFileSystemType *fs_type;
PedPartition *part;
ped_exception_set_handler(parted_exception_handler);
try(device = ped_device_get(block_dev));
try(disk = ped_disk_new(device));
int last_part_num = ped_disk_get_last_partition_num(disk);
if (last_part_num != -1) {
// if partitions exist, delete them
try(ped_disk_delete_all(disk));
}
long long end = device->length - 1;
try(fs_type = ped_file_system_type_get(fs));
// create new partition
try(part = ped_partition_new(disk, PED_PARTITION_NORMAL, fs_type, 1, end));
try(ped_disk_add_partition(disk, part, ped_constraint_any(device)));
try(ped_file_system_create(&part->geom, fs_type, NULL));
// commit changes
try(ped_disk_commit_to_dev(disk));
// this needs root priviliges
// try(ped_disk_commit_to_os(disk));
#ifdef DEBUG
printf("device.sector_size: %lld\n", device->sector_size);
printf("device.length: %lld\n", device->length);
printf("end: %lld\n", end);
#endif
// free stuff
ped_disk_destroy(disk);
ped_device_destroy(device);
}
int
main(int argc, char *argv[])
{
PedDevice *dev;
ped_exception_fetch_all();
ped_device_probe_all();
if (argc > 1) {
int i;
for (i = 1; i < argc; ++i) {
dev = ped_device_get(argv[i]);
if (dev) {
process_device(dev);
ped_device_destroy(dev);
}
}
} else {
for (dev = NULL; NULL != (dev = ped_device_get_next(dev));)
process_device(dev);
}
return 0;
}
PyObject *py_ped_device_destroy(PyObject *s, PyObject *args) {
_ped_Device *dev = (_ped_Device *) s;
PedDevice *device = NULL;
device = _ped_Device2PedDevice(s);
if (device == NULL) {
return NULL;
}
ped_device_destroy(device);
Py_CLEAR(dev->hw_geom);
dev->hw_geom = NULL;
Py_CLEAR(dev->bios_geom);
dev->bios_geom = NULL;
Py_CLEAR(dev);
Py_INCREF(Py_None);
return Py_None;
}
static gboolean
part_add_change_partition (char *device_file,
guint64 start, guint64 size,
guint64 new_start, guint64 new_size,
guint64 *out_start, guint64 *out_size,
char *type, char *label, char **flags,
int geometry_hps, int geometry_spt)
{
int n;
gboolean is_change;
gboolean res;
PedDevice *device;
PedDisk *disk;
PedPartition *part;
PedConstraint* constraint;
PedPartitionType ped_type;
guint64 start_sector;
guint64 end_sector;
guint64 new_start_sector;
guint64 new_end_sector;
PartitionTable *p;
PartitionTable *container_p;
int container_entry;
PartitionScheme scheme;
guint8 mbr_flags = 0;
guint8 mbr_part_type = 0;
char *endp;
guint64 gpt_attributes = 0;
guint32 apm_status = 0;
res = FALSE;
is_change = FALSE;
if (size == 0) {
is_change = TRUE;
}
if (is_change) {
HAL_INFO (("In part_change_partition: device_file=%s, start=%lld, new_start=%lld, new_size=%lld, type=%s", device_file, start, new_start, new_size, type));
} else {
HAL_INFO (("In part_add_partition: device_file=%s, start=%lld, size=%lld, type=%s", device_file, start, size, type));
}
/* first, find the kind of (embedded) partition table the new partition is going to be part of */
p = part_table_load_from_disk (device_file);
if (p == NULL) {
HAL_INFO (("Cannot load partition table from %s", device_file));
goto out;
}
part_table_find (p, start + 512, &container_p, &container_entry);
scheme = part_table_get_scheme (container_p);
if (is_change) {
/* if changing, make sure there is a partition to change */
if (container_entry < 0) {
HAL_INFO (("Couldn't find partition to change"));
goto out;
}
} else {
/* if adding, make sure there is no partition in the way... */
if (container_entry >= 0) {
char *part_type;
/* this might be Apple_Free if we're on PART_TYPE_APPLE */
part_type = part_table_entry_get_type (p, container_entry);
if (! (p->scheme == PART_TYPE_APPLE && part_type != NULL && (strcmp (part_type, "Apple_Free") == 0))) {
part_table_free (p);
HAL_INFO (("There is a partition in the way on %s", device_file));
goto out;
}
}
}
HAL_INFO (("containing partition table scheme = %d", scheme));
part_table_free (p);
p = NULL;
if (!is_change) {
if (type == NULL) {
HAL_INFO (("No type specified"));
goto out;
}
}
/* now that we know the partitoning scheme, sanity check type and flags */
switch (scheme) {
case PART_TYPE_MSDOS:
case PART_TYPE_MSDOS_EXTENDED:
mbr_flags = 0;
if (flags != NULL) {
for (n = 0; flags[n] != NULL; n++) {
if (strcmp (flags[n], "boot") == 0) {
mbr_flags |= 0x80;
} else {
HAL_INFO (("unknown flag '%s'", flags[n]));
goto out;
}
}
}
if (type != NULL) {
mbr_part_type = (guint8) (strtol (type, &endp, 0));
if (*endp != '\0') {
HAL_INFO (("invalid type '%s' given", type));
goto out;
}
}
if (label != NULL) {
HAL_INFO (("labeled partitions not supported on MSDOS or MSDOS_EXTENDED"));
goto out;
}
break;
case PART_TYPE_GPT:
gpt_attributes = 0;
if (flags != NULL) {
for (n = 0; flags[n] != NULL; n++) {
if (strcmp (flags[n], "required") == 0) {
gpt_attributes |= 1;
} else {
HAL_INFO (("unknown flag '%s'", flags[n]));
goto out;
}
}
}
break;
case PART_TYPE_APPLE:
apm_status = 0;
if (flags != NULL) {
for (n = 0; flags[n] != NULL; n++) {
if (strcmp (flags[n], "allocated") == 0) {
apm_status |= (1<<1);
} else if (strcmp (flags[n], "in_use") == 0) {
apm_status |= (1<<2);
} else if (strcmp (flags[n], "boot") == 0) {
apm_status |= (1<<3);
} else if (strcmp (flags[n], "allow_read") == 0) {
apm_status |= (1<<4);
} else if (strcmp (flags[n], "allow_write") == 0) {
apm_status |= (1<<5);
} else if (strcmp (flags[n], "boot_code_is_pic") == 0) {
apm_status |= (1<<6);
} else {
HAL_INFO (("unknown flag '%s'", flags[n]));
goto out;
}
}
}
break;
default:
HAL_INFO (("partitioning scheme %d not supported", scheme));
goto out;
}
switch (scheme) {
case PART_TYPE_MSDOS:
if (mbr_part_type == 0x05 || mbr_part_type == 0x85 || mbr_part_type == 0x0f) {
ped_type = PED_PARTITION_EXTENDED;
} else {
ped_type = PED_PARTITION_NORMAL;
}
break;
case PART_TYPE_MSDOS_EXTENDED:
ped_type = PED_PARTITION_LOGICAL;
if (mbr_part_type == 0x05 || mbr_part_type == 0x85 || mbr_part_type == 0x0f) {
HAL_INFO (("Cannot create an extended partition inside an extended partition"));
goto out;
}
break;
default:
ped_type = PED_PARTITION_NORMAL;
break;
}
/* now, create the partition */
start_sector = start / 512;
end_sector = (start + size) / 512 - 1;
new_start_sector = new_start / 512;
new_end_sector = (new_start + new_size) / 512 - 1;
device = ped_device_get (device_file);
if (device == NULL) {
HAL_INFO (("ped_device_get() failed"));
goto out;
}
HAL_INFO (("got it"));
/* set drive geometry on libparted object if the user requested it */
if (geometry_hps > 0 && geometry_spt > 0 ) {
/* not sure this is authorized use of libparted, but, eh, it seems to work */
device->hw_geom.cylinders = device->bios_geom.cylinders = device->length / geometry_hps / geometry_spt;
device->hw_geom.heads = device->bios_geom.heads = geometry_hps;
device->hw_geom.sectors = device->bios_geom.sectors = geometry_spt;
}
disk = ped_disk_new (device);
if (disk == NULL) {
HAL_INFO (("ped_disk_new() failed"));
goto out_ped_device;
}
HAL_INFO (("got disk"));
if (!is_change) {
part = ped_partition_new (disk,
ped_type,
NULL,
start_sector,
end_sector);
if (part == NULL) {
HAL_INFO (("ped_partition_new() failed"));
goto out_ped_disk;
}
HAL_INFO (("new partition"));
} else {
part = ped_disk_get_partition_by_sector (disk,
start_sector);
if (part == NULL) {
HAL_INFO (("ped_partition_get_by_sector() failed"));
goto out_ped_disk;
}
HAL_INFO (("got partition"));
}
/* TODO HACK XXX FIXME UGLY BAD: This is super ugly abuse of
* libparted - we poke at their internal data structures - but
* there ain't nothing we can do about it until libparted
* provides API for this...
*/
if (scheme == PART_TYPE_GPT) {
struct {
efi_guid type;
efi_guid uuid;
char name[37];
int lvm;
int raid;
int boot;
int hp_service;
int hidden;
/* more stuff */
} *gpt_data = (void *) part->disk_specific;
if (type != NULL) {
if (!set_le_guid ((guint8*) &gpt_data->type, type)) {
HAL_INFO (("type '%s' for GPT appear to be malformed", type));
goto out_ped_partition;
}
}
if (flags != NULL) {
if (gpt_attributes & 1) {
gpt_data->hidden = 1;
} else {
gpt_data->hidden = 0;
}
}
} else if (scheme == PART_TYPE_MSDOS || scheme == PART_TYPE_MSDOS_EXTENDED) {
struct {
unsigned char system;
int boot;
/* more stuff */
} *dos_data = (void *) part->disk_specific;
if (type != NULL) {
dos_data->system = mbr_part_type;
}
if (flags != NULL) {
if (mbr_flags & 0x80) {
dos_data->boot = 1;
} else {
dos_data->boot = 0;
}
}
} else if (scheme == PART_TYPE_APPLE) {
struct {
char volume_name[33]; /* eg: "Games" */
char system_name[33]; /* eg: "Apple_Unix_SVR2" */
char processor_name[17];
int is_boot;
int is_driver;
int has_driver;
int is_root;
int is_swap;
int is_lvm;
int is_raid;
PedSector data_region_length;
PedSector boot_region_length;
guint32 boot_base_address;
guint32 boot_entry_address;
guint32 boot_checksum;
guint32 status;
/* more stuff */
} *mac_data = (void *) part->disk_specific;
if (type != NULL) {
memset (mac_data->system_name, 0, 33);
strncpy (mac_data->system_name, type, 32);
}
if (flags != NULL) {
mac_data->status = apm_status;
}
}
if (label != NULL) {
ped_partition_set_name (part, label);
}
if (geometry_hps > 0 && geometry_spt > 0 ) {
/* respect drive geometry */
constraint = ped_constraint_any (device);
} else if (geometry_hps == -1 && geometry_spt == -1 ) {
/* undocumented (or is it?) libparted usage again.. it appears that
* the probed geometry is stored in hw_geom
*/
device->bios_geom.cylinders = device->hw_geom.cylinders;
device->bios_geom.heads = device->hw_geom.heads;
device->bios_geom.sectors = device->hw_geom.sectors;
constraint = ped_constraint_any (device);
} else {
PedGeometry *geo_start;
PedGeometry *geo_end;
/* ignore drive geometry */
if (is_change) {
geo_start = ped_geometry_new (device, new_start_sector, 1);
geo_end = ped_geometry_new (device, new_end_sector, 1);
} else {
geo_start = ped_geometry_new (device, start_sector, 1);
geo_end = ped_geometry_new (device, end_sector, 1);
}
constraint = ped_constraint_new (ped_alignment_any, ped_alignment_any,
geo_start, geo_end, 1, device->length);
}
try_change_again:
if (is_change) {
if (ped_disk_set_partition_geom (disk,
part,
constraint,
new_start_sector, new_end_sector) == 0) {
HAL_INFO (("ped_disk_set_partition_geom() failed"));
goto out_ped_constraint;
}
} else {
if (ped_disk_add_partition (disk,
part,
constraint) == 0) {
HAL_INFO (("ped_disk_add_partition() failed"));
goto out_ped_constraint;
}
}
*out_start = part->geom.start * 512;
*out_size = part->geom.length * 512;
if (is_change) {
/* make sure the resulting size is never smaller than requested
* (this is because one will resize the FS and *then* change the partition table)
*/
if (*out_size < new_size) {
HAL_INFO (("new_size=%lld but resulting size, %lld, smaller than requested", new_size, *out_size));
new_end_sector++;
goto try_change_again;
} else {
HAL_INFO (("changed partition to start=%lld size=%lld", *out_start, *out_size));
}
} else {
HAL_INFO (("added partition start=%lld size=%lld", *out_start, *out_size));
}
/* hmm, if we don't do this libparted crashes.. I assume that
* ped_disk_add_partition assumes ownership of the
* PedPartition when adding it... sadly this is not documented
* anywhere.. sigh..
*/
part = NULL;
/* 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_constraint;
}
HAL_INFO (("committed to disk"));
res = TRUE;
ped_constraint_destroy (constraint);
ped_disk_destroy (disk);
ped_device_destroy (device);
goto out;
out_ped_constraint:
ped_constraint_destroy (constraint);
out_ped_partition:
if (part != NULL) {
ped_partition_destroy (part);
}
out_ped_disk:
ped_disk_destroy (disk);
out_ped_device:
ped_device_destroy (device);
out:
return res;
}
gboolean
part_create_partition_table (char *device_file, PartitionScheme scheme)
{
PedDevice *device;
PedDisk *disk;
PedDiskType *disk_type;
gboolean ret;
ret = FALSE;
HAL_INFO (("In part_create_partition_table: device_file=%s, scheme=%d", device_file, scheme));
device = ped_device_get (device_file);
if (device == NULL) {
HAL_INFO (("ped_device_get() failed"));
goto out;
}
HAL_INFO (("got it"));
switch (scheme) {
case PART_TYPE_MSDOS:
disk_type = ped_disk_type_get ("msdos");
break;
case PART_TYPE_APPLE:
disk_type = ped_disk_type_get ("mac");
break;
case PART_TYPE_GPT:
disk_type = ped_disk_type_get ("gpt");
break;
default:
disk_type = NULL;
break;
}
if (disk_type == NULL) {
HAL_INFO (("Unknown or unsupported partitioning scheme %d", scheme));
goto out;
}
disk = ped_disk_new_fresh (device, disk_type);
if (disk == NULL) {
HAL_INFO (("ped_disk_new_fresh() failed"));
goto out_ped_device;
}
HAL_INFO (("got disk"));
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;
}
/* Return a new store in STORE which contains a remap store of partition
PART from the contents of SOURCE; SOURCE is consumed. */
error_t
store_part_create (struct store *source, int index, int flags,
struct store **store)
{
static pthread_mutex_t parted_lock = PTHREAD_MUTEX_INITIALIZER;
static int version_check;
error_t err = 0;
PedDevice *dev;
PedDisk *disk;
PedPartition *part;
struct store_run run;
if ((source->block_size < PED_SECTOR_SIZE
&& PED_SECTOR_SIZE % source->block_size != 0)
|| (source->block_size > PED_SECTOR_SIZE
&& source->block_size % PED_SECTOR_SIZE != 0))
return EINVAL;
pthread_mutex_lock (&parted_lock);
/* Since Parted provides no source-level information about
version compatibility, we have to check at run time. */
if (version_check == 0)
{
const char *version = ped_get_version ();
version_check = -1;
if (version == 0)
error (0, 0, "cannot get version of Parted library!");
else if (strverscmp (version, NEED_PARTED_VERSION) < 0)
error (0, 0, "Parted library version %s older than needed %s",
version, NEED_PARTED_VERSION);
else
version_check = 1;
}
if (version_check <= 0)
{
error (0, 0, "the `part' store type is not available");
pthread_mutex_unlock (&parted_lock);
return ENOTSUP;
}
ped_exception_fetch_all ();
dev = ped_device_new_from_store (source);
if (! dev)
{
ped_exception_catch ();
err = EIO;
goto out;
}
assert (ped_device_open (dev) != 0);
disk = ped_disk_new (dev);
if (! disk)
{
ped_exception_catch ();
err = EIO;
goto out_with_dev;
}
for (part = ped_disk_next_partition (disk, NULL); part;
part = ped_disk_next_partition (disk, part))
{
if (part->type != PED_PARTITION_LOGICAL
&& part->type != 0 /* PED_PARTITION_PRIMARY */)
continue;
assert (part->num);
if (part->num == index)
break;
}
if (! part)
{
err = EIO;
goto out_with_disk;
}
if (source->block_size == PED_SECTOR_SIZE)
{
run.start = part->geom.start;
run.length = part->geom.length;
}
else if (source->block_size < PED_SECTOR_SIZE)
{
run.start = part->geom.start * (PED_SECTOR_SIZE / source->block_size);
run.length = part->geom.length * (PED_SECTOR_SIZE / source->block_size);
}
else
/* source->block_size > PED_SECTOR_SIZE */
{
run.start = part->geom.start * PED_SECTOR_SIZE;
if (run.start % source->block_size != 0)
err = EIO;
else
{
run.start /= source->block_size;
run.length = part->geom.length * PED_SECTOR_SIZE;
if (run.length % source->block_size != 0)
err = EIO;
else
run.length /= source->block_size;
}
}
out_with_disk:
assert (ped_device_close (dev) != 0);
ped_disk_destroy (disk);
out_with_dev:
ped_device_destroy (dev);
out:
ped_exception_leave_all ();
pthread_mutex_unlock (&parted_lock);
if (! err)
err = store_remap (source, &run, 1, store);
return err;
}
/**
* @brief GetPartitions
* @param deviceName : dev name of the disk eg. '/dev/sdc'
* @param partitions : a vector of partitions that this function will write to.
* @return true if partitions on disk(deviceName) was successfully read.
*/
bool GetPartitions(std::string deviceName, cPartitions& partitions)
{
PedDevice* device = NULL;
PedDisk* disk = NULL;
PedPartition* part = NULL;
bool result = false;
cPartition partition;
ped_device_probe_all ();
device = ped_device_get(deviceName.c_str());
if (device == NULL)
{
LOG_PARTED_ERROR("ped_device_get('%s') returned NULL", deviceName.c_str());
result = false;
goto cleanup;
} // if
disk = ped_disk_new(device);
if (disk == NULL)
{
LOG_PARTED_ERROR("ped_disk_new(%p) returned NULL for device %s",
disk, deviceName.c_str());
result = false;
goto cleanup;
} // if
result = true;
partitions.clear();
// iterate over found paritions
for (part = ped_disk_next_partition (disk, NULL);
part;
part = ped_disk_next_partition (disk, part))
{
if (part->num < 0)
{
LOG_PARTED_WARN("got negative partition number := %d! in device %s",
part->num,
deviceName.c_str());
continue;
}
/* device name to which this partition belongs */
partition.deviceName = deviceName;
partition.number = part->num;
/* convert from number of blocks to number of Megabytes MiB*/
partition.size = (part->geom.length * device->sector_size) /(1024 * 1024);
partition.filesystem = (part->fs_type) ? part->fs_type->name : "";
/* partition type , avoid extended partitions and freespace ...*/
partition.mountable = ((part->type&PED_PARTITION_LOGICAL)
||(part->type==PED_PARTITION_NORMAL));
/* add to partition list */
partitions.push_back (partition);
} // for
cleanup:
/* clean up */
if (disk)
ped_disk_destroy (disk);
if (device)
ped_device_destroy (device);
return result;
} // GetPartitions()
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;
}
Device::~Device()
{
ped_device_destroy( dev_ );
delete part_table_;
delete unit_;
}
