END_TEST
int
main (int argc, char **argv)
{
set_program_name (argv[0]);
int number_failed;
Suite* suite = suite_create ("Symlink");
TCase* tcase_symlink = tcase_create ("/dev/mapper symlink");
/* Fail when an exception is raised */
ped_exception_set_handler (_test_exception_handler);
tcase_add_checked_fixture (tcase_symlink, create_disk, destroy_disk);
tcase_add_test (tcase_symlink, test_symlink);
/* Disable timeout for this test */
tcase_set_timeout (tcase_symlink, 0);
suite_add_tcase (suite, tcase_symlink);
SRunner* srunner = srunner_create (suite);
srunner_run_all (srunner, CK_VERBOSE);
number_failed = srunner_ntests_failed (srunner);
srunner_free (srunner);
return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
void
done_ui ()
{
ped_exception_set_handler (NULL);
done_ex_opt_str ();
done_state_str ();
done_alignment_type_str ();
str_list_destroy (fs_type_list);
str_list_destroy (disk_type_list);
}
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
init_ui ()
{
if (!init_ex_opt_str ()
|| !init_state_str ()
|| !init_alignment_type_str ()
|| !init_fs_type_str ()
|| !init_disk_type_str ())
return 0;
ped_exception_set_handler (exception_handler);
#ifdef SA_SIGINFO
sigset_t curr;
sigfillset (&curr);
sig_segv.sa_sigaction = &sa_sigsegv_handler;
sig_int.sa_sigaction = &sa_sigint_handler;
sig_fpe.sa_sigaction = &sa_sigfpe_handler;
sig_ill.sa_sigaction = &sa_sigill_handler;
sig_segv.sa_mask =
sig_int.sa_mask =
sig_fpe.sa_mask =
sig_ill.sa_mask = curr;
sig_segv.sa_flags =
sig_int.sa_flags =
sig_fpe.sa_flags =
sig_ill.sa_flags = SA_SIGINFO;
sigaction (SIGSEGV, &sig_segv, NULL);
sigaction (SIGINT, &sig_int, NULL);
sigaction (SIGFPE, &sig_fpe, NULL);
sigaction (SIGILL, &sig_ill, NULL);
#else
signal (SIGSEGV, s_sigsegv_handler);
signal (SIGINT, s_sigint_handler);
signal (SIGFPE, s_sigfpe_handler);
signal (SIGILL, s_sigill_handler);
#endif /* SA_SIGINFO */
return 1;
}
int detect_parts(int noswap)
{
PedDevice *dev = NULL;
PedDisk *disk = NULL;
if(parts)
{
g_list_free(parts);
parts = NULL;
}
if(partschk)
{
g_list_free(partschk);
partschk = NULL;
}
ped_device_free_all();
chdir("/");
ped_exception_set_handler(peh);
ped_device_probe_all();
if(ped_device_get_next(NULL)==NULL)
// no disk detected already handled before, no need to inform
// the user about this
return(1);
for(dev=ped_device_get_next(NULL);dev!=NULL;dev=dev->next)
{
if(dev->read_only)
// we don't want to partition cds ;-)
continue;
disk = ped_disk_new(dev);
if(disk)
listparts(disk, noswap);
}
// software raids
detect_raids();
return(0);
}
int
main(void)
{
int i, state = 0, ret;
int (*states[])() = {
partition_menu,
filesystem,
mountpoint,
mountpoint_manual,
fixup, // never does an INPUT, just handles the manual mountpoint result
NULL
};
/* FIXME: How can we tell which file system modules to load? */
char *file_system_modules[] = {"ext2", "ext3", "reiserfs", "jfs", "xfs", NULL};
debconf = debconfclient_new();
debconf_capb(debconf, "backup");
ped_exception_set_handler(my_exception_handler);
for (i = 0; file_system_modules[i]; i++)
modprobe(file_system_modules[i]);
if (check_proc_mounts("")) {
// Chicken out if /target is already mounted
debconf_set(debconf,"partconf/already-mounted", "no");
debconf_input(debconf, "critical", "partconf/already-mounted");
debconf_go(debconf);
debconf_get(debconf,"partconf/already-mounted");
if (strcmp(debconf->value, "false") == 0)
return 0;
}
if (!umount_target()) {
debconf_input(debconf, "critical", "partconf/umount-failed");
debconf_go(debconf);
return 1;
}
if ((part_count = get_all_partitions(parts, MAX_PARTS, false, 0)) <= 0) {
debconf_input(debconf, "critical", "partconf/no-partitions");
debconf_go(debconf);
return 1;
}
if (get_all_filesystems() <= 0) {
debconf_input(debconf, "critical", "partconf/no-filesystems");
debconf_go(debconf);
return 1;
}
fschoices = build_fs_choices();
while (state >= 0) {
ret = states[state]();
if (ret < 0)
return 10;
else if (ret == 0 && debconf_go(debconf) == 0)
state++;
else
state--;
if (states[state] == NULL)
state = 0;
}
return ret;
}
PyMODINIT_FUNC PyInit__ped(void) {
PyObject *m = NULL;
/* init the main Python module and add methods */
m = PyModule_Create(&module_def);
/* PedUnit possible values */
PyModule_AddIntConstant(m, "UNIT_SECTOR", PED_UNIT_SECTOR);
PyModule_AddIntConstant(m, "UNIT_BYTE", PED_UNIT_BYTE);
PyModule_AddIntConstant(m, "UNIT_KILOBYTE", PED_UNIT_KILOBYTE);
PyModule_AddIntConstant(m, "UNIT_MEGABYTE", PED_UNIT_MEGABYTE);
PyModule_AddIntConstant(m, "UNIT_GIGABYTE", PED_UNIT_GIGABYTE);
PyModule_AddIntConstant(m, "UNIT_TERABYTE", PED_UNIT_TERABYTE);
PyModule_AddIntConstant(m, "UNIT_COMPACT", PED_UNIT_COMPACT);
PyModule_AddIntConstant(m, "UNIT_CYLINDER", PED_UNIT_CYLINDER);
PyModule_AddIntConstant(m, "UNIT_CHS", PED_UNIT_CHS);
PyModule_AddIntConstant(m, "UNIT_PERCENT", PED_UNIT_PERCENT);
PyModule_AddIntConstant(m, "UNIT_KIBIBYTE", PED_UNIT_KIBIBYTE);
PyModule_AddIntConstant(m, "UNIT_MEBIBYTE", PED_UNIT_MEBIBYTE);
PyModule_AddIntConstant(m, "UNIT_GIBIBYTE", PED_UNIT_GIBIBYTE);
PyModule_AddIntConstant(m, "UNIT_TEBIBYTE", PED_UNIT_TEBIBYTE);
/* add PedCHSGeometry type as _ped.CHSGeometry */
if (PyType_Ready(&_ped_CHSGeometry_Type_obj) < 0)
return NULL;
Py_INCREF(&_ped_CHSGeometry_Type_obj);
PyModule_AddObject(m, "CHSGeometry",
(PyObject *)&_ped_CHSGeometry_Type_obj);
/* add PedDevice type as _ped.Device */
if (PyType_Ready(&_ped_Device_Type_obj) < 0)
return NULL;
Py_INCREF(&_ped_Device_Type_obj);
PyModule_AddObject(m, "Device", (PyObject *)&_ped_Device_Type_obj);
PyModule_AddIntConstant(m, "DEVICE_UNKNOWN", PED_DEVICE_UNKNOWN);
PyModule_AddIntConstant(m, "DEVICE_SCSI", PED_DEVICE_SCSI);
PyModule_AddIntConstant(m, "DEVICE_IDE", PED_DEVICE_IDE);
PyModule_AddIntConstant(m, "DEVICE_DAC960", PED_DEVICE_DAC960);
PyModule_AddIntConstant(m, "DEVICE_CPQARRAY", PED_DEVICE_CPQARRAY);
PyModule_AddIntConstant(m, "DEVICE_FILE", PED_DEVICE_FILE);
PyModule_AddIntConstant(m, "DEVICE_ATARAID", PED_DEVICE_ATARAID);
PyModule_AddIntConstant(m, "DEVICE_I2O", PED_DEVICE_I2O);
PyModule_AddIntConstant(m, "DEVICE_UBD", PED_DEVICE_UBD);
PyModule_AddIntConstant(m, "DEVICE_DASD", PED_DEVICE_DASD);
PyModule_AddIntConstant(m, "DEVICE_VIODASD", PED_DEVICE_VIODASD);
PyModule_AddIntConstant(m, "DEVICE_SX8", PED_DEVICE_SX8);
PyModule_AddIntConstant(m, "DEVICE_DM", PED_DEVICE_DM);
PyModule_AddIntConstant(m, "DEVICE_XVD", PED_DEVICE_XVD);
PyModule_AddIntConstant(m, "DEVICE_SDMMC", PED_DEVICE_SDMMC);
PyModule_AddIntConstant(m, "DEVICE_VIRTBLK", PED_DEVICE_VIRTBLK);
/* add PedTimer type as _ped.Timer */
if (PyType_Ready(&_ped_Timer_Type_obj) < 0)
return NULL;
Py_INCREF(&_ped_Timer_Type_obj);
PyModule_AddObject(m, "Timer", (PyObject *)&_ped_Timer_Type_obj);
/* add PedGeometry type as _ped.Geometry */
if (PyType_Ready(&_ped_Geometry_Type_obj) < 0)
return NULL;
Py_INCREF(&_ped_Geometry_Type_obj);
PyModule_AddObject(m, "Geometry", (PyObject *)&_ped_Geometry_Type_obj);
/* add PedAlignment type as _ped.Alignment */
if (PyType_Ready(&_ped_Alignment_Type_obj) < 0)
return NULL;
Py_INCREF(&_ped_Alignment_Type_obj);
PyModule_AddObject(m, "Alignment", (PyObject *)&_ped_Alignment_Type_obj);
/* add PedConstraint type as _ped.Constraint */
if (PyType_Ready(&_ped_Constraint_Type_obj) < 0)
return NULL;
Py_INCREF(&_ped_Constraint_Type_obj);
PyModule_AddObject(m, "Constraint", (PyObject *)&_ped_Constraint_Type_obj);
/* add PedPartition type as _ped.Partition */
if (PyType_Ready(&_ped_Partition_Type_obj) < 0)
return NULL;
Py_INCREF(&_ped_Partition_Type_obj);
PyModule_AddObject(m, "Partition", (PyObject *)&_ped_Partition_Type_obj);
/* add PedDisk as _ped.Disk */
if (PyType_Ready(&_ped_Disk_Type_obj) < 0)
return NULL;
Py_INCREF(&_ped_Disk_Type_obj);
PyModule_AddObject(m, "Disk", (PyObject *)&_ped_Disk_Type_obj);
/* add PedDiskType as _ped.DiskType */
if (PyType_Ready(&_ped_DiskType_Type_obj) < 0)
return NULL;
Py_INCREF(&_ped_DiskType_Type_obj);
PyModule_AddObject(m, "DiskType", (PyObject *)&_ped_DiskType_Type_obj);
/* possible PedDiskTypeFeature values */
PyModule_AddIntConstant(m, "PARTITION_NORMAL", PED_PARTITION_NORMAL);
PyModule_AddIntConstant(m, "PARTITION_LOGICAL", PED_PARTITION_LOGICAL);
PyModule_AddIntConstant(m, "PARTITION_EXTENDED", PED_PARTITION_EXTENDED);
PyModule_AddIntConstant(m, "PARTITION_FREESPACE", PED_PARTITION_FREESPACE);
PyModule_AddIntConstant(m, "PARTITION_METADATA", PED_PARTITION_METADATA);
PyModule_AddIntConstant(m, "PARTITION_PROTECTED", PED_PARTITION_PROTECTED);
PyModule_AddIntConstant(m, "PARTITION_BOOT", PED_PARTITION_BOOT);
PyModule_AddIntConstant(m, "PARTITION_ROOT", PED_PARTITION_ROOT);
PyModule_AddIntConstant(m, "PARTITION_SWAP", PED_PARTITION_SWAP);
PyModule_AddIntConstant(m, "PARTITION_HIDDEN", PED_PARTITION_HIDDEN);
PyModule_AddIntConstant(m, "PARTITION_RAID", PED_PARTITION_RAID);
PyModule_AddIntConstant(m, "PARTITION_LVM", PED_PARTITION_LVM);
PyModule_AddIntConstant(m, "PARTITION_LBA", PED_PARTITION_LBA);
PyModule_AddIntConstant(m, "PARTITION_HPSERVICE", PED_PARTITION_HPSERVICE);
PyModule_AddIntConstant(m, "PARTITION_PALO", PED_PARTITION_PALO);
PyModule_AddIntConstant(m, "PARTITION_PREP", PED_PARTITION_PREP);
PyModule_AddIntConstant(m, "PARTITION_MSFT_RESERVED", PED_PARTITION_MSFT_RESERVED);
PyModule_AddIntConstant(m, "PARTITION_APPLE_TV_RECOVERY", PED_PARTITION_APPLE_TV_RECOVERY);
PyModule_AddIntConstant(m, "PARTITION_BIOS_GRUB", PED_PARTITION_BIOS_GRUB);
PyModule_AddIntConstant(m, "PARTITION_DIAG", PED_PARTITION_DIAG);
PyModule_AddIntConstant(m, "PARTITION_LEGACY_BOOT", PED_PARTITION_LEGACY_BOOT);
PyModule_AddIntConstant(m, "DISK_CYLINDER_ALIGNMENT", PED_DISK_CYLINDER_ALIGNMENT);
PyModule_AddIntConstant(m, "DISK_GPT_PMBR_BOOT", PED_DISK_GPT_PMBR_BOOT);
PyModule_AddIntConstant(m, "DISK_TYPE_EXTENDED", PED_DISK_TYPE_EXTENDED);
PyModule_AddIntConstant(m, "DISK_TYPE_PARTITION_NAME", PED_DISK_TYPE_PARTITION_NAME);
/* add PedFileSystemType as _ped.FileSystemType */
if (PyType_Ready(&_ped_FileSystemType_Type_obj) < 0)
return NULL;
Py_INCREF(&_ped_FileSystemType_Type_obj);
PyModule_AddObject(m, "FileSystemType",
(PyObject *)&_ped_FileSystemType_Type_obj);
/* add PedFileSystem as _ped.FileSystem */
if (PyType_Ready(&_ped_FileSystem_Type_obj) < 0)
return NULL;
Py_INCREF(&_ped_FileSystem_Type_obj);
PyModule_AddObject(m, "FileSystem", (PyObject *)&_ped_FileSystem_Type_obj);
/* add our custom exceptions */
AlignmentException = PyErr_NewException("_ped.AlignmentException", NULL,
NULL);
Py_INCREF(AlignmentException);
PyModule_AddObject(m, "AlignmentException", AlignmentException);
ConstraintException = PyErr_NewException("_ped.ConstraintException", NULL,
NULL);
Py_INCREF(ConstraintException);
PyModule_AddObject(m, "ConstraintException", ConstraintException);
CreateException = PyErr_NewException("_ped.CreateException", NULL, NULL);
Py_INCREF(CreateException);
PyModule_AddObject(m, "CreateException", CreateException);
DeviceException = PyErr_NewException("_ped.DeviceException", NULL, NULL);
Py_INCREF(DeviceException);
PyModule_AddObject(m, "DeviceException", DeviceException);
DiskException = PyErr_NewException("_ped.DiskException", NULL, NULL);
Py_INCREF(DiskException);
PyModule_AddObject(m, "DiskException", DiskException);
DiskLabelException = PyErr_NewException("_ped.DiskLabelException", NULL, NULL);
Py_INCREF(DiskLabelException);
PyModule_AddObject(m, "DiskLabelException", DiskLabelException);
FileSystemException = PyErr_NewException("_ped.FileSystemException", NULL,
NULL);
Py_INCREF(FileSystemException);
PyModule_AddObject(m, "FileSystemException", FileSystemException);
GeometryException = PyErr_NewException("_ped.GeometryException", NULL, NULL);
Py_INCREF(GeometryException);
PyModule_AddObject(m, "GeometryException", GeometryException);
IOException = PyErr_NewException("_ped.IOException", NULL, NULL);
Py_INCREF(IOException);
PyModule_AddObject(m, "IOException", IOException);
NotNeededException = PyErr_NewException("_ped.NotNeededException",
NULL, NULL);
Py_INCREF(NotNeededException);
PyModule_AddObject(m, "NotNeededException", NotNeededException);
PartedException = PyErr_NewException("_ped.PartedException", NULL, NULL);
Py_INCREF(PartedException);
PyModule_AddObject(m, "PartedException", PartedException);
PartitionException = PyErr_NewException("_ped.PartitionException", NULL,
NULL);
Py_INCREF(PartitionException);
PyModule_AddObject(m, "PartitionException", PartitionException);
TimerException = PyErr_NewException("_ped.TimerException", NULL, NULL);
Py_INCREF(TimerException);
PyModule_AddObject(m, "TimerException", TimerException);
UnknownDeviceException = PyErr_NewException("_ped.UnknownDeviceException",
NULL, NULL);
Py_INCREF(UnknownDeviceException);
PyModule_AddObject(m, "UnknownDeviceException", UnknownDeviceException);
UnknownTypeException = PyErr_NewException("_ped.UnknownTypeException", NULL,
NULL);
Py_INCREF(UnknownTypeException);
PyModule_AddObject(m, "UnknownTypeException", UnknownTypeException);
/* Set up our libparted exception handler. */
ped_exception_set_handler(partedExnHandler);
return m;
}
gboolean disk_resize_grow(const gchar* disk_path, GChildWatchFunc async_func_watcher, gpointer data) {
char command[LINE_MAX] = { 0 };
int last_partition_num;
const gchar* partition_path;
PedDevice* dev = NULL;
PedDisk* disk = NULL;
gboolean result = false;
PedPartition* partition;
PedSector start;
PedSector end;
PedGeometry geometry_start;
PedGeometry* geometry_end;
PedConstraint* constraint;
resize_fs = false;
/* to handle exceptions, i.e Fix PMBR */
ped_exception_set_handler(disk_exception_handler);
if (!disk_path) {
LOG(MOD "Disk path is empty\n");
return false;
}
dev = ped_device_get(disk_path);
if (!dev) {
LOG(MOD "Cannot get device '%s'\n", disk_path);
return false;
}
/*
* verify disk, disk_exception_handler will called
* if the disk has problems and it needs to be fixed
* and resized
*/
disk = ped_disk_new(dev);
if (!disk) {
LOG(MOD "Cannot create a new disk '%s'\n", disk_path);
return false;
}
if (!resize_fs) {
/* do not resize filesystem, it is ok */
LOG(MOD "Nothing to do with '%s' disk\n", disk_path);
return false;
}
LOG(MOD "Resizing filesystem disk '%s'\n", disk_path);
last_partition_num = ped_disk_get_last_partition_num(disk);
partition = ped_disk_get_partition(disk, last_partition_num);
if (!partition) {
LOG(MOD "Cannot get partition '%d' disk '%s'\n", last_partition_num, disk_path);
return false;
}
start = partition->geom.start;
end = (-PED_MEGABYTE_SIZE) / dev->sector_size + dev->length;
geometry_start.dev = dev;
geometry_start.start = start;
geometry_start.end = end;
geometry_start.length = 1;
geometry_end = ped_geometry_new(dev, end, 1);
if (!geometry_end) {
LOG(MOD "Cannot get partition '%d' disk '%s'\n", last_partition_num, disk_path);
return false;
}
constraint = ped_constraint_new(ped_alignment_any, ped_alignment_any, &geometry_start, geometry_end, 1, dev->length);
if (!constraint) {
LOG(MOD "Cannot create a new constraint disk '%s'\n", disk_path);
goto fail1;
}
if (!ped_disk_set_partition_geom(disk, partition, constraint, start, end)) {
LOG(MOD "Cannot set partition geometry disk '%s'\n", disk_path);
goto fail2;
}
if (!ped_disk_commit(disk)) {
LOG(MOD "Cannot write the partition table to disk '%s'\n", disk_path);
goto fail2;
}
partition_path = ped_partition_get_path(partition);
if (!partition_path) {
LOG(MOD "Cannot get partition path disk '%s'\n", disk_path);
goto fail2;
}
snprintf(command, LINE_MAX, RESIZEFS_PATH " %s", partition_path);
exec_task_async(command, async_func_watcher, data);
result = true;
LOG(MOD "Resizing filesystem done\n");
fail2:
ped_constraint_destroy (constraint);
fail1:
ped_geometry_destroy (geometry_end);
return result;
}
