YZBruh/pmt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

pmt: revert 7f8090b

Browse Source
This commit is contained in:
Yağız Zengin
2024-12-14 10:43:33 +03:00
parent 7f8090bb1f
commit bbf76e4925
1292 changed files with 2823 additions and 500876 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
jni/parted/libparted/fs/amiga/a-interface.c
View File

@@ -1,88 +0,0 @@
/*
interface.c -- parted support amiga file systems
Copyright (C) 1998-2000, 2007, 2009-2014, 2019-2023 Free Software
Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include <parted/parted.h>
#include <parted/debug.h>
#include <parted/endian.h>
extern PedFileSystemType _affs0_type;
extern PedFileSystemType _affs1_type;
extern PedFileSystemType _affs2_type;
extern PedFileSystemType _affs3_type;
extern PedFileSystemType _affs4_type;
extern PedFileSystemType _affs5_type;
extern PedFileSystemType _affs6_type;
extern PedFileSystemType _affs7_type;
extern PedFileSystemType _amufs_type;
extern PedFileSystemType _amufs0_type;
extern PedFileSystemType _amufs1_type;
extern PedFileSystemType _amufs2_type;
extern PedFileSystemType _amufs3_type;
extern PedFileSystemType _amufs4_type;
extern PedFileSystemType _amufs5_type;
extern PedFileSystemType _asfs_type;
extern PedFileSystemType _apfs1_type;
extern PedFileSystemType _apfs2_type;
void ped_file_system_amiga_init ()
{
ped_file_system_type_register (&_affs0_type);
ped_file_system_type_register (&_affs1_type);
ped_file_system_type_register (&_affs2_type);
ped_file_system_type_register (&_affs3_type);
ped_file_system_type_register (&_affs4_type);
ped_file_system_type_register (&_affs5_type);
ped_file_system_type_register (&_affs6_type);
ped_file_system_type_register (&_affs7_type);
ped_file_system_type_register (&_amufs_type);
ped_file_system_type_register (&_amufs0_type);
ped_file_system_type_register (&_amufs1_type);
ped_file_system_type_register (&_amufs2_type);
ped_file_system_type_register (&_amufs3_type);
ped_file_system_type_register (&_amufs4_type);
ped_file_system_type_register (&_amufs5_type);
ped_file_system_type_register (&_asfs_type);
ped_file_system_type_register (&_apfs1_type);
ped_file_system_type_register (&_apfs2_type);
}
void ped_file_system_amiga_done ()
{
ped_file_system_type_unregister (&_affs0_type);
ped_file_system_type_unregister (&_affs1_type);
ped_file_system_type_unregister (&_affs2_type);
ped_file_system_type_unregister (&_affs3_type);
ped_file_system_type_unregister (&_affs4_type);
ped_file_system_type_unregister (&_affs5_type);
ped_file_system_type_unregister (&_affs6_type);
ped_file_system_type_unregister (&_affs7_type);
ped_file_system_type_unregister (&_amufs_type);
ped_file_system_type_unregister (&_amufs0_type);
ped_file_system_type_unregister (&_amufs1_type);
ped_file_system_type_unregister (&_amufs2_type);
ped_file_system_type_unregister (&_amufs3_type);
ped_file_system_type_unregister (&_amufs4_type);
ped_file_system_type_unregister (&_amufs5_type);
ped_file_system_type_unregister (&_asfs_type);
ped_file_system_type_unregister (&_apfs1_type);
ped_file_system_type_unregister (&_apfs2_type);
}

292
jni/parted/libparted/fs/amiga/affs.c
View File

@@ -1,292 +0,0 @@
/*
affs.c -- parted support for affs file systems
Copyright (C) 1998-2000, 2007, 2009-2014, 2019-2023 Free Software
Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include <parted/parted.h>
#include <parted/debug.h>
#include <parted/endian.h>
#include "amiga.h"
#include "affs.h"
#if ENABLE_NLS
# include <libintl.h>
# define _(String) dgettext (PACKAGE, String)
#else
# define _(String) (String)
#endif /* ENABLE_NLS */
static int
_affs_probe_root (uint32_t *block, int blocksize) {
int i;
uint32_t sum;
if (PED_BE32_TO_CPU (block[0]) != 2) return 0;
if (PED_BE32_TO_CPU (block[128*blocksize-1]) != 1) return 0;
for (i = 0, sum = 0; i < 128*blocksize; i++)
sum += PED_BE32_TO_CPU (block[i]);
if (sum) return 0;
return 1;
}
static PedGeometry*
_generic_affs_probe (PedGeometry* geom, uint32_t kind)
{
uint32_t *block;
PedSector root, len, pos;
struct PartitionBlock * part;
int 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);
reserved = reserved == 0 ? 1 : 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 */
len = geom->length / blocksize - reserved;
pos = (len - 1) / 2;
root = geom->start + (pos + 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 (_affs_probe_root(block, blocksize) == 1) {
free (block);
return ped_geometry_duplicate (geom);
}
error:
free (block);
error_block:
error_part:
return NULL;
}
static PedGeometry*
_affs0_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x444f5300);
}
static PedGeometry*
_affs1_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x444f5301);
}
static PedGeometry*
_affs2_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x444f5302);
}
static PedGeometry*
_affs3_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x444f5303);
}
static PedGeometry*
_affs4_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x444f5304);
}
static PedGeometry*
_affs5_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x444f5305);
}
static PedGeometry*
_affs6_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x444f5306);
}
static PedGeometry*
_affs7_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x444f5307);
}
static PedGeometry*
_amufs_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x6d754653);
}
static PedGeometry*
_amufs0_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x6d754600);
}
static PedGeometry*
_amufs1_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x6d754601);
}
static PedGeometry*
_amufs2_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x6d754602);
}
static PedGeometry*
_amufs3_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x6d754603);
}
static PedGeometry*
_amufs4_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x6d754604);
}
static PedGeometry*
_amufs5_probe (PedGeometry* geom) {
return _generic_affs_probe (geom, 0x6d754605);
}
static PedFileSystemOps _affs0_ops = {
probe: _affs0_probe,
};
static PedFileSystemOps _affs1_ops = {
probe: _affs1_probe,
};
static PedFileSystemOps _affs2_ops = {
probe: _affs2_probe,
};
static PedFileSystemOps _affs3_ops = {
probe: _affs3_probe,
};
static PedFileSystemOps _affs4_ops = {
probe: _affs4_probe,
};
static PedFileSystemOps _affs5_ops = {
probe: _affs5_probe,
};
static PedFileSystemOps _affs6_ops = {
probe: _affs6_probe,
};
static PedFileSystemOps _affs7_ops = {
probe: _affs7_probe,
};
static PedFileSystemOps _amufs_ops = {
probe: _amufs_probe,
};
static PedFileSystemOps _amufs0_ops = {
probe: _amufs0_probe,
};
static PedFileSystemOps _amufs1_ops = {
probe: _amufs1_probe,
};
static PedFileSystemOps _amufs2_ops = {
probe: _amufs2_probe,
};
static PedFileSystemOps _amufs3_ops = {
probe: _amufs3_probe,
};
static PedFileSystemOps _amufs4_ops = {
probe: _amufs4_probe,
};
static PedFileSystemOps _amufs5_ops = {
probe: _amufs5_probe,
};
PedFileSystemType _affs0_type = {
next: NULL,
ops: &_affs0_ops,
name: "affs0",
};
PedFileSystemType _affs1_type = {
next: NULL,
ops: &_affs1_ops,
name: "affs1",
};
PedFileSystemType _affs2_type = {
next: NULL,
ops: &_affs2_ops,
name: "affs2",
};
PedFileSystemType _affs3_type = {
next: NULL,
ops: &_affs3_ops,
name: "affs3",
};
PedFileSystemType _affs4_type = {
next: NULL,
ops: &_affs4_ops,
name: "affs4",
};
PedFileSystemType _affs5_type = {
next: NULL,
ops: &_affs5_ops,
name: "affs5",
};
PedFileSystemType _affs6_type = {
next: NULL,
ops: &_affs6_ops,
name: "affs6",
};
PedFileSystemType _affs7_type = {
next: NULL,
ops: &_affs7_ops,
name: "affs7",
};
PedFileSystemType _amufs_type = {
next: NULL,
ops: &_amufs_ops,
name: "amufs",
};
PedFileSystemType _amufs0_type = {
next: NULL,
ops: &_amufs0_ops,
name: "amufs0",
};
PedFileSystemType _amufs1_type = {
next: NULL,
ops: &_amufs1_ops,
name: "amufs1",
};
PedFileSystemType _amufs2_type = {
next: NULL,
ops: &_amufs2_ops,
name: "amufs2",
};
PedFileSystemType _amufs3_type = {
next: NULL,
ops: &_amufs3_ops,
name: "amufs3",
};
PedFileSystemType _amufs4_type = {
next: NULL,
ops: &_amufs4_ops,
name: "amufs4",
};
PedFileSystemType _amufs5_type = {
next: NULL,
ops: &_amufs5_ops,
name: "amufs5",
};

19
jni/parted/libparted/fs/amiga/affs.h
View File

@@ -1,19 +0,0 @@
/*
affs.h -- parted suppoer for affs filesystems header files
Copyright (C) 1998-2000, 2007, 2009-2014, 2019-2023 Free Software
Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

351
jni/parted/libparted/fs/amiga/amiga.c
View File

@@ -1,351 +0,0 @@
/*
libparted/fs_amiga - amiga file system support.
Copyright (C) 2000-2001, 2007, 2009-2014, 2019-2023 Free Software
Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Contributor: Sven Luther <luther@debian.org>
*/
#include <config.h>
#include <parted/parted.h>
#include <parted/debug.h>
#include <parted/endian.h>
#include "amiga.h"
#if ENABLE_NLS
# include <libintl.h>
# define _(String) dgettext (PACKAGE, String)
#else
# define _(String) (String)
#endif /* ENABLE_NLS */
#define IDNAME_RIGIDDISK (uint32_t)0x5244534B /* 'RDSK' */
#define IDNAME_BADBLOCK (uint32_t)0x42414442 /* 'BADB' */
#define IDNAME_PARTITION (uint32_t)0x50415254 /* 'PART' */
#define IDNAME_FILESYSHEADER (uint32_t)0x46534844 /* 'FSHD' */
#define IDNAME_LOADSEG (uint32_t)0x4C534547 /* 'LSEG' */
#define IDNAME_BOOT (uint32_t)0x424f4f54 /* 'BOOT' */
#define IDNAME_FREE (uint32_t)0xffffffff
static const char *
_amiga_block_id (uint32_t id) {
switch (id) {
case IDNAME_RIGIDDISK :
return "RDSK";
case IDNAME_BADBLOCK :
return "BADB";
case IDNAME_PARTITION :
return "PART";
case IDNAME_FILESYSHEADER :
return "FSHD";
case IDNAME_LOADSEG :
return "LSEG";
case IDNAME_BOOT :
return "BOOT";
case IDNAME_FREE :
return "<free>";
default :
return "<unknown>";
}
}
struct AmigaIds *
_amiga_add_id (uint32_t id, struct AmigaIds *ids) {
struct AmigaIds *newid;
if ((newid=ped_malloc(sizeof (struct AmigaIds)))==NULL) {
ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("%s : Failed to allocate id list element\n"), __func__);
return 0;
}
newid->ID = id;
newid->next = ids;
return newid;
}
void
_amiga_free_ids (struct AmigaIds *ids) {
struct AmigaIds *current, *next;
for (current = ids; current != NULL; current = next) {
next = current->next;
free (current);
}
}
int
_amiga_id_in_list (uint32_t id, struct AmigaIds *ids) {
struct AmigaIds *current;
for (current = ids; current != NULL; current = current->next) {
if (id == current->ID)
return 1;
}
return 0;
}
#define AMIGA_RDB_NOT_FOUND ((uint32_t)0xffffffff)
struct AmigaBlock {
uint32_t amiga_ID; /* Identifier 32 bit word */
uint32_t amiga_SummedLongss; /* Size of the structure for checksums */
int32_t amiga_ChkSum; /* Checksum of the structure */
};
#define AMIGA(pos) ((struct AmigaBlock *)(pos))
struct RigidDiskBlock {
uint32_t rdb_ID; /* Identifier 32 bit word : 'RDSK' */
uint32_t rdb_SummedLongs; /* Size of the structure for checksums */
int32_t rdb_ChkSum; /* Checksum of the structure */
uint32_t rdb_HostID; /* SCSI Target ID of host, not really used */
uint32_t rdb_BlockBytes; /* Size of disk blocks */
uint32_t rdb_Flags; /* RDB Flags */
/* block list heads */
uint32_t rdb_BadBlockList; /* Bad block list */
uint32_t rdb_PartitionList; /* Partition list */
uint32_t rdb_FileSysHeaderList; /* File system header list */
uint32_t rdb_DriveInit; /* Drive specific init code */
uint32_t rdb_BootBlockList; /* Amiga OS 4 Boot Blocks */
uint32_t rdb_Reserved1[5]; /* Unused word, need to be set to $ffffffff */
/* physical drive characteristics */
uint32_t rdb_Cylinders; /* Number of the cylinders of the drive */
uint32_t rdb_Sectors; /* Number of sectors of the drive */
uint32_t rdb_Heads; /* Number of heads of the drive */
uint32_t rdb_Interleave; /* Interleave */
uint32_t rdb_Park; /* Head parking cylinder */
uint32_t rdb_Reserved2[3]; /* Unused word, need to be set to $ffffffff */
uint32_t rdb_WritePreComp; /* Starting cylinder of write precompensation */
uint32_t rdb_ReducedWrite; /* Starting cylinder of reduced write current */
uint32_t rdb_StepRate; /* Step rate of the drive */
uint32_t rdb_Reserved3[5]; /* Unused word, need to be set to $ffffffff */
/* logical drive characteristics */
uint32_t rdb_RDBBlocksLo; /* low block of range reserved for hardblocks */
uint32_t rdb_RDBBlocksHi; /* high block of range for these hardblocks */
uint32_t rdb_LoCylinder; /* low cylinder of partitionable disk area */
uint32_t rdb_HiCylinder; /* high cylinder of partitionable data area */
uint32_t rdb_CylBlocks; /* number of blocks available per cylinder */
uint32_t rdb_AutoParkSeconds; /* zero for no auto park */
uint32_t rdb_HighRDSKBlock; /* highest block used by RDSK */
/* (not including replacement bad blocks) */
uint32_t rdb_Reserved4;
/* drive identification */
char rdb_DiskVendor[8];
char rdb_DiskProduct[16];
char rdb_DiskRevision[4];
char rdb_ControllerVendor[8];
char rdb_ControllerProduct[16];
char rdb_ControllerRevision[4];
uint32_t rdb_Reserved5[10];
};
#define AMIGA_MAX_PARTITIONS 128
#define RDB_LOCATION_LIMIT 16
#define RDSK(pos) ((struct RigidDiskBlock *)(pos))
static int
_amiga_checksum (struct AmigaBlock *blk) {
uint32_t *rdb = (uint32_t *) blk;
uint32_t sum;
int i, end;
sum = PED_BE32_TO_CPU (rdb[0]);
end = PED_BE32_TO_CPU (rdb[1]);
if (end > PED_SECTOR_SIZE_DEFAULT) end = PED_SECTOR_SIZE_DEFAULT;
for (i = 1; i < end; i++) sum += PED_BE32_TO_CPU (rdb[i]);
return sum;
}
static void
_amiga_calculate_checksum (struct AmigaBlock *blk) {
blk->amiga_ChkSum = PED_CPU_TO_BE32(
PED_BE32_TO_CPU(blk->amiga_ChkSum) -
_amiga_checksum((struct AmigaBlock *) blk));
return;
}
static struct AmigaBlock *
_amiga_read_block (PedDevice *dev, struct AmigaBlock *blk, PedSector block, struct AmigaIds *ids) {
if (!ped_device_read (dev, blk, block, 1)) {
switch (ped_exception_throw(PED_EXCEPTION_ERROR,
PED_EXCEPTION_CANCEL,
_("%s : Couldn't read block %llu\n"), __func__, block))
{
case PED_EXCEPTION_CANCEL :
case PED_EXCEPTION_UNHANDLED :
default :
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\n"),
__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 (dev, blk, block, 1)) {
switch (ped_exception_throw(PED_EXCEPTION_FATAL,
PED_EXCEPTION_CANCEL,
_("%s : Couldn't write block %d\n"), __func__, block))
{
case PED_EXCEPTION_CANCEL :
case PED_EXCEPTION_UNHANDLED :
default :
return NULL;
}
}
/* FALLTHROUGH */
case PED_EXCEPTION_IGNORE :
case PED_EXCEPTION_UNHANDLED :
default :
return blk;
}
}
return blk;
}
static uint32_t
_amiga_find_rdb (PedDevice *dev, struct RigidDiskBlock *rdb) {
int i;
struct AmigaIds *ids;
ids = _amiga_add_id (IDNAME_RIGIDDISK, NULL);
for (i = 0; i<RDB_LOCATION_LIMIT; i++) {
if (!_amiga_read_block (dev, AMIGA(rdb), i, ids)) {
continue;
}
if (PED_BE32_TO_CPU (rdb->rdb_ID) == IDNAME_RIGIDDISK) {
_amiga_free_ids (ids);
return i;
}
}
_amiga_free_ids (ids);
return AMIGA_RDB_NOT_FOUND;
}
static int
_amiga_loop_check (uint32_t block, uint32_t * blocklist, uint32_t max)
{
uint32_t i;
for (i = 0; i < max; i++)
if (block == blocklist[i]) {
/* We are looping, let's stop. */
return 1;
}
blocklist[max] = block;
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;
}

70
jni/parted/libparted/fs/amiga/amiga.h
View File

@@ -1,70 +0,0 @@
/*
util.h -- amiga partition table headers.
Copyright (C) 1998-2000, 2007, 2009-2014, 2019-2023 Free Software
Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
struct PartitionBlock {
uint32_t pb_ID; /* Identifier 32 bit word : 'PART' */
uint32_t pb_SummedLongs; /* Size of the structure for checksums */
int32_t pb_ChkSum; /* Checksum of the structure */
uint32_t pb_HostID; /* SCSI Target ID of host, not really used */
uint32_t pb_Next; /* Block number of the next PartitionBlock */
uint32_t pb_Flags; /* Part Flags (NOMOUNT and BOOTABLE) */
uint32_t pb_Reserved1[2];
uint32_t pb_DevFlags; /* Preferred flags for OpenDevice */
uint8_t pb_DriveName[32]; /* Preferred DOS device name: BSTR form */
uint32_t pb_Reserved2[15];
uint32_t de_TableSize; /* Size of Environment vector */
uint32_t de_SizeBlock; /* Size of the blocks in 32 bit words, usually 128 */
uint32_t de_SecOrg; /* Not used; must be 0 */
uint32_t de_Surfaces; /* Number of heads (surfaces) */
uint32_t de_SectorPerBlock; /* Disk sectors per block, used with SizeBlock, usually 1 */
uint32_t de_BlocksPerTrack; /* Blocks per track. drive specific */
uint32_t de_Reserved; /* DOS reserved blocks at start of partition. */
uint32_t de_PreAlloc; /* DOS reserved blocks at end of partition */
uint32_t de_Interleave; /* Not used, usually 0 */
uint32_t de_LowCyl; /* First cylinder of the partition */
uint32_t de_HighCyl; /* Last cylinder of the partition */
uint32_t de_NumBuffers; /* Initial # DOS of buffers. */
uint32_t de_BufMemType; /* Type of mem to allocate for buffers */
uint32_t de_MaxTransfer; /* Max number of bytes to transfer at a time */
uint32_t de_Mask; /* Address Mask to block out certain memory */
int32_t de_BootPri; /* Boot priority for autoboot */
uint32_t de_DosType; /* Dostype of the file system */
uint32_t de_Baud; /* Baud rate for serial handler */
uint32_t de_Control; /* Control word for handler/filesystem */
uint32_t de_BootBlocks; /* Number of blocks containing boot code */
uint32_t pb_EReserved[12];
};
#define PART(pos) ((struct PartitionBlock *)(pos))
#define PBFB_BOOTABLE 0 /* this partition is intended to be bootable */
#define PBFF_BOOTABLE 1L /* (expected directories and files exist) */
#define PBFB_NOMOUNT 1 /* do not mount this partition (e.g. manually */
#define PBFF_NOMOUNT 2L /* mounted, but space reserved here) */
struct PartitionBlock * amiga_find_part (PedGeometry *geom, struct PartitionBlock *part);
struct AmigaIds {
uint32_t ID;
struct AmigaIds *next;
};
struct AmigaIds * _amiga_add_id (uint32_t id, struct AmigaIds *ids);
void _amiga_free_ids (struct AmigaIds *ids);
int _amiga_id_in_list (uint32_t id, struct AmigaIds *ids) _GL_ATTRIBUTE_PURE;

128
jni/parted/libparted/fs/amiga/apfs.c
View File

@@ -1,128 +0,0 @@
/*
apfs.c -- parted support for apfs file systems
Copyright (C) 1998-2000, 2007, 2009-2014, 2019-2023 Free Software
Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include <parted/parted.h>
#include <parted/debug.h>
#include <parted/endian.h>
#include "amiga.h"
#include "apfs.h"
#if ENABLE_NLS
# include <libintl.h>
# define _(String) dgettext (PACKAGE, String)
#else
# define _(String) (String)
#endif /* ENABLE_NLS */
static int
_apfs_probe_root (uint32_t *block, uint32_t blocksize, uint32_t kind) {
if (PED_BE32_TO_CPU (block[0]) != kind) return 0;
return 1;
}
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 PedGeometry*
_apfs1_probe (PedGeometry* geom) {
return _generic_apfs_probe (geom, 0x50463101);
}
static PedGeometry*
_apfs2_probe (PedGeometry* geom) {
return _generic_apfs_probe (geom, 0x50463102);
}
static PedFileSystemOps _apfs1_ops = {
probe: _apfs1_probe,
};
static PedFileSystemOps _apfs2_ops = {
probe: _apfs2_probe,
};
PedFileSystemType _apfs1_type = {
next: NULL,
ops: &_apfs1_ops,
name: "apfs1",
};
PedFileSystemType _apfs2_type = {
next: NULL,
ops: &_apfs2_ops,
name: "apfs2",
};

18
jni/parted/libparted/fs/amiga/apfs.h
View File

@@ -1,18 +0,0 @@
/*
apfs.h -- parted support for apfs file systems header files
Copyright (C) 1998-2000, 2007, 2009-2014, 2019-2023 Free Software
Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

130
jni/parted/libparted/fs/amiga/asfs.c
View File

@@ -1,130 +0,0 @@
/*
asfs.c -- parted asfs filesystem support
Copyright (C) 1998-2000, 2007, 2009-2014, 2019-2023 Free Software
Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include <parted/parted.h>
#include <parted/debug.h>
#include <parted/endian.h>
#include "amiga.h"
#include "asfs.h"
#if ENABLE_NLS
# include <libintl.h>
# define _(String) dgettext (PACKAGE, String)
#else
# define _(String) (String)
#endif /* ENABLE_NLS */
static int
_asfs_probe_root (PedGeometry *geom, uint32_t *block, int blocksize, PedSector root) {
int i, sum;
PedSector start, end;
if (PED_BE32_TO_CPU (block[0]) != 0x53465300) return 0;
for (i = 0, sum = 1; i < 128*blocksize; i++) sum += PED_BE32_TO_CPU (block[i]);
if (sum != 0) return 0;
if (PED_BE32_TO_CPU (block[2]) * blocksize + geom->start != root) {
return 0;
}
start = ((((PedSector) PED_BE32_TO_CPU (block[8])) << 32)
+ (PedSector) PED_BE32_TO_CPU (block[9])) / 512;
end = (((((PedSector) PED_BE32_TO_CPU (block[10])) << 32)
+ (PedSector) PED_BE32_TO_CPU (block[11])) / 512) - 1;
if (start != geom->start || end != geom->end) return 0;
return 1;
}
static PedGeometry*
_asfs_probe (PedGeometry* geom)
{
uint32_t *block;
struct PartitionBlock * part;
int blocksize = 1;
PedSector root;
int found = 0;
PED_ASSERT (geom != NULL);
PED_ASSERT (geom->dev != NULL);
if (geom->dev->sector_size != 512)
return NULL;
/* Finds the blocksize 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) {
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;
}
root = geom->start;
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 (PED_BE32_TO_CPU (block[0]) != 0x53465300) {
goto error;
}
/* Find and test the root blocks */
if (_asfs_probe_root(geom, block, blocksize, root)) {
found++;
}
root = geom->end - blocksize - (geom->length % blocksize) + 1;
if (!ped_device_read (geom->dev, block, root, 1)) {
ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("%s : Couldn't read root block %llu\n"), __func__, root);
goto error;
}
if (_asfs_probe_root(geom, block, blocksize, root)) {
found++;
}
if (found != 0) {
free (block);
return ped_geometry_duplicate (geom);
}
error:
free (block);
error_block:
error_part:
return NULL;
}
static PedFileSystemOps _asfs_ops = {
probe: _asfs_probe,
};
PedFileSystemType _asfs_type = {
next: NULL,
ops: &_asfs_ops,
name: "asfs",
};

18
jni/parted/libparted/fs/amiga/asfs.h
View File

@@ -1,18 +0,0 @@
/*
asfs.h -- parted asfs filesystem support header files
Copyright (C) 1998-2000, 2007, 2009-2014, 2019-2023 Free Software
Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/