/* 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; }