/* XXX: Remove this function at some point in the future. The deprecation
* warning tells people what they should be doing.
*/
PyObject *py_ped_constraint_duplicate(PyObject *s, PyObject *args) {
PedConstraint *constraint = NULL, *dup_constraint = NULL;
_ped_Constraint *ret = NULL;
constraint = _ped_Constraint2PedConstraint(s);
if (constraint == NULL) {
return NULL;
}
if (PyErr_WarnEx(PyExc_DeprecationWarning,
"use copy.deepcopy() to duplicate a _ped.Constraint",
1) == -1) {
return NULL;
}
dup_constraint = ped_constraint_duplicate(constraint);
ped_constraint_destroy(constraint);
if (dup_constraint) {
ret = PedConstraint2_ped_Constraint(dup_constraint);
} else {
PyErr_SetString(CreateException, "Could not duplicate constraint");
return NULL;
}
ped_constraint_destroy(dup_constraint);
return (PyObject *) ret;
}
static int
pc98_alloc_metadata (PedDisk* disk)
{
PedPartition* new_part;
PedConstraint* constraint_any = NULL;
PedSector cyl_size;
PED_ASSERT (disk != NULL);
PED_ASSERT (disk->dev != NULL);
constraint_any = ped_constraint_any (disk->dev);
cyl_size = disk->dev->hw_geom.sectors * disk->dev->hw_geom.heads;
new_part = ped_partition_new (disk, PED_PARTITION_METADATA, NULL,
0, cyl_size - 1);
if (!new_part)
goto error;
if (!ped_disk_add_partition (disk, new_part, constraint_any)) {
ped_partition_destroy (new_part);
goto error;
}
ped_constraint_destroy (constraint_any);
return 1;
error:
ped_constraint_destroy (constraint_any);
return 0;
}
static int
amiga_alloc_metadata (PedDisk* disk)
{
PedPartition* new_part;
PedConstraint* constraint_any = NULL;
PED_ASSERT (disk != NULL);
PED_ASSERT (disk->dev != NULL);
constraint_any = ped_constraint_any (disk->dev);
/* Allocate space for the RDB */
new_part = ped_partition_new (disk, PED_PARTITION_METADATA, NULL,
0, MAX_RDB_BLOCK);
if (!new_part)
goto error;
if (!ped_disk_add_partition (disk, new_part, constraint_any)) {
ped_partition_destroy (new_part);
goto error;
}
ped_constraint_destroy (constraint_any);
return 1;
error:
ped_constraint_destroy (constraint_any);
return 0;
}
static int
bsd_alloc_metadata (PedDisk* disk)
{
PedPartition* new_part;
PedConstraint* constraint_any = NULL;
PED_ASSERT (disk != NULL);
PED_ASSERT (disk->dev != NULL);
constraint_any = ped_constraint_any (disk->dev);
/* allocate 1 sector for the disk label at the start */
new_part = ped_partition_new (disk, PED_PARTITION_METADATA, NULL, 0, 0);
if (!new_part)
goto error;
if (!ped_disk_add_partition (disk, new_part, constraint_any)) {
ped_partition_destroy (new_part);
goto error;
}
ped_constraint_destroy (constraint_any);
return 1;
error:
ped_constraint_destroy (constraint_any);
return 0;
}
PyObject *py_ped_constraint_is_solution(PyObject *s, PyObject *args) {
PyObject *in_geometry = NULL;
PedConstraint *constraint = NULL;
PedGeometry *out_geometry = NULL;
int ret = 0;
if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj,
&in_geometry)) {
return NULL;
}
constraint = _ped_Constraint2PedConstraint(s);
if (constraint == NULL) {
return NULL;
}
out_geometry = _ped_Geometry2PedGeometry(in_geometry);
if (out_geometry == NULL) {
ped_constraint_destroy(constraint);
return NULL;
}
ret = ped_constraint_is_solution(constraint, out_geometry);
ped_constraint_destroy(constraint);
if (ret) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
static int
loop_read (PedDisk* disk)
{
PedDevice* dev = NULL;
PedGeometry* geom;
PedFileSystemType* fs_type;
PedPartition* part;
PedConstraint* constraint_any;
PED_ASSERT (disk != NULL);
dev = disk->dev;
constraint_any = ped_constraint_any (dev);
ped_disk_delete_all (disk);
void *buf;
if (!ptt_read_sector (dev, 0, &buf))
goto error;
int found_sig = !strncmp (buf, LOOP_SIGNATURE, strlen (LOOP_SIGNATURE));
free (buf);
if (found_sig) {
ped_constraint_destroy (constraint_any);
return 1;
}
geom = ped_geometry_new (dev, 0, dev->length);
if (!geom)
goto error;
fs_type = ped_file_system_probe (geom);
if (!fs_type)
goto error_free_geom;
part = ped_partition_new (disk, PED_PARTITION_NORMAL,
fs_type, geom->start, geom->end);
ped_geometry_destroy (geom);
if (!part)
goto error;
part->fs_type = fs_type;
if (!ped_disk_add_partition (disk, part, constraint_any))
goto error;
ped_constraint_destroy (constraint_any);
return 1;
error_free_geom:
ped_geometry_destroy (geom);
error:
ped_constraint_destroy (constraint_any);
return 0;
}
PyObject *py_ped_constraint_solve_max(PyObject *s, PyObject *args) {
PedConstraint *constraint = NULL;
PedGeometry *geometry = NULL;
_ped_Geometry *ret = NULL;
constraint = _ped_Constraint2PedConstraint(s);
if (constraint == NULL) {
return NULL;
}
geometry = ped_constraint_solve_max(constraint);
ped_constraint_destroy(constraint);
if (geometry) {
ret = PedGeometry2_ped_Geometry(geometry);
}
else {
if (partedExnRaised) {
partedExnRaised = 0;
if (!PyErr_ExceptionMatches(PartedException) &&
!PyErr_ExceptionMatches(PyExc_NotImplementedError))
PyErr_SetString(ConstraintException, partedExnMessage);
}
else
PyErr_SetString(PyExc_ArithmeticError, "Could not find largest region satisfying constraint");
return NULL;
}
return (PyObject *) ret;
}
PyObject *py_ped_constraint_any(PyObject *s, PyObject *args) {
PyObject *in_device = NULL;
PedDevice *out_device = NULL;
PedConstraint *constraint = NULL;
_ped_Constraint *ret = NULL;
if (!PyArg_ParseTuple(args, "O!", &_ped_Device_Type_obj, &in_device)) {
return NULL;
}
out_device = _ped_Device2PedDevice(in_device);
if (out_device == NULL) {
return NULL;
}
constraint = ped_constraint_any(out_device);
if (constraint) {
ret = PedConstraint2_ped_Constraint(constraint);
}
else {
PyErr_SetString(CreateException, "Could not create new constraint");
return NULL;
}
ped_constraint_destroy(constraint);
return (PyObject *) ret;
}
PyObject *py_ped_constraint_new_from_max(PyObject *s, PyObject *args) {
PyObject *in_max = NULL;
PedGeometry *out_max = NULL;
PedConstraint *constraint = NULL;
_ped_Constraint *ret = NULL;
if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_max)) {
return NULL;
}
out_max = _ped_Geometry2PedGeometry(in_max);
if (out_max == NULL) {
return NULL;
}
constraint = ped_constraint_new_from_max(out_max);
if (constraint) {
ret = PedConstraint2_ped_Constraint(constraint);
}
else {
PyErr_SetString(CreateException, "Could not create new constraint from max");
return NULL;
}
ped_constraint_destroy(constraint);
return (PyObject *) ret;
}
bool LibPartedPartitionTable::updateGeometry(Report& report, const Partition& partition, qint64 sector_start, qint64 sector_end)
{
Q_ASSERT(partition.devicePath() == QString::fromUtf8(pedDevice()->path));
bool rval = false;
PedPartition* pedPartition = (partition.roles().has(PartitionRole::Extended))
? ped_disk_extended_partition(pedDisk())
: ped_disk_get_partition_by_sector(pedDisk(), partition.firstSector());
if (pedPartition) {
if (PedGeometry* pedGeometry = ped_geometry_new(pedDevice(), sector_start, sector_end - sector_start + 1)) {
if (PedConstraint* pedConstraint = ped_constraint_exact(pedGeometry)) {
if (ped_disk_set_partition_geom(pedDisk(), pedPartition, pedConstraint, sector_start, sector_end))
rval = true;
else
report.line() << xi18nc("@info:progress", "Could not set geometry for partition <filename>%1</filename> while trying to resize/move it.", partition.deviceNode());
ped_constraint_destroy(pedConstraint);
} else
report.line() << xi18nc("@info:progress", "Could not get constraint for partition <filename>%1</filename> while trying to resize/move it.", partition.deviceNode());
ped_geometry_destroy(pedGeometry);
} else
report.line() << xi18nc("@info:progress", "Could not get geometry for partition <filename>%1</filename> while trying to resize/move it.", partition.deviceNode());
} else
report.line() << xi18nc("@info:progress", "Could not open partition <filename>%1</filename> while trying to resize/move it.", partition.deviceNode());
return rval;
}
static int
dvh_alloc_metadata (PedDisk* disk)
{
PedPartition* part;
PedPartition* extended_part;
PedPartitionType metadata_type;
PED_ASSERT(disk != NULL);
/* We don't need to "protect" the start of the disk from the volume
* header.
*/
extended_part = ped_disk_extended_partition (disk);
if (extended_part && extended_part->geom.start == 0)
metadata_type = PED_PARTITION_METADATA | PED_PARTITION_LOGICAL;
else
metadata_type = PED_PARTITION_METADATA;
part = ped_partition_new (disk, metadata_type, NULL, 0, 0);
if (!part)
goto error;
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)
return 1;
ped_partition_destroy (part);
error:
return 0;
}
PyObject *py_ped_constraint_exact(PyObject *s, PyObject *args) {
PyObject *in_geometry = NULL;
PedGeometry *out_geometry = NULL;
PedConstraint *constraint = NULL;
_ped_Constraint *ret = NULL;
if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_geometry)) {
return NULL;
}
out_geometry = _ped_Geometry2PedGeometry(in_geometry);
if (out_geometry == NULL) {
return NULL;
}
constraint = ped_constraint_exact(out_geometry);
if (constraint) {
ret = PedConstraint2_ped_Constraint(constraint);
}
else {
PyErr_SetString(CreateException, "Could not create exact constraint");
return NULL;
}
ped_constraint_destroy(constraint);
return (PyObject *) ret;
}
QString LibPartedPartitionTable::createPartition(Report& report, const Partition& partition)
{
Q_ASSERT(partition.devicePath() == QString::fromUtf8(pedDevice()->path));
QString rval = QString();
// According to libParted docs, PedPartitionType can be "nullptr if unknown". That's obviously wrong,
// it's a typedef for an enum. So let's use something the libparted devs will hopefully never
// use...
PedPartitionType pedType = static_cast<PedPartitionType>(0xffffffff);
if (partition.roles().has(PartitionRole::Extended))
pedType = PED_PARTITION_EXTENDED;
else if (partition.roles().has(PartitionRole::Logical))
pedType = PED_PARTITION_LOGICAL;
else if (partition.roles().has(PartitionRole::Primary))
pedType = PED_PARTITION_NORMAL;
if (pedType == static_cast<int>(0xffffffff)) {
report.line() << xi18nc("@info:progress", "Unknown partition role for new partition <filename>%1</filename> (roles: %2)", partition.deviceNode(), partition.roles().toString());
return QString();
}
PedFileSystemType* pedFsType = (partition.roles().has(PartitionRole::Extended) || partition.fileSystem().type() == FileSystem::Unformatted) ? nullptr : getPedFileSystemType(partition.fileSystem().type());
PedPartition* pedPartition = ped_partition_new(pedDisk(), pedType, pedFsType, partition.firstSector(), partition.lastSector());
if (pedPartition == nullptr) {
report.line() << xi18nc("@info:progress", "Failed to create new partition <filename>%1</filename>.", partition.deviceNode());
return QString();
}
PedConstraint* pedConstraint = nullptr;
PedGeometry* pedGeometry = ped_geometry_new(pedDevice(), partition.firstSector(), partition.length());
if (pedGeometry)
pedConstraint = ped_constraint_exact(pedGeometry);
ped_geometry_destroy(pedGeometry);
if (pedConstraint == nullptr) {
report.line() << i18nc("@info:progress", "Failed to create a new partition: could not get geometry for constraint.");
return QString();
}
if (ped_disk_add_partition(pedDisk(), pedPartition, pedConstraint)) {
char *pedPath = ped_partition_get_path(pedPartition);
rval = QString::fromUtf8(pedPath);
free(pedPath);
}
else {
report.line() << xi18nc("@info:progress", "Failed to add partition <filename>%1</filename> to device <filename>%2</filename>.", partition.deviceNode(), QString::fromUtf8(pedDisk()->dev->path));
report.line() << LibPartedBackend::lastPartedExceptionMessage();
}
ped_constraint_destroy(pedConstraint);
return rval;
}
static PedDisk*
dvh_alloc (const PedDevice* dev)
{
PedDisk* disk;
DVHDiskData* dvh_disk_data;
PedPartition* volume_part;
PedConstraint* constraint_any;
disk = _ped_disk_alloc (dev, &dvh_disk_type);
if (!disk)
goto error;
disk->disk_specific = dvh_disk_data
= ped_malloc (sizeof (DVHDiskData));
if (!dvh_disk_data)
goto error_free_disk;
memset (&dvh_disk_data->dev_params, 0,
sizeof (struct device_parameters));
dvh_disk_data->swap = 0;
dvh_disk_data->root = 0;
dvh_disk_data->boot = 0;
volume_part = ped_partition_new (disk, PED_PARTITION_EXTENDED, NULL,
0, PTYPE_VOLHDR_DFLTSZ - 1);
if (!volume_part)
goto error_free_disk_specific;
volume_part->num = PNUM_VOLHDR + 1;
constraint_any = ped_constraint_any (dev);
if (!ped_disk_add_partition (disk, volume_part, constraint_any))
goto error_destroy_constraint_any;
ped_constraint_destroy (constraint_any);
return disk;
error_destroy_constraint_any:
ped_constraint_destroy (constraint_any);
ped_partition_destroy (volume_part);
error_free_disk_specific:
free (disk->disk_specific);
error_free_disk:
free (disk);
error:
return NULL;
}
/* try to make a reasonable volume header partition... */
static PedExceptionOption
_handle_no_volume_header (PedDisk* disk)
{
PedExceptionOption ret;
PedPartition* part;
PedConstraint* constraint;
switch (ped_exception_throw (
PED_EXCEPTION_WARNING,
PED_EXCEPTION_FIX + PED_EXCEPTION_CANCEL,
_("%s has no extended partition (volume header partition)."),
disk->dev->path)) {
case PED_EXCEPTION_UNHANDLED:
case PED_EXCEPTION_FIX:
default:
part = ped_partition_new (
disk, PED_PARTITION_EXTENDED, NULL,
0, PTYPE_VOLHDR_DFLTSZ - 1);
if (!part)
goto error;
part->num = PNUM_VOLHDR + 1;
constraint = ped_constraint_any (part->disk->dev);
if (!constraint)
goto error_destroy_part;
if (!ped_disk_add_partition (disk, part, constraint))
goto error_destroy_constraint;
ped_constraint_destroy (constraint);
ret = PED_EXCEPTION_FIX;
break;
case PED_EXCEPTION_CANCEL:
goto error;
}
return ret;
error_destroy_constraint:
ped_constraint_destroy (constraint);
error_destroy_part:
ped_partition_destroy (part);
error:
return PED_EXCEPTION_CANCEL;
}
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;
}
bool MParted::MParted_Core::resizePartition(MParted::Partition & partition_old, MParted::Partition & partition_new) {
if (partition_new.getSectorLength() == partition_old.getSectorLength()
&& partition_new.sector_start == partition_old.sector_start)
return true; // New and old partition have the same size and position. Hence skipping this operation
bool return_value = false;
PedConstraint *constraint = NULL;
PedPartition *pedPartition = NULL;
if (!openDeviceAndDisk(partition_old.devicePath))
return false;
if (partition_old.type == MParted::TYPE_EXTENDED)
pedPartition = ped_disk_extended_partition(pedDisk);
else
pedPartition = ped_disk_get_partition_by_sector(pedDisk, partition_old.getSector());
if (pedPartition) {
if (partition_new.alignment == MParted::ALIGN_MEBIBYTE) {
PedGeometry *geom = ped_geometry_new(pedDevice,
partition_new.sector_start,
partition_new.getSectorLength());
constraint = ped_constraint_exact(geom);
}
else {
constraint = ped_constraint_any(pedDevice);
}
if (constraint) {
if (ped_disk_set_partition_geom(pedDisk,
pedPartition,
constraint,
partition_new.sector_start,
partition_new.sector_end)
&& commit())
{
partition_new.sector_start = pedPartition->geom.start;
partition_new.sector_end = pedPartition->geom.end;
return_value = true;
}
ped_constraint_destroy(constraint);
}
}
closeDeviceAndDisk();
return return_value;
}
PyObject *py_ped_constraint_intersect(PyObject *s, PyObject *args) {
PyObject *in_constraintB = NULL;
PedConstraint *constraintA = NULL, *constraintB = NULL;
PedConstraint *constraint = NULL;
_ped_Constraint *ret = NULL;
if (!PyArg_ParseTuple(args, "O!", &_ped_Constraint_Type_obj,
&in_constraintB)) {
return NULL;
}
constraintA = _ped_Constraint2PedConstraint(s);
if (constraintA == NULL) {
return NULL;
}
constraintB = _ped_Constraint2PedConstraint(in_constraintB);
if (constraintB == NULL) {
ped_constraint_destroy(constraintA);
return NULL;
}
constraint = ped_constraint_intersect(constraintA, constraintB);
ped_constraint_destroy(constraintA);
ped_constraint_destroy(constraintB);
if (constraint) {
ret = PedConstraint2_ped_Constraint(constraint);
}
else {
PyErr_SetString(PyExc_ArithmeticError, "Could not find constraint intersection");
return NULL;
}
ped_constraint_destroy(constraint);
return (PyObject *) ret;
}
static int
bsd_read (PedDisk* disk)
{
BSDDiskData* bsd_specific = (BSDDiskData*) disk->disk_specific;
BSDRawLabel* label;
int i;
ped_disk_delete_all (disk);
void *s0;
if (!ptt_read_sector (disk->dev, 0, &s0))
return 0;
memcpy (bsd_specific->boot_code, s0, sizeof (bsd_specific->boot_code));
free (s0);
label = (BSDRawLabel *) (bsd_specific->boot_code + BSD_LABEL_OFFSET);
for (i = 1; i <= BSD_MAXPARTITIONS; i++) {
PedPartition* part;
BSDPartitionData* bsd_part_data;
PedSector start;
PedSector end;
PedConstraint* constraint_exact;
if (!label->d_partitions[i - 1].p_size
|| !label->d_partitions[i - 1].p_fstype)
continue;
start = PED_LE32_TO_CPU(label->d_partitions[i - 1].p_offset);
end = PED_LE32_TO_CPU(label->d_partitions[i - 1].p_offset)
+ PED_LE32_TO_CPU(label->d_partitions[i - 1].p_size) - 1;
part = ped_partition_new (disk, PED_PARTITION_NORMAL,
NULL, start, end);
if (!part)
goto error;
bsd_part_data = part->disk_specific;
bsd_part_data->type = label->d_partitions[i - 1].p_fstype;
part->num = i;
part->fs_type = ped_file_system_probe (&part->geom);
constraint_exact = ped_constraint_exact (&part->geom);
if (!ped_disk_add_partition (disk, part, constraint_exact))
goto error;
ped_constraint_destroy (constraint_exact);
}
return 1;
error:
return 0;
}
PyObject *py_ped_constraint_solve_nearest(PyObject *s, PyObject *args) {
PyObject *in_geometry = NULL;
PedConstraint *constraint = NULL;
PedGeometry *out_geometry = NULL;
PedGeometry *geometry = NULL;
_ped_Geometry *ret = NULL;
if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj,
&in_geometry)) {
return NULL;
}
constraint = _ped_Constraint2PedConstraint(s);
if (constraint == NULL) {
return NULL;
}
out_geometry = _ped_Geometry2PedGeometry(in_geometry);
if (out_geometry == NULL) {
ped_constraint_destroy(constraint);
return NULL;
}
geometry = ped_constraint_solve_nearest(constraint, out_geometry);
ped_constraint_destroy(constraint);
if (geometry) {
ret = PedGeometry2_ped_Geometry(geometry);
}
else {
PyErr_SetString(PyExc_ArithmeticError, "Could not find region nearest to constraint for given geometry");
return NULL;
}
return (PyObject *) ret;
}
PedPartition* create_and_add_partition(PedDisk* disk, PedPartitionType type,
const PedFileSystemType* fs,
PedSector start, PedSector end)
{
PedPartition* part = ped_partition_new (disk, type, fs, start, end);
g_return_val_if_fail(part != NULL, FALSE);
PedGeometry* geom = ped_geometry_new (disk->dev, start, end - start + 1);
g_assert(geom != NULL);
PedConstraint* constraint = ped_constraint_new_from_max (geom);
g_assert(constraint != NULL);
ped_disk_add_partition(disk, part, constraint);
ped_constraint_destroy (constraint);
ped_geometry_destroy (geom);
return part;
}
/**
* 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;
}
PyObject *py_ped_device_get_optimal_aligned_constraint(PyObject *s, PyObject *args) {
PedDevice *device = NULL;
PedConstraint *constraint = NULL;
_ped_Constraint *ret = NULL;
device = _ped_Device2PedDevice(s);
if (device == NULL) {
return NULL;
}
constraint = ped_device_get_optimal_aligned_constraint(device);
if (!constraint) {
PyErr_SetString(CreateException, "Could not create constraint");
return NULL;
}
ret = PedConstraint2_ped_Constraint(constraint);
ped_constraint_destroy(constraint);
return (PyObject *) ret;
}
/* 1:1 function mappings for constraint.h in libparted */
PyObject *py_ped_constraint_new_from_min_max(PyObject *s, PyObject *args) {
PyObject *in_min = NULL, *in_max = NULL;
PedGeometry *out_min = NULL, *out_max = NULL;
PedConstraint *constraint = NULL;
_ped_Constraint *ret = NULL;
if (!PyArg_ParseTuple(args, "O!O!", &_ped_Geometry_Type_obj, &in_min,
&_ped_Geometry_Type_obj, &in_max)) {
return NULL;
}
out_min = _ped_Geometry2PedGeometry(in_min);
if (out_min == NULL) {
return NULL;
}
out_max = _ped_Geometry2PedGeometry(in_max);
if (out_max == NULL) {
return NULL;
}
/* ped_constraint_new_from_min_max will ASSERT if this isn't enforced. */
if (!ped_geometry_test_inside(out_max, out_min)) {
PyErr_SetString(CreateException, "min geometry must be contained within max geometry");
return NULL;
}
constraint = ped_constraint_new_from_min_max(out_min, out_max);
if (constraint) {
ret = PedConstraint2_ped_Constraint(constraint);
}
else {
PyErr_SetString(CreateException, "Could not create new constraint from min/max");
return NULL;
}
ped_constraint_destroy(constraint);
return (PyObject *) ret;
}
bool MParted::MParted_Core::calculateExactGeom(MParted::Partition & partition_old, MParted::Partition & partition_new) {
bool success = false;
if (!openDeviceAndDisk(partition_old.devicePath))
return false;
PedPartition *pedPartition = NULL;
if (partition_old.type == MParted::TYPE_EXTENDED)
pedPartition = ped_disk_extended_partition(pedDisk);
else
pedPartition = ped_disk_get_partition_by_sector(pedDisk, partition_old.getSector());
if (pedPartition) {
PedConstraint *constraint = NULL;
constraint = ped_constraint_any(pedDevice);
if (constraint) {
if (ped_disk_set_partition_geom(pedDisk,
pedPartition,
constraint,
partition_new.sector_start,
partition_new.sector_end))
{
partition_new.sector_start = pedPartition->geom.start;
partition_new.sector_end = pedPartition->geom.end;
success = true;
}
ped_constraint_destroy(constraint);
}
}
closeDeviceAndDisk() ;
return success;
}
static int
read_table (PedDisk* disk)
{
int i;
PC98RawTable table;
PedConstraint* constraint_any;
PED_ASSERT (disk != NULL);
PED_ASSERT (disk->dev != NULL);
constraint_any = ped_constraint_any (disk->dev);
if (!ped_device_read (disk->dev, (void*) &table, 0, 2))
goto error;
if (!pc98_check_magic(&table)) {
if (ped_exception_throw (
PED_EXCEPTION_ERROR, PED_EXCEPTION_IGNORE_CANCEL,
_("Invalid partition table on %s."),
disk->dev->path))
goto error;
}
for (i = 0; i < MAX_PART_COUNT; i++) {
PC98RawPartition* raw_part;
PedPartition* part;
PC98PartitionData* pc98_data;
PedSector part_start;
PedSector part_end;
raw_part = &table.partitions [i];
if (is_unused_partition(raw_part))
continue;
part_start = legacy_start (disk, raw_part);
part_end = legacy_end (disk, raw_part);
part = ped_partition_new (disk, PED_PARTITION_NORMAL,
NULL, part_start, part_end);
if (!part)
goto error;
pc98_data = part->disk_specific;
PED_ASSERT (pc98_data != NULL);
pc98_data->system = (raw_part->mid << 8) | raw_part->sid;
pc98_data->boot = GET_BIT(raw_part->mid, 7);
pc98_data->hidden = !GET_BIT(raw_part->sid, 7);
ped_partition_set_name (part, raw_part->name);
pc98_data->ipl_sector = chs_to_sector (
disk->dev,
PED_LE16_TO_CPU(raw_part->ipl_cyl),
raw_part->ipl_head,
raw_part->ipl_sect);
/* hack */
if (pc98_data->ipl_sector == part->geom.start)
pc98_data->ipl_sector = 0;
part->num = i + 1;
if (!ped_disk_add_partition (disk, part, constraint_any))
goto error;
if (part->geom.start != part_start
|| part->geom.end != part_end) {
ped_exception_throw (
PED_EXCEPTION_NO_FEATURE,
PED_EXCEPTION_CANCEL,
_("Partition %d isn't aligned to cylinder "
"boundaries. This is still unsupported."),
part->num);
goto error;
}
part->fs_type = ped_file_system_probe (&part->geom);
}
ped_constraint_destroy (constraint_any);
return 1;
error:
ped_disk_delete_all (disk);
ped_constraint_destroy (constraint_any);
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;
}
bool CreatePartitionJob::run(Report& parent)
{
Q_ASSERT(partition().devicePath() == device().deviceNode());
bool rval = false;
Report* report = jobStarted(parent);
// According to libParted docs, PedPartitionType can be "NULL if unknown". That's obviously wrong,
// it's a typedef for an enum. So let's use something the libparted devs will hopefully never
// use...
PedPartitionType pedType = static_cast<PedPartitionType>(0xffffffff);
if (partition().roles().has(PartitionRole::Extended))
pedType = PED_PARTITION_EXTENDED;
else if (partition().roles().has(PartitionRole::Logical))
pedType = PED_PARTITION_LOGICAL;
else if (partition().roles().has(PartitionRole::Primary))
pedType = PED_PARTITION_NORMAL;
if (pedType == static_cast<int>(0xffffffff))
{
report->line() << i18nc("@info/plain", "Unknown partition role for new partition <filename>%1</filename> (roles: %2)", partition().deviceNode(), partition().roles().toString());
}
else if (openPed(device().deviceNode()))
{
PedFileSystemType* pedFsType = (partition().roles().has(PartitionRole::Extended) || partition().fileSystem().type() == FileSystem::Unformatted) ? NULL : getPedFileSystemType(partition().fileSystem().type());
PedPartition* pedPartition = ped_partition_new(pedDisk(), pedType, pedFsType, partition().firstSector(), partition().lastSector());
if (pedPartition)
{
PedConstraint* pedConstraint = NULL;
PedGeometry* pedGeometry = ped_geometry_new(pedDevice(), partition().firstSector(), partition().length());
if (pedGeometry)
pedConstraint = ped_constraint_exact(pedGeometry);
if (pedConstraint)
{
if (ped_disk_add_partition(pedDisk(), pedPartition, pedConstraint) && commit())
{
partition().setNumber(pedPartition->num);
partition().setState(Partition::StateNone);
partition().setFirstSector(pedPartition->geom.start);
partition().setLastSector(pedPartition->geom.end);
rval = true;
}
else
report->line() << i18nc("@info/plain", "Failed to add partition <filename>%1</filename> to device <filename>%2</filename>.", partition().deviceNode(), device().deviceNode());
ped_constraint_destroy(pedConstraint);
}
else
report->line() << i18nc("@info/plain", "Failed to create a new partition: could not get geometry for constraint.");
}
else
report->line() << i18nc("@info/plain", "Failed to create new partition <filename>%1</filename>.", partition().deviceNode());
closePed();
}
else
report->line() << i18nc("@info/plain", "Could not open device <filename>%1</filename> to create new partition <filename>%2</filename>.", device().deviceNode(), partition().deviceNode());
jobFinished(*report, rval);
return rval;
}
static int
dasd_alloc_metadata (PedDisk* disk)
{
PedPartition* new_part;
PedConstraint* constraint_any = NULL;
PedSector vtoc_end;
LinuxSpecific* arch_specific;
DasdDiskSpecific* disk_specific;
PedPartition* part = NULL; /* initialize solely to placate gcc */
PedPartition* new_part2;
PedSector trailing_meta_start, trailing_meta_end;
PED_ASSERT (disk != NULL);
PED_ASSERT (disk->dev != NULL);
arch_specific = LINUX_SPECIFIC (disk->dev);
disk_specific = disk->disk_specific;
constraint_any = ped_constraint_any (disk->dev);
/* For LDL or CMS, the leading metadata ends at the sector before
the start of the first partition */
if (disk_specific->format_type == 1) {
part = ped_disk_get_partition(disk, 1);
if (part)
vtoc_end = part->geom.start - 1;
else
vtoc_end = (PedSector) arch_specific->real_sector_size /
(PedSector) disk->dev->sector_size *
(PedSector) disk_specific->label_block;
}
else {
if (disk->dev->type == PED_DEVICE_FILE)
arch_specific->real_sector_size = disk->dev->sector_size;
/* Mark the start of the disk as metadata. */
vtoc_end = (FIRST_USABLE_TRK * (long long) disk->dev->hw_geom.sectors
* (long long) arch_specific->real_sector_size
/ (long long) disk->dev->sector_size) - 1;
}
new_part = ped_partition_new (disk,PED_PARTITION_METADATA,NULL,0,vtoc_end);
if (!new_part)
goto error;
if (!ped_disk_add_partition (disk, new_part, constraint_any)) {
ped_partition_destroy (new_part);
goto error;
}
if (disk_specific->format_type == 1 && part) {
/*
For LDL or CMS there may be trailing metadata as well.
For example: the last block of a CMS reserved file,
the "recomp" area of a CMS minidisk that has been
formatted and then formatted again with the RECOMP
option specifying fewer than the maximum number of
cylinders, a disk that was formatted at one size,
backed up, then restored to a larger size disk, etc.
*/
trailing_meta_start = part->geom.end + 1;
trailing_meta_end = (long long) disk->dev->length - 1;
if (trailing_meta_end >= trailing_meta_start) {
new_part2 = ped_partition_new (disk,PED_PARTITION_METADATA,
NULL, trailing_meta_start, trailing_meta_end);
if (!new_part2) {
ped_partition_destroy (new_part);
goto error;
}
if (!ped_disk_add_partition (disk, new_part2,
constraint_any)) {
ped_partition_destroy (new_part2);
ped_partition_destroy (new_part);
goto error;
}
}
}
ped_constraint_destroy (constraint_any);
return 1;
error:
ped_constraint_destroy (constraint_any);
return 0;
}
static int
dasd_read (PedDisk* disk)
{
int i;
char str[20];
PedDevice* dev;
PedPartition* part;
PedFileSystemType *fs;
PedSector start, end;
PedConstraint* constraint_exact;
partition_info_t *p;
LinuxSpecific* arch_specific;
DasdDiskSpecific* disk_specific;
struct fdasd_anchor anchor;
PDEBUG;
PED_ASSERT (disk != NULL);
PDEBUG;
PED_ASSERT (disk->dev != NULL);
PDEBUG;
dev = disk->dev;
arch_specific = LINUX_SPECIFIC(dev);
disk_specific = disk->disk_specific;
PDEBUG;
fdasd_initialize_anchor(&anchor);
if (fdasd_get_geometry(disk->dev, &anchor, arch_specific->fd) == 0)
goto error_close_dev;
disk_specific->label_block = anchor.label_block;
if ((anchor.geo.cylinders * anchor.geo.heads) > BIG_DISK_SIZE)
anchor.big_disk++;
/* check dasd for labels and vtoc */
if (fdasd_check_volume(&anchor, arch_specific->fd)) {
DasdPartitionData* dasd_data;
/* Kernel partitioning code will report 'implicit' partitions
* for non-CDL format DASDs even when there is no
* label/VTOC. */
if (anchor.FBA_layout == 0)
goto error_close_dev;
disk_specific->format_type = 1;
/* Register implicit partition */
ped_disk_delete_all (disk);
start = (PedSector) arch_specific->real_sector_size /
(PedSector) disk->dev->sector_size *
(PedSector) (anchor.label_block + 1);
end = disk->dev->length - 1;
part = ped_partition_new (disk, PED_PARTITION_NORMAL, NULL,
start, end);
if (!part)
goto error_close_dev;
part->num = 1;
part->fs_type = ped_file_system_probe (&part->geom);
dasd_data = part->disk_specific;
dasd_data->raid = 0;
dasd_data->lvm = 0;
dasd_data->type = 0;
if (!ped_disk_add_partition (disk, part, NULL))
goto error_close_dev;
fdasd_cleanup(&anchor);
return 1;
}
/* Save volume label (read by fdasd_check_volume) for writing */
memcpy(&disk_specific->vlabel, anchor.vlabel, sizeof(volume_label_t));
ped_disk_delete_all (disk);
bool is_ldl = strncmp(anchor.vlabel->volkey,
vtoc_ebcdic_enc("LNX1", str, 4), 4) == 0;
bool is_cms = strncmp(anchor.vlabel->volkey,
vtoc_ebcdic_enc("CMS1", str, 4), 4) == 0;
if (is_ldl || is_cms) {
DasdPartitionData* dasd_data;
union vollabel {
volume_label_t ldl;
cms_volume_label_t cms;
};
union vollabel *cms_ptr1 = (union vollabel *) anchor.vlabel;
cms_volume_label_t *cms_ptr = &cms_ptr1->cms;
volume_label_t *ldl_ptr = &cms_ptr1->ldl;
int partition_start_block;
disk_specific->format_type = 1;
if (is_cms && cms_ptr->usable_count >= cms_ptr->block_count)
partition_start_block = 2; /* FBA DASD */
else
partition_start_block = 3; /* CKD DASD */
if (is_ldl)
start = (long long) arch_specific->real_sector_size
/ (long long) disk->dev->sector_size
* (long long) partition_start_block;
else if (cms_ptr->disk_offset == 0)
start = (long long) cms_ptr->block_size
/ (long long) disk->dev->sector_size
* (long long) partition_start_block;
else
start = (long long) cms_ptr->block_size
/ (long long) disk->dev->sector_size
* (long long) cms_ptr->disk_offset;
if (is_ldl)
if (ldl_ptr->ldl_version >= 0xf2)
end = (long long) arch_specific->real_sector_size
/ (long long) disk->dev->sector_size
* (long long) ldl_ptr->formatted_blocks - 1;
else
end = disk->dev->length - 1;
else
if (cms_ptr->disk_offset == 0)
end = (long long) cms_ptr->block_size
/ (long long) disk->dev->sector_size
* (long long) cms_ptr->block_count - 1;
else
/*
Frankly, I do not understand why the last block
of the CMS reserved file is not included in the
partition; but this is the algorithm used by the
Linux kernel. See fs/partitions/ibm.c in the
Linux kernel source code.
*/
end = (long long) cms_ptr->block_size
/ (long long) disk->dev->sector_size
* (long long) (cms_ptr->block_count - 1) - 1;
part = ped_partition_new (disk, PED_PARTITION_NORMAL, NULL, start, end);
if (!part)
goto error_close_dev;
part->num = 1;
part->fs_type = ped_file_system_probe (&part->geom);
dasd_data = part->disk_specific;
dasd_data->raid = 0;
dasd_data->lvm = 0;
dasd_data->type = 0;
if (!ped_disk_add_partition (disk, part, NULL))
goto error_close_dev;
fdasd_cleanup(&anchor);
return 1;
}
/* CDL format, newer */
disk_specific->format_type = 2;
p = anchor.first;
PDEBUG;
for (i = 1 ; i <= USABLE_PARTITIONS; i++) {
char *ch = p->f1->DS1DSNAM;
DasdPartitionData* dasd_data;
if (p->used != 0x01)
continue;
PDEBUG;
start = (long long)(long long) p->start_trk
* (long long) disk->dev->hw_geom.sectors
* (long long) arch_specific->real_sector_size
/ (long long) disk->dev->sector_size;
end = (long long)((long long) p->end_trk + 1)
* (long long) disk->dev->hw_geom.sectors
* (long long) arch_specific->real_sector_size
/ (long long) disk->dev->sector_size - 1;
part = ped_partition_new(disk, PED_PARTITION_NORMAL, NULL,
start, end);
PDEBUG;
if (!part)
goto error_close_dev;
PDEBUG;
part->num = i;
part->fs_type = ped_file_system_probe(&part->geom);
vtoc_ebcdic_dec(p->f1->DS1DSNAM, p->f1->DS1DSNAM, 44);
ch = strstr(p->f1->DS1DSNAM, "PART");
if (ch != NULL) {
strncpy(str, ch+9, 6);
str[6] = '\0';
}
dasd_data = part->disk_specific;
if ((strncmp(PART_TYPE_RAID, str, 6) == 0) &&
(ped_file_system_probe(&part->geom) == NULL))
ped_partition_set_flag(part, PED_PARTITION_RAID, 1);
else
ped_partition_set_flag(part, PED_PARTITION_RAID, 0);
if ((strncmp(PART_TYPE_LVM, str, 6) == 0) &&
(ped_file_system_probe(&part->geom) == NULL))
ped_partition_set_flag(part, PED_PARTITION_LVM, 1);
else
ped_partition_set_flag(part, PED_PARTITION_LVM, 0);
if (strncmp(PART_TYPE_SWAP, str, 6) == 0) {
fs = ped_file_system_probe(&part->geom);
if (fs && is_linux_swap(fs->name)) {
dasd_data->system = PARTITION_LINUX_SWAP;
PDEBUG;
}
}
vtoc_ebcdic_enc(p->f1->DS1DSNAM, p->f1->DS1DSNAM, 44);
dasd_data->type = 0;
constraint_exact = ped_constraint_exact (&part->geom);
if (!constraint_exact)
goto error_close_dev;
if (!ped_disk_add_partition(disk, part, constraint_exact)) {
ped_constraint_destroy(constraint_exact);
goto error_close_dev;
}
ped_constraint_destroy(constraint_exact);
if (p->fspace_trk > 0) {
start = (long long)((long long) p->end_trk + 1)
* (long long) disk->dev->hw_geom.sectors
* (long long) arch_specific->real_sector_size
/ (long long) disk->dev->sector_size;
end = (long long)((long long) p->end_trk + 1 + p->fspace_trk)
* (long long) disk->dev->hw_geom.sectors
* (long long) arch_specific->real_sector_size
/ (long long) disk->dev->sector_size - 1;
part = ped_partition_new (disk, PED_PARTITION_NORMAL,
NULL, start, end);
if (!part)
goto error_close_dev;
part->type = PED_PARTITION_FREESPACE;
constraint_exact = ped_constraint_exact(&part->geom);
if (!constraint_exact)
goto error_close_dev;
if (!ped_disk_add_partition(disk, part, constraint_exact)) {
ped_constraint_destroy(constraint_exact);
goto error_close_dev;
}
ped_constraint_destroy (constraint_exact);
}
p = p->next;
}
PDEBUG;
fdasd_cleanup(&anchor);
return 1;
error_close_dev:
PDEBUG;
fdasd_cleanup(&anchor);
return 0;
}
