static PedGeometry*
_generic_apfs_probe (PedGeometry* geom, uint32_t kind)
{
uint32_t *block;
PedSector root;
struct PartitionBlock * part;
uint32_t blocksize = 1, reserved = 2;
PED_ASSERT (geom != NULL);
PED_ASSERT (geom->dev != NULL);
if (geom->dev->sector_size != 512)
return NULL;
/* Finds the blocksize and reserved values of the partition block */
if (!(part = ped_malloc (PED_SECTOR_SIZE_DEFAULT*blocksize))) {
ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("%s : Failed to allocate partition block\n"), __func__);
goto error_part;
}
if (amiga_find_part(geom, part) != NULL) {
reserved = PED_BE32_TO_CPU (part->de_Reserved);
blocksize = PED_BE32_TO_CPU (part->de_SizeBlock)
* PED_BE32_TO_CPU (part->de_SectorPerBlock) / 128;
}
free (part);
/* Test boot block */
if (!(block = ped_malloc (PED_SECTOR_SIZE_DEFAULT*blocksize))) {
ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("%s : Failed to allocate block\n"), __func__);
goto error_block;
}
if (!ped_device_read (geom->dev, block, geom->start, blocksize)) {
ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("%s : Couldn't read boot block %llu\n"), __func__, geom->start);
goto error;
}
if (PED_BE32_TO_CPU (block[0]) != kind) {
goto error;
}
/* Find and test the root block */
root = geom->start+reserved*blocksize;
if (!ped_device_read (geom->dev, block, root, blocksize)) {
ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("%s : Couldn't read root block %llu\n"), __func__, root);
goto error;
}
if (_apfs_probe_root(block, blocksize, kind) == 1) {
free(block);
return ped_geometry_duplicate (geom);
}
error:
free (block);
error_block:
error_part:
return NULL;
}
static int
loop_write (const PedDisk* disk)
{
size_t buflen = disk->dev->sector_size;
char *buf = ped_malloc (buflen);
if (buf == NULL)
return 0;
if (ped_disk_get_partition (disk, 1)) {
if (!ped_device_read (disk->dev, buf, 0, 1)) {
free (buf);
return 0;
}
if (strncmp (buf, LOOP_SIGNATURE, strlen (LOOP_SIGNATURE)) != 0) {
free (buf);
return 1;
}
memset (buf, 0, strlen (LOOP_SIGNATURE));
return ped_device_write (disk->dev, buf, 0, 1);
}
memset (buf, 0, buflen);
strcpy (buf, LOOP_SIGNATURE);
int write_ok = ped_device_write (disk->dev, buf, 0, 1);
free (buf);
return write_ok;
}
bool LibPartedDevice::readSectors(void* buffer, qint64 offset, qint64 numSectors)
{
if (!isExclusive())
return false;
return ped_device_read(pedDevice(), buffer, offset, numSectors);
}
static struct AmigaBlock *
_amiga_read_block (const PedDevice *dev, struct AmigaBlock *blk,
PedSector block, struct AmigaIds *ids)
{
if (!ped_device_read (dev, blk, block, 1))
return NULL;
if (ids && !_amiga_id_in_list(PED_BE32_TO_CPU(blk->amiga_ID), ids))
return NULL;
if (_amiga_checksum (blk) != 0) {
switch (ped_exception_throw(PED_EXCEPTION_ERROR,
PED_EXCEPTION_FIX | PED_EXCEPTION_IGNORE | PED_EXCEPTION_CANCEL,
_("%s : Bad checksum on block %llu of type %s."),
__func__, block, _amiga_block_id(PED_BE32_TO_CPU(blk->amiga_ID))))
{
case PED_EXCEPTION_CANCEL :
return NULL;
case PED_EXCEPTION_FIX :
_amiga_calculate_checksum(AMIGA(blk));
if (!ped_device_write ((PedDevice*)dev, blk, block, 1))
return NULL;
case PED_EXCEPTION_IGNORE :
case PED_EXCEPTION_UNHANDLED :
default :
return blk;
}
}
return blk;
}
PyObject *py_ped_device_read(PyObject *s, PyObject *args) {
PyObject *ret = NULL;
PedSector start, count;
PedDevice *device = NULL;
char *out_buf = NULL;
if (!PyArg_ParseTuple(args, "LL", &start, &count)) {
return NULL;
}
device = _ped_Device2PedDevice(s);
if (device == NULL) {
return NULL;
}
if (!device->open_count) {
PyErr_Format(IOException, "Device %s is not open.", device->path);
return NULL;
}
if (device->external_mode) {
PyErr_Format(IOException, "Device %s is already open for external access.", device->path);
return NULL;
}
if ((out_buf = malloc(device->sector_size * count)) == NULL) {
return PyErr_NoMemory();
}
if (ped_device_read(device, out_buf, start, count) == 0) {
if (partedExnRaised) {
partedExnRaised = 0;
if (!PyErr_ExceptionMatches(PartedException) &&
!PyErr_ExceptionMatches(PyExc_NotImplementedError))
PyErr_SetString(IOException, partedExnMessage);
}
else
PyErr_Format(IOException, "Could not read from device %s", device->path);
free(out_buf);
return NULL;
}
ret = PyUnicode_FromString(out_buf);
free(out_buf);
return ret;
}
static int
pc98_probe (const PedDevice *dev)
{
PC98RawTable part_table;
int empty;
const PC98RawPartition* p;
PED_ASSERT (dev != NULL);
if (dev->sector_size != 512)
return 0;
if (!ped_device_read (dev, &part_table, 0, 2))
return 0;
/* check magic */
if (!pc98_check_magic (&part_table))
return 0;
/* check consistency */
empty = 1;
for (p = part_table.partitions;
p < part_table.partitions + MAX_PART_COUNT;
p++)
{
if (p->mid == 0 && p->sid == 0)
continue;
empty = 0;
if (!check_partition_consistency (dev, p))
return 0;
}
/* check boot loader */
if (pc98_check_ipl_signature (&part_table))
return 1;
else if (part_table.boot_code[0]) /* invalid boot loader */
return 0;
/* Not to mistake msdos disk map for PC-9800's empty disk map */
if (empty)
return 0;
return 1;
}
static int
pc98_probe (const PedDevice *dev)
{
PC98RawTable part_table;
PED_ASSERT (dev != NULL);
if (dev->sector_size != 512)
return 0;
if (!ped_device_read (dev, &part_table, 0, 2))
return 0;
/* check magic */
if (!pc98_check_magic (&part_table))
return 0;
/* check for boot loader signatures */
return pc98_check_ipl_signature (&part_table);
}
/** Reads a given number of sectors from the Device into the given buffer.
Note that @p readOffset must be greater or equal than zero.
@param buffer the buffer to store the read sectors in
@param readOffset the offset to begin reading
@param numSectors the number of sector to read
@return true if successful
*/
bool CopySourceDevice::readSectors(void* buffer, qint64 readOffset, qint64 numSectors)
{
Q_ASSERT(readOffset >= 0);
return ped_device_read(m_PedDevice, buffer, readOffset, numSectors);
}
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;
}
/* We have already allocated a rdb, we are now reading it from the disk */
struct PartitionBlock *
amiga_find_part (PedGeometry *geom, struct PartitionBlock *part)
{
struct RigidDiskBlock *rdb;
uint32_t partblock;
uint32_t partlist[AMIGA_MAX_PARTITIONS];
int i;
PED_ASSERT(geom!= NULL);
PED_ASSERT(geom->dev!= NULL);
if (!(rdb = ped_malloc (PED_SECTOR_SIZE_DEFAULT))) {
switch (ped_exception_throw(PED_EXCEPTION_ERROR,
PED_EXCEPTION_CANCEL,
_("%s : Failed to allocate disk_specific rdb block\n"), __func__))
{
case PED_EXCEPTION_CANCEL :
case PED_EXCEPTION_UNHANDLED :
default :
return NULL;
}
}
if (_amiga_find_rdb (geom->dev, rdb) == AMIGA_RDB_NOT_FOUND) {
switch (ped_exception_throw(PED_EXCEPTION_ERROR,
PED_EXCEPTION_CANCEL,
_("%s : Didn't find rdb block, should never happen\n"), __func__))
{
case PED_EXCEPTION_CANCEL :
case PED_EXCEPTION_UNHANDLED :
default :
free(rdb);
return NULL;
}
}
/* We initialize the hardblock free list to detect loops */
for (i = 0; i < AMIGA_MAX_PARTITIONS; i++) partlist[i] = IDNAME_FREE;
for (i = 1, partblock = PED_BE32_TO_CPU(rdb->rdb_PartitionList);
i < AMIGA_MAX_PARTITIONS && partblock != IDNAME_FREE;
i++, partblock = PED_BE32_TO_CPU(part->pb_Next))
{
PedSector start, end;
PedSector cylblocks;
/* Let's look for loops in the partition table */
if (_amiga_loop_check(partblock, partlist, i)) {
free (rdb);
return NULL;
}
/* Let's read a partition block to get its geometry*/
if (!ped_device_read (geom->dev, part, (PedSector)partblock, 1)) {
switch (ped_exception_throw(PED_EXCEPTION_ERROR,
PED_EXCEPTION_CANCEL,
_("%s : Failed to read partition block %llu\n"),
__func__, (PedSector)partblock))
{
case PED_EXCEPTION_CANCEL :
case PED_EXCEPTION_UNHANDLED :
default :
free(rdb);
return NULL;
}
}
/* Current block is not a Partition Block */
if (part->pb_ID != IDNAME_PARTITION) {
free (rdb);
return NULL;
}
/* Calculate the geometry of the partition */
cylblocks = ((PedSector) PED_BE32_TO_CPU (part->de_Surfaces)) *
((PedSector) PED_BE32_TO_CPU (part->de_BlocksPerTrack));
start = ((PedSector) PED_BE32_TO_CPU (part->de_LowCyl)) * cylblocks;
end = ((((PedSector) PED_BE32_TO_CPU (part->de_HighCyl))+1) * (cylblocks))-1;
/* And check if it is the one we are searching for */
if (start == geom->start && end == geom->end) {
free (rdb);
return part;
}
}
free (rdb);
return NULL;
}
void MParted::MParted_Core::scan(MParted::Devices & devices) {
QMutexLocker locker(&mutex);
// Clean up first
devices.clear();
// Initialise
QStringList devicePaths;
ped_device_probe_all();
pedDevice = NULL;
while ((pedDevice = ped_device_get_next(pedDevice))) {
// Only add this device if we can read the first sector (which means it's a real device)
char * buf = static_cast<char *>(malloc(pedDevice->sector_size));
if (buf) {
// Confirming device
if (ped_device_open(pedDevice)) {
//Devices with sector sizes of 512 bytes and higher are supported
if (ped_device_read(pedDevice, buf, 0, 1))
devicePaths.append(Utils::charToString(pedDevice->path));
ped_device_close(pedDevice) ;
}
free(buf);
}
}
closeDeviceAndDisk();
// Sort list, remove duplicates and empty entries
devicePaths.removeDuplicates();
devicePaths.removeAll("");
devicePaths.sort();
for (int i = 0; i < devicePaths.size(); i++) {
const QString devicePath = devicePaths.at(i);
// Open device and disk
if (!openDeviceAndDisk(devicePath, false))
continue;
// Add to list and save pointer
devices.append(MParted::Device());
MParted::Device &device = devices.last();
//device info..
device.path = devicePath;
device.model = Utils::charToString(pedDevice->model);
device.length = pedDevice->length;
device.sector_size = pedDevice->sector_size;
device.heads = pedDevice->bios_geom.heads;
device.sectors = pedDevice->bios_geom.sectors;
device.cylinders = pedDevice->bios_geom.cylinders;
device.cylsize = device.heads * device.sectors;
device.removable = isDeviceRemovable(device);
//make sure cylsize is at least 1 MiB
if (device.cylsize < (MEBIBYTE / device.sector_size))
device.cylsize = (MEBIBYTE / device.sector_size);
//normal harddisk
if (pedDisk) {
device.unkownPartitionTable = false;
device.diskType = Utils::charToString(pedDisk->type->name);
device.maxPrimaryPartitions = ped_disk_get_max_primary_partition_count(pedDisk);
// Scan partitions
scanDevicePartitions(device);
}
//harddisk without disklabel
else {
device.unkownPartitionTable = true;
device.diskType = QObject::tr("unrecognized");
device.maxPrimaryPartitions = -1;
}
// Clean up
closeDeviceAndDisk();
}
}
