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;
}
_ped_Disk *PedDisk2_ped_Disk(PedDisk *disk) {
_ped_Disk *ret = NULL;
if (disk == NULL) {
PyErr_SetString(PyExc_TypeError, "Empty PedDisk()");
return NULL;
}
ret = (_ped_Disk *) _ped_Disk_Type_obj.tp_new(&_ped_Disk_Type_obj, NULL, NULL);
if (!ret) {
ped_disk_destroy(disk);
return (_ped_Disk *) PyErr_NoMemory();
}
ret->ped_disk = disk;
ret->dev = (PyObject *) PedDevice2_ped_Device(disk->dev);
if (!ret->dev)
goto error;
ret->type = (PyObject *) PedDiskType2_ped_DiskType(disk->type);
if (!ret->type)
goto error;
return ret;
error:
Py_DECREF(ret);
return NULL;
}
PartitionTable::~PartitionTable()
{
if ( disk_ )
ped_disk_destroy( disk_ );
if ( part_list_ )
delete part_list_;
}
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;
}
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 *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;
}
int
interactive_mode (PedDevice** dev, PedDisk** disk, Command* cmd_list[])
{
StrList* list;
StrList* command_names = command_get_names (cmd_list);
commands = cmd_list; /* FIXME yucky, nasty, evil hack */
fputs (prog_name, stdout);
print_using_dev (*dev);
list = str_list_create (_(banner_msg), NULL);
str_list_print_wrap (list, screen_width (), 0, 0, stdout);
str_list_destroy (list);
while (1) {
char* word;
Command* cmd;
while (!command_line_get_word_count ()) {
if (got_ctrl_c) {
putchar ('\n');
return 1;
}
command_line_prompt_words ("(parted)", NULL,
command_names, 1);
}
word = command_line_pop_word ();
if (word) {
cmd = command_get (commands, word);
free (word);
if (cmd) {
if (!command_run (cmd, dev, disk)) {
command_line_flush ();
if (*disk) {
ped_disk_destroy (*disk);
*disk = 0;
}
}
} else
print_commands_help ();
}
}
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);
}
/* create the new fresh parttable with disk_type.
* if failure, disk_ and disk_type_ will be NULL.
*/
bool PartitionTable::create(const char* disk_type)
{
if ( disk_ )
ped_disk_destroy( disk_ );
if ( part_list_ )
delete part_list_;
disk_type_ = ped_disk_type_get(disk_type);
if ( disk_type_ == NULL )
disk_ = NULL;
else
disk_ = ped_disk_new_fresh( pdev_, disk_type_ );
if ( disk_ != NULL ) {
part_list_ = new PartitionList( this );
return true;
} else
return false;
}
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;
}
/* read the parttable.
* if no parttable exist in device, disk_ and disk_type_ == NULL.
*/
bool PartitionTable::read()
{
if (disk_type_ && disk_ && part_list_) { // already loaded
return true;
}
if ( disk_ )
ped_disk_destroy( disk_ );
if ( part_list_ )
delete part_list_;
disk_type_ = ped_disk_probe( pdev_ );
if ( disk_type_ == NULL )
disk_ = NULL;
else
disk_ = ped_disk_new( pdev_ );
if ( disk_ != NULL ) {
part_list_ = new PartitionList( this );
return true;
} else
return false;
}
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;
}
/* 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;
}
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;
}
/**
* @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()
void SystemPartitioner::init()
{
#if NONDESTRUCTIVE
emit done();
return;
#endif
// Check # of harddisks to see if RAID0-ing them makes any sense
ped_device_probe_all();
PedDevice *tmp=NULL;
int disks=0;
QString installsource(getenv("INSTALLSOURCE"));
MSG("Install source is " + installsource);
while((tmp=ped_device_get_next(tmp))) {
// FIXME workaround for parted breakage
// Skip CD-ROMs parted accidentally marks as harddisk
QString p(tmp->path);
if(!p.startsWith("/dev/sd") && (p.contains("/dev/scd") || p.contains("/dev/sr") || access(QFile::encodeName("/proc/ide/" + p.section('/', 2, 2) + "/cache"), R_OK)))
continue;
// It's not a good idea to install on a USB stick we're installing from...
if(installsource.startsWith(p))
continue;
MSG(QString("Found disk: ") + QString(tmp->path) + ":" + "/proc/ide/" + p.section('/', 2, 2) + "/" + "cache" + ":" + QString::number(access(QFile::encodeName("/proc/ide/" + p.section('/', 2, 2) + "/cache"), R_OK)));
#if 0
// Check if the drive is actually there -- some empty CF
// readers misidentify themselves...
int fd=open(tmp->path, O_RDONLY);
if(fd < 0)
continue;
char test;
if(read(fd, &test, 1) <= 0) {
close(fd);
continue;
}
close(fd);
#endif
disks++;
}
ped_device_free_all();
// Grab all disks
ped_device_probe_all();
PedFileSystemType const *ext3=ped_file_system_type_get("ext2"); // parted doesn't support ext3 creation yet, so we need this hack
PedFileSystemType const *bootext3=ped_file_system_type_get("ext2");
PedFileSystemType const *swap=ped_file_system_type_get("linux-swap");
Meminfo m;
unsigned long long swapsize=m.suggested_swap();
QStringList raidPartitions;
PedDevice *dev=NULL;
PedPartition *fspart=NULL;
PedGeometry *fsgeo=NULL;
setHelp(tr("Removing other OSes..."));
resizeEvent(0);
uint32_t bootsize=0;
#ifndef NO_RAID0
if(disks>1)
bootsize=32*1024*2; /* size is in 512 kB blocks --> we use 32 MB */
#endif
while((dev=ped_device_get_next(dev))) {
// FIXME workaround for parted breakage
QString p(dev->path);
if(!p.startsWith("/dev/sd") && (p.contains("/dev/scd") || p.contains("/dev/sr") || access(QFile::encodeName("/proc/ide/" + p.section('/', 2, 2) + "/cache"), R_OK)))
continue;
// It's not a good idea to install on a USB stick we're installing from...
if(installsource.startsWith(p))
continue;
//unsigned long long disksize=dev->length*dev->sector_size;
PedDiskType *type=ped_disk_type_get("msdos");
PedDisk *disk=ped_disk_new_fresh(dev, type);
PedGeometry *part=ped_geometry_new(dev, 0, dev->length);
if(swapsize && _swap.isEmpty() && ((unsigned long long)part->length > swapsize + bootsize)) {
// Split disk in swap and fs partitions
PedGeometry *swapgeo=ped_geometry_new(dev, 0, swapsize);
PedGeometry *bootgeo=NULL;
uint32_t fssize=part->end - swapsize;
uint32_t fsstart=swapsize+1;
if(bootsize) {
bootgeo=ped_geometry_new(dev, swapsize+1, bootsize);
fssize -= bootsize;
fsstart += bootsize;
}
fsgeo=ped_geometry_new(dev, fsstart, fssize);
PedPartition *swappart=ped_partition_new(disk, (PedPartitionType)0, swap, swapgeo->start, swapgeo->end);
PedPartition *bootpart=NULL;
if(bootsize)
bootpart=ped_partition_new(disk, (PedPartitionType)0, bootext3, bootgeo->start, bootgeo->end);
fspart=ped_partition_new(disk, (PedPartitionType)0, ext3, fsgeo->start, fsgeo->end);
if(bootsize)
ped_partition_set_flag(fspart, PED_PARTITION_RAID, 1);
ped_disk_add_partition(disk, swappart, ped_constraint_any(dev));
ped_disk_commit(disk);
ped_geometry_destroy(swapgeo);
setHelp(tr("Creating swap filesystem"));
PedFileSystem *swapfs=ped_file_system_create(&(swappart->geom), swap, NULL /*timer->timer()*/);
ped_file_system_close(swapfs);
_swap = dev->path + QString::number(swappart->num);
// Parted's swap creator is buggy
QProcess::execute("/sbin/mkswap " + _swap);
if(bootpart) {
setHelp(tr("Creating boot filesystem"));
ped_disk_add_partition(disk, bootpart, ped_constraint_any(dev));
ped_disk_commit(disk);
PedFileSystem *bootfs=ped_file_system_create(&(bootpart->geom), bootext3, timer->timer());
ped_file_system_close(bootfs);
ped_partition_set_flag(bootpart, PED_PARTITION_BOOT, 1);
ped_geometry_destroy(bootgeo);
QString devname=dev->path + QString::number(bootpart->num);
_size.insert(devname, bootpart->geom.length);
if(_rootfs == "ext3") {
Ext3FS e3(devname);
e3.addJournal(0);
e3.setCheckInterval(0);
e3.setCheckMountcount(-1);
e3.setDirIndex();
} else {
QProcess::execute("/sbin/mkfs." + _rootfs + " " + _mkfsopts + " " + devname);
}
if(!_postmkfs.isEmpty())
QProcess::execute(_postmkfs + " " + devname);
_partitions.insert(devname, FileSystem("/boot", _rootfs));
}
} else {
// Grab the whole disk for filesystem
fsgeo=ped_constraint_solve_max(ped_constraint_any(dev));
fspart=ped_partition_new(disk, (PedPartitionType)0, ext3, part->start, part->end);
if(bootsize)
ped_partition_set_flag(fspart, PED_PARTITION_RAID, 1);
}
ped_disk_add_partition(disk, fspart, ped_constraint_any(dev));
if(!bootsize)
ped_partition_set_flag(fspart, PED_PARTITION_BOOT, 1);
ped_disk_commit(disk);
if(!bootsize) {
setHelp(tr("Creating Linux filesystem"));
PedFileSystem *fs=ped_file_system_create(&(fspart->geom), ext3, timer->timer());
_totalSize += fspart->geom.length;
ped_file_system_close(fs);
}
ped_geometry_destroy(fsgeo);
// Convert to ext3 and turn off checking
QString devname=dev->path + QString::number(fspart->num);
if(bootsize)
raidPartitions.append(devname);
else if(!_partitions.hasMountpoint("/"))
_partitions.insert(devname, FileSystem("/", _rootfs));
else {
QString mp(devname);
mp.replace("/dev", "/mnt");
_partitions.insert(devname, FileSystem(mp, _rootfs));
}
_size.insert(devname, fspart->geom.length);
if(!bootsize) {
if(_rootfs == "ext3") {
Ext3FS e3(devname);
e3.addJournal(0);
e3.setCheckInterval(0);
e3.setCheckMountcount(-1);
e3.setDirIndex();
} else {
QProcess::execute("/sbin/mkfs." + _rootfs + " " + _mkfsopts + " " + devname);
}
if(!_postmkfs.isEmpty())
QProcess::execute(_postmkfs + " " + devname);
ped_disk_destroy(disk);
}
}
if(bootsize) {
setHelp(tr("Combining disks..."));
// Make sure we can read the array we're building first...
Modules::instance()->loadWithDeps("md");
Modules::instance()->loadWithDeps("raid0");
// Now create it
FILE *f=fopen("/tmp/mdadm.conf", "w");
if(!f)
QMessageBox::information(0, "debug", QString("Failed to create mdadm.conf: ") + strerror(errno));
fprintf(f, "DEVICE partitions");
fprintf(f, "ARRAY /dev/md0 name=ArkLinux devices=%s level=0 num-devices=%u\n", qPrintable(raidPartitions.join(",")), raidPartitions.count());
fprintf(f, "MAILADDR root@localhost\n");
fclose(f);
QString command="/sbin/mdadm --create -e 1.2 --chunk=32 --level=0 --raid-devices=" + QString::number(raidPartitions.count()) + " --name=ArkLinux --force /dev/md0 " + raidPartitions.join(" ");
QProcess::execute(command);
if(_rootfs == "ext3") {
QProcess::execute("/sbin/mke2fs -j /dev/md0");
Ext3FS e3("/dev/md0");
e3.setCheckInterval(0);
e3.setCheckMountcount(-1);
e3.setDirIndex();
} else {
QProcess::execute("/sbin/mkfs." + _rootfs + " " + _mkfsopts + " /dev/md0");
}
if(!_postmkfs.isEmpty())
QProcess::execute(_postmkfs + " /dev/md0");
_partitions.insert("/dev/md0", FileSystem("/", _rootfs));
_size.clear();
_size.insert("/dev/md0", _totalSize);
}
// We don't need a UI to take the whole system - we're done.
emit done();
}
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;
}
void MParted::MParted_Core::closeDisk() {
if (pedDisk)
ped_disk_destroy(pedDisk);
pedDisk = NULL ;
}
LibPartedPartitionTable::~LibPartedPartitionTable()
{
ped_disk_destroy(m_PedDisk);
}
