[Parted-maintainers] Bug#239816: [PATCH] libparted: Add support for Atari partition tables
John Paul Adrian Glaubitz
glaubitz at physik.fu-berlin.de
Sat Oct 15 14:57:00 UTC 2016
Signed-off-by: John Paul Adrian Glaubitz <glaubitz at physik.fu-berlin.de>
---
libparted/labels/Makefile.am | 1 +
libparted/labels/atari.c | 1969 ++++++++++++++++++++++++++++++++++++++++++
libparted/libparted.c | 4 +
po/POTFILES.in | 1 +
4 files changed, 1975 insertions(+)
create mode 100644 libparted/labels/atari.c
diff --git a/libparted/labels/Makefile.am b/libparted/labels/Makefile.am
index c996f81..3327c8c 100644
--- a/libparted/labels/Makefile.am
+++ b/libparted/labels/Makefile.am
@@ -19,6 +19,7 @@ noinst_LTLIBRARIES = liblabels.la
liblabels_la_SOURCES = \
$(S390_SRCS) \
aix.c \
+ atari.c \
bsd.c \
dos.c \
dvh.c \
diff --git a/libparted/labels/atari.c b/libparted/labels/atari.c
new file mode 100644
index 0000000..8ed0dfb
--- /dev/null
+++ b/libparted/labels/atari.c
@@ -0,0 +1,1969 @@
+/* -*- Mode: c; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+
+ libparted - a library for manipulating disk partitions
+ atari.c - libparted module to manipulate Atari partition tables.
+ Copyright (C) 2000-2001, 2004, 2007-2014 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: Guillaume Knispel <k_guillaume at libertysurf.fr>
+ John Paul Adrian Glaubitz <glaubitz at physik.fu-berlin.de>
+*/
+
+/*
+ Documentation :
+ README file of atari-fdisk
+ atari-fdisk source code
+ Linux atari partitions parser source code
+ ( fs/partitions/atari.[ch] )
+*/
+
+#include <config.h>
+
+#include <string.h>
+#include <parted/parted.h>
+#include <parted/debug.h>
+#include <parted/endian.h>
+#include <string.h>
+#include <locale.h>
+#include <xlocale.h>
+#include <stdint.h>
+#include <ctype.h>
+#include <stddef.h>
+
+#include "pt-tools.h"
+
+#if ENABLE_NLS
+# include <libintl.h>
+# define _(String) dgettext (PACKAGE, String)
+#else
+# define _(String) (String)
+#endif /* ENABLE_NLS */
+
+
+/********************** Atari data and structure stuff **********************/
+
+#define BOOTABLE_CKSUM 0x1234
+#define NONBOOT_CKSUM 0x4321
+
+#define GEM_MAX ((32*1024*1024)/PED_SECTOR_SIZE_DEFAULT)
+
+#define PART_FLAG_USED 0x01
+#define PART_FLAG_BOOT_GEM 0x80 /* GEMDOS */
+#define PART_FLAG_BOOT_ASV 0x40 /* Atari System V */
+#define PART_FLAG_BOOT_BSD 0x20 /* Net(?)BSD */
+#define PART_FLAG_BOOT_LNX 0x10 /* Linux */
+#define PART_FLAG_BOOT_UNK 0x08 /* unknown / other */
+
+#define N_AHDI 4
+#define N_ICD 8
+
+#define MAXIMUM_PARTS 64
+
+/* what we put instead of id, start and size in empty */
+/* partition tables, to be able to detect it */
+#define SIGNATURE_EMPTY_TABLE "PARTEDATARI"
+#define SIGNATURE_EMPTY_SIZE 11
+
+/* to be compared to the last two bytes of 1st sector (Big Endian) */
+static const uint16_t atr_forbidden_sign[] = {
+ 0x55AA,
+ 0
+};
+
+static const char *atr_known_icd_pid[] = {
+ "BGM", "GEM", "LNX", "SWP", "RAW", NULL
+};
+
+/* static const char *atr_known_pid[] = { */
+/* "BGM", "GEM", "LNX", "MAC", "MIX", "MNX", "RAW", "SWP", "UNX", */
+/* "F32", "SV4", NULL */
+/* }; */
+
+struct _AtariPartID2BootFlag {
+ const char pid[4];
+ uint8_t flag;
+};
+typedef struct _AtariPartID2BootFlag AtariPartID2BootFlag;
+
+static AtariPartID2BootFlag atr_pid2bf[] = {
+ { "GEM", PART_FLAG_BOOT_GEM },
+ { "BGM", PART_FLAG_BOOT_GEM },
+ { "UNX", PART_FLAG_BOOT_ASV },
+ { "LNX", PART_FLAG_BOOT_LNX },
+ { "", PART_FLAG_BOOT_UNK },
+};
+
+struct _AtariFS2PartId {
+ const char* fs;
+ const char pid[4];
+ PedSector max_sectors;
+};
+typedef struct _AtariFS2PartId AtariFS2PartId;
+
+static AtariFS2PartId atr_fs2pid[] = {
+/* Other ID are available : MIX MNX <= minix
+ UNX <= Atari SysV Unix
+ SV4 <= Univ System 4 */
+ { "ext2", "LNX", INT32_MAX },
+ { "ext3", "LNX", INT32_MAX },
+ { "fat16", "GEM", GEM_MAX }, /* small partitions */
+ { "fat16", "BGM", INT32_MAX }, /* big partitions */
+ { "fat32", "F32", INT32_MAX },
+ { "hfs", "MAC", INT32_MAX },
+ { "hfs+", "MAC", INT32_MAX },
+ { "hfsx", "MAC", INT32_MAX },
+ { "jfs", "LNX", INT32_MAX },
+ { "linux-swap", "SWP", INT32_MAX },
+ { "reiserfs", "LNX", INT32_MAX },
+ { "hp-ufs", "LNX", INT32_MAX },
+ { "sun-ufs", "LNX", INT32_MAX },
+ { "xfs", "LNX", INT32_MAX },
+ { "ntfs", "RAW", INT32_MAX },
+ { "", "RAW", INT32_MAX }, /* default entry */
+ { NULL, "" , 0 } /* end of list */
+};
+
+struct __attribute__ ((packed)) _AtariRawPartition {
+ uint8_t flag; /* bit 0: active; bit 7: bootable */
+ uint8_t id[3]; /* "GEM", "BGM", "XGM", ... */
+ uint32_t start; /* start of partition */
+ uint32_t size; /* length of partition */
+};
+typedef struct _AtariRawPartition AtariRawPartition;
+
+struct __attribute__ ((packed)) _AtariRawTable {
+ uint8_t boot_code[0x156]; /* room for boot code */
+ AtariRawPartition icd_part[N_ICD]; /* info for ICD-partitions 5..12 */
+ uint8_t unused[0xc];
+ uint32_t hd_size; /* size of disk in blocks */
+ AtariRawPartition part[N_AHDI]; /* the four primary partitions */
+ uint32_t bsl_start; /* start of bad sector list */
+ uint32_t bsl_count; /* length of bad sector list */
+ uint16_t checksum; /* checksum for bootable disks */
+};
+typedef struct _AtariRawTable AtariRawTable;
+
+typedef enum {
+ FMT_AHDI = 0, /* AHDI v1 compatible, no ICD and no XGM */
+ FMT_XGM = 1, /* AHDI v3 with XGM / this disable ICD */
+ FMT_ICD = 2 /* ICD detected / requested because more than 4 prim */
+ /* no XGM allowed */
+} AtrFmt;
+
+struct _AtariDisk {
+ AtrFmt format;
+ int has_been_read; /* actually means has been read or written... */
+ uint32_t bsl_start; /* first sector of the Bad Sectors List */
+ uint32_t bsl_count; /* number of sectors of the BSL */
+ uint8_t HDX_comp; /* if set to one, atari_write will initialize */
+ /* the bsl area */
+};
+typedef struct _AtariDisk AtariDisk;
+
+struct _AtariPart {
+ char part_id[4]; /* ASCIIZ */
+ char icd_id[4]; /* Linux only parse a limited set of ID */
+ /* in ICD (why???), so everything else */
+ /* is translated to RAW. */
+ uint8_t flag; /* without bit 0 (entry used) */
+};
+typedef struct _AtariPart AtariPart;
+
+/* set by initialisation code to C locale */
+static locale_t atr_c_locale;
+
+static PedDiskType atari_disk_type;
+
+
+
+/******************************** Atari Code ********************************/
+
+#define ATARI_DISK(disk) ((AtariDisk*)((disk)->disk_specific))
+#define ATARI_PART(part) ((AtariPart*)((part)->disk_specific))
+
+#define atr_pid_eq(a,b) (!memcmp( (a), (b), 3 ))
+
+#define atr_pid_assign(a, b) (memcpy ( (a), (b), 3 ))
+
+#define atr_part_used(part) (((part)->flag) & PART_FLAG_USED)
+
+static int
+atr_start_size_correct (uint32_t start, uint32_t size, uint32_t hd_size)
+{
+ uint32_t end = start + size;
+
+ return end >= start
+ && 0 < start && start <= hd_size
+ && 0 < size && size <= hd_size
+ && 0 < end && end <= hd_size;
+}
+
+static int
+atr_part_correct (AtariRawPartition* part, uint32_t hd_size)
+{
+ uint32_t start, size;
+
+ start = PED_BE32_TO_CPU (part->start);
+ size = PED_BE32_TO_CPU (part->size);
+
+ return isalnum_l(part->id[0], atr_c_locale)
+ && isalnum_l(part->id[1], atr_c_locale)
+ && isalnum_l(part->id[2], atr_c_locale)
+ && atr_start_size_correct (start, size, hd_size);
+}
+
+static int _GL_ATTRIBUTE_PURE
+atr_pid_known (const char* pid, const char** pid_list)
+{
+ for (; *pid_list; pid_list++) {
+ if (atr_pid_eq(pid, *pid_list))
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Recognize Parted signature in an AHDI entry, used to
+ * identify empty Atari partition tables */
+static int
+atr_is_signature_entry (AtariRawPartition* part)
+{
+ return part->flag == 0
+ && !memcmp (part->id, SIGNATURE_EMPTY_TABLE,
+ SIGNATURE_EMPTY_SIZE );
+}
+
+/* Set Parted signature in an AHDI entry */
+static void
+atr_put_signature_entry (AtariRawPartition* part)
+{
+ part->flag = 0;
+ memcpy (part->id, SIGNATURE_EMPTY_TABLE, SIGNATURE_EMPTY_SIZE);
+}
+
+#define atr_part_known(part, pid_list) (atr_pid_known ((part)->id, pid_list))
+
+#define atr_part_valid(part, sz) (atr_part_used(part)\
+ && atr_part_correct((part), (sz)))
+#define atr_part_trash(part, sz) (atr_part_used(part)\
+ && !atr_part_correct((part), (sz)))
+
+/* Check if this device can be used with an Atari label */
+static int
+atr_can_use_dev (const PedDevice *dev)
+{
+ /* i really don't know how atari behave with non 512 bytes */
+ /* sectors... */
+ if (dev->sector_size != PED_SECTOR_SIZE_DEFAULT) {
+ ped_exception_throw (
+ PED_EXCEPTION_ERROR,
+ PED_EXCEPTION_CANCEL,
+ _("Can't use Atari partition tables on disks with a "
+ "sector size not equal to %d bytes."),
+ (int)PED_SECTOR_SIZE_DEFAULT );
+ return 0;
+ }
+
+ /* the format isn't well defined enough to support > 0x7FFFFFFF */
+ /* sectors */
+ if (dev->length > INT32_MAX) {
+ ped_exception_throw (
+ PED_EXCEPTION_ERROR,
+ PED_EXCEPTION_CANCEL,
+ _("Can't use Atari partition tables on disks with more "
+ "than %d sectors."),
+ INT32_MAX );
+ return 0;
+ }
+
+ return 1;
+}
+
+/*
+ * The Atari disk label doesn't have any magic id
+ * so we must completely parse the layout to be sure
+ * we are really dealing with it.
+ */
+static int
+atari_probe (const PedDevice *dev)
+{
+ AtariRawTable table;
+ uint32_t rs_hd_size, parts, exts;
+ int valid_count, xgm_part, xgm_num, i;
+ int num_sign, total_count = 0;
+
+ PED_ASSERT (dev != NULL);
+
+ /* Device Spec ok for Atari label? */
+ if (!atr_can_use_dev (dev))
+ return 0;
+
+ /* read the root sector */
+ if (!ped_device_read (dev, &table, 0, 1))
+ return 0;
+
+ /* number of sectors stored in the root sector > device length ? */
+ /* => just reject the Atari disk label */
+ rs_hd_size = PED_BE32_TO_CPU (table.hd_size);
+ if (rs_hd_size > dev->length
+ || rs_hd_size < 2)
+ return 0;
+
+ /* check the BSL fields */
+ if ((table.bsl_start || table.bsl_count)
+ && !atr_start_size_correct (PED_BE32_TO_CPU (table.bsl_start),
+ PED_BE32_TO_CPU (table.bsl_count),
+ rs_hd_size ) )
+ return 0;
+
+ /* scan the main AHDI fields */
+ num_sign = 0; xgm_num = 0;
+ valid_count = 0; xgm_part = 0;
+ for (i = 0; i < N_AHDI; i++) {
+ if (atr_part_valid (&table.part[i], rs_hd_size)) {
+ valid_count++;
+ total_count++;
+ if (atr_pid_eq(table.part[i].id, "XGM")) {
+ xgm_part++;
+ xgm_num = i;
+ }
+ } else if (atr_part_trash (&table.part[i], rs_hd_size)) {
+ return 0;
+ }
+ if (atr_is_signature_entry (&table.part[i]))
+ num_sign++;
+ }
+
+ /* no way to reliably detect empty Atari disk labels if
+ * they aren't using parted signature in 4 prim fields
+ * && reject multi XGM labels because Parted can't handle
+ * multiple extended partitions
+ * && reject if xgm partition in slot 0 because not allowed */
+ if ((!valid_count && num_sign != N_AHDI)
+ || xgm_part > 1
+ || (xgm_part == 1 && xgm_num == 0) )
+ return 0;
+
+ /* check coherency of each logical partitions and ARS */
+ if (xgm_part) { /* ! WARNING ! reuses "table" */
+ /* we must allow empty ext partition even if they're */
+ /* not valid because parted write the layout to the HD */
+ /* at each operation, and we can't create ext and log */
+ /* at the same time */
+ int empty_ars_allowed = 1;
+
+ parts = exts = PED_BE32_TO_CPU (table.part[xgm_num].start);
+ while (1) {
+ if (!ped_device_read (dev, &table, parts, 1))
+ return 0;
+
+ for (i = 0; i < N_AHDI-1; ++i) {
+ if (atr_part_used (&table.part[i]))
+ break;
+ }
+
+ /* we allow the ext part to be empty (see above) */
+ if (i == N_AHDI-1 && empty_ars_allowed)
+ break;
+
+ /* data partition must be in slot 0, 1 or 2 */
+ if (i == N_AHDI-1
+ || !atr_part_correct (&table.part[i], rs_hd_size
+ - parts )
+ || atr_pid_eq (table.part[i].id, "XGM"))
+ return 0;
+
+ /* If there is at least one logical partition */
+ /* then next ARS should not be empty */
+ empty_ars_allowed = 0;
+
+ total_count++;
+ if (total_count > MAXIMUM_PARTS) {
+ ped_exception_throw (
+ PED_EXCEPTION_ERROR,
+ PED_EXCEPTION_CANCEL,
+ _("Too many Atari partitions detected. "
+ " Maybe there is a loop in the XGM "
+ "linked list. Aborting.") );
+ return 0;
+ }
+
+ /* end of logical partitions? */
+ if (!atr_part_used (&table.part[i+1]))
+ break;
+
+ /* is this really the descriptor of the next ARS? */
+ if (!atr_part_correct (&table.part[i+1], rs_hd_size
+ - exts )
+ || !atr_pid_eq (table.part[i+1].id, "XGM"))
+ return 0;
+
+ parts = exts + PED_BE32_TO_CPU (table.part[i+1].start);
+ }
+ } /* no XGM so try ICD */
+ else if (atr_part_valid (&table.icd_part[0], rs_hd_size)
+ && atr_part_known (&table.icd_part[0], atr_known_icd_pid)) {
+ for (i = 1; i < N_ICD; i++) {
+ if (atr_part_trash (&table.icd_part[i], rs_hd_size))
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+static void
+atr_disk_reset (AtariDisk* atr_disk)
+{
+ /* Empty partition table => only AHDI needed right now */
+ atr_disk->format = FMT_AHDI;
+ /* The disk is not in sync with the actual content of the label */
+ atr_disk->has_been_read = 0;
+ /* Create an empty BSL for HDX compatibility */
+ atr_disk->bsl_start = 1;
+ atr_disk->bsl_count = 1;
+ atr_disk->HDX_comp = 1;
+}
+
+/*
+ * Must set up the PedDisk and the associated AtariDisk as if
+ * the user is doing mklabel, since in this case atari_alloc
+ * is called alone whereas when reading an existing partition
+ * table atari_read is called after atari_alloc and can overwrite
+ * the settings.
+ */
+static PedDisk*
+atari_alloc (const PedDevice* dev)
+{
+ PedDisk* disk;
+ AtariDisk* atr_disk;
+
+ PED_ASSERT (dev != NULL);
+
+ if (!atr_can_use_dev (dev)
+ || !(disk = _ped_disk_alloc (dev, &atari_disk_type)))
+ return NULL;
+
+ if (!(disk->disk_specific = atr_disk = ped_malloc (sizeof (AtariDisk))))
+ goto error_free_disk;
+
+ atr_disk_reset (atr_disk);
+
+ return disk;
+
+error_free_disk:
+ free (disk);
+ return NULL;
+}
+
+static PedDisk*
+atari_duplicate (const PedDisk* disk)
+{
+ PedDisk* new_disk;
+ AtariDisk* old_atr_dsk;
+ AtariDisk* new_atr_dsk;
+
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
+ PED_ASSERT (disk->disk_specific != NULL);
+
+ old_atr_dsk = ATARI_DISK (disk);
+ if (!(new_disk = ped_disk_new_fresh (disk->dev, &atari_disk_type)))
+ return NULL;
+ new_atr_dsk = ATARI_DISK (new_disk);
+
+ memcpy (new_atr_dsk, old_atr_dsk, sizeof(*old_atr_dsk));
+
+ return new_disk;
+}
+
+static void
+atari_free (PedDisk* disk)
+{
+ AtariDisk* atr_disk;
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->disk_specific != NULL);
+ atr_disk = ATARI_DISK (disk);
+
+ _ped_disk_free (disk);
+ free (atr_disk);
+}
+
+/* Warning : ID not ASCIIZ but 3 chars long */
+static void
+atr_part_sysraw (PedPartition* part, const char* id, uint8_t flag)
+{
+ AtariPart* atr_part = ATARI_PART (part);
+
+ atr_part->flag = flag & ~PART_FLAG_USED;
+
+ atr_pid_assign (atr_part->part_id, id);
+ atr_part->part_id[3] = 0;
+
+ if (atr_pid_known (id, atr_known_icd_pid)) {
+ atr_pid_assign (atr_part->icd_id, id);
+ atr_part->icd_id[3] = 0;
+ } else {
+ atr_pid_assign (atr_part->icd_id, "RAW");
+ atr_part->icd_id[3] = 0;
+ }
+}
+
+static int
+atr_parse_add_rawpart (PedDisk* disk, PedPartitionType type, PedSector st_off,
+ int num, const AtariRawPartition* rawpart )
+{
+ PedSector start, end;
+ PedPartition* part;
+ PedConstraint* const_exact;
+ int added;
+
+ start = st_off + PED_BE32_TO_CPU (rawpart->start);
+ end = start + PED_BE32_TO_CPU (rawpart->size) - 1;
+
+ part = ped_partition_new (disk, type, NULL, start, end);
+ if (!part)
+ return 0;
+
+ /*part->num = num;*/ /* Enumeration will take care of that */
+ part->num = -1; /* Indeed we can't enumerate here
+ * because the enumerate function uses
+ * -1 do detect new partition being
+ * inserted and update the atrdisk->format */
+ if (type != PED_PARTITION_EXTENDED)
+ part->fs_type = ped_file_system_probe (&part->geom);
+ else
+ part->fs_type = NULL;
+ atr_part_sysraw (part, rawpart->id, rawpart->flag);
+
+ const_exact = ped_constraint_exact (&part->geom);
+ added = ped_disk_add_partition (disk, part, const_exact);
+ ped_constraint_destroy (const_exact);
+ if (!added) {
+ ped_partition_destroy (part);
+ return 0;
+ }
+
+ PED_ASSERT (part->num == num);
+ return 1;
+}
+
+/*
+ * Read the chained list of logical partitions.
+ * exts points to the first Auxiliary Root Sector, at the start
+ * of the extended partition.
+ * In each ARS one partition entry describes to the logical partition
+ * (start relative to the ARS position) and the next entry with ID "XGM"
+ * points to the next ARS (start relative to exts).
+ */
+static int
+atr_read_logicals (PedDisk* disk, PedSector exts, int* pnum)
+{
+ AtariRawTable table;
+ PedSector parts = exts;
+ int i, empty_ars_allowed = 1;
+
+ while (1) {
+ if (!ped_device_read (disk->dev, &table, parts, 1))
+ return 0;
+
+ for (i = 0; i < N_AHDI-1; ++i)
+ if (atr_part_used (&table.part[i]))
+ break;
+
+ if (i == N_AHDI-1 && empty_ars_allowed)
+ break;
+
+ /* data partition must be in slot 0, 1 or 2 */
+ if (i == N_AHDI-1
+ || atr_pid_eq (table.part[i].id, "XGM")) {
+ ped_exception_throw (
+ PED_EXCEPTION_ERROR,
+ PED_EXCEPTION_CANCEL,
+ _("No data partition found in the ARS at "
+ "sector %lli."), parts );
+ return 0;
+ }
+
+ empty_ars_allowed = 0;
+
+ if (!atr_parse_add_rawpart (disk, PED_PARTITION_LOGICAL,
+ parts, *pnum, &table.part[i] ) )
+ return 0;
+
+ (*pnum)++;
+
+ /* end of logical partitions? */
+ if (!atr_part_used (&table.part[i+1]))
+ break;
+
+ if (!atr_pid_eq (table.part[i+1].id, "XGM")) {
+ ped_exception_throw (
+ PED_EXCEPTION_ERROR,
+ PED_EXCEPTION_CANCEL,
+ _("The entry of the next logical ARS is not of "
+ "type XGM in ARS at sector %lli."), parts );
+ return 0;
+ }
+
+ parts = exts + PED_BE32_TO_CPU (table.part[i+1].start);
+ }
+
+ return 1;
+}
+
+static int
+atari_read (PedDisk* disk)
+{
+ AtariRawTable table;
+ AtariDisk* atr_disk;
+ uint32_t rs_hd_size;
+ int i, pnum, xgm, pcount;
+
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
+ PED_ASSERT (disk->disk_specific != NULL);
+ atr_disk = ATARI_DISK (disk);
+
+ ped_disk_delete_all (disk);
+ atr_disk_reset (atr_disk);
+
+ if (!atari_probe (disk->dev)) {
+ if (ped_exception_throw (
+ PED_EXCEPTION_ERROR,
+ PED_EXCEPTION_IGNORE_CANCEL,
+ _("There doesn't seem to be an Atari partition table "
+ "on this disk (%s), or it is corrupted."),
+ disk->dev->path )
+ != PED_EXCEPTION_IGNORE)
+ return 0;
+ }
+
+ if (!ped_device_read (disk->dev, (void*) &table, 0, 1))
+ goto error;
+
+ /* We are sure that the layout looks coherent so we
+ don't need to check too much */
+
+ rs_hd_size = PED_BE32_TO_CPU (table.hd_size);
+ atr_disk->bsl_start = PED_BE32_TO_CPU (table.bsl_start);
+ atr_disk->bsl_count = PED_BE32_TO_CPU (table.bsl_count);
+ atr_disk->HDX_comp = 0;
+
+ /* AHDI primary partitions */
+ pnum = 1; xgm = 0; pcount = 0;
+ for (i = 0; i < N_AHDI; i++) {
+ if (!atr_part_used (&table.part[i]))
+ continue;
+
+ pcount++;
+
+ if (atr_pid_eq (table.part[i].id, "XGM")) {
+
+ atr_disk->format = FMT_XGM;
+ xgm = 1;
+ if (!atr_parse_add_rawpart(disk, PED_PARTITION_EXTENDED,
+ 0, 0, &table.part[i] )
+ || !atr_read_logicals (
+ disk,
+ PED_BE32_TO_CPU (table.part[i].start),
+ &pnum ) )
+ goto error;
+
+ } else {
+
+ if (!atr_parse_add_rawpart (disk, PED_PARTITION_NORMAL,
+ 0, pnum, &table.part[i] ) )
+ goto error;
+ pnum++;
+ }
+ }
+
+ /* If no XGM partition has been found, the AHDI table is not empty, */
+ /* the first entry is valid and its ID ok for ICD, then we parse the */
+ /* ICD table. */
+ if (!xgm && pcount != 0
+ && atr_part_valid (&table.icd_part[0], rs_hd_size)
+ && atr_part_known (&table.icd_part[0], atr_known_icd_pid))
+ for (i = 0; i < N_ICD; i++) {
+
+ if (!atr_part_known (&table.icd_part[i], atr_known_icd_pid)
+ || !atr_part_used (&table.icd_part[i]))
+ continue;
+ atr_disk->format = FMT_ICD;
+
+ if (!atr_parse_add_rawpart (disk, PED_PARTITION_NORMAL,
+ 0, pnum, &table.icd_part[i] ) )
+ goto error;
+ pnum++;
+ }
+
+ atr_disk->has_been_read = 1;
+ return 1;
+
+error:
+ ped_disk_delete_all (disk);
+ atr_disk_reset (atr_disk);
+ return 0;
+}
+
+/* Returns the number of the first logical partition or -1 if not found */
+static int
+atr_find_first_log (const PedDisk* disk)
+{
+ PedPartition* part;
+ int first_log, last;
+
+ last = ped_disk_get_last_partition_num (disk);
+
+ for (first_log = 1; first_log <= last; first_log++) {
+ if ((part = ped_disk_get_partition (disk, first_log))
+ && (part->type & PED_PARTITION_LOGICAL))
+ break;
+ }
+
+ return first_log > last ? -1 : first_log;
+}
+
+#ifndef DISCOVER_ONLY
+static int
+atari_clobber (PedDevice* dev)
+{
+ AtariRawTable table;
+
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (atari_probe (dev));
+
+ if (!ped_device_read (dev, &table, 0, 1))
+ return 0;
+
+ /* clear anything but the boot code and the optional ICD table */
+ memset (table.boot_code + offsetof (AtariRawTable, hd_size),
+ 0,
+ PED_SECTOR_SIZE_DEFAULT - offsetof (AtariRawTable, hd_size));
+
+ return ped_device_write (dev, &table, 0, 1);
+}
+
+/* Computes the checksum of the root sector */
+static uint16_t
+atr_calc_rs_sum (const AtariRawTable* table)
+{
+ const uint16_t* word = (uint16_t*)(table);
+ const uint16_t* end = (uint16_t*)(table + 1);
+ uint16_t sum;
+
+ for (sum = 0; word < end; word++)
+ sum += PED_BE16_TO_CPU(*word);
+
+ return sum;
+}
+
+/* Returns 1 if the root sector is bootable, else returns 0 */
+static int
+atr_is_boot_table (const AtariRawTable* table)
+{
+ return atr_calc_rs_sum (table) == BOOTABLE_CKSUM;
+}
+
+/*
+ * Returns 1 if sign belongs to a set of `forbidden' signatures.
+ * (e.g.: 55AA which is the MSDOS siganture...)
+ * Only used for non bootable root sector since the signature of
+ * a bootable one is unique.
+ */
+static int _GL_ATTRIBUTE_PURE
+atr_sign_is_forbidden (uint16_t sign)
+{
+ const uint16_t* forbidden;
+
+ for (forbidden = atr_forbidden_sign; *forbidden; forbidden++) {
+ if (sign == *forbidden)
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Updates table->checksum so the RS will be considered bootable (or not) */
+static void
+atr_table_set_boot (AtariRawTable* table, int boot)
+{
+ uint16_t boot_cksum, noboot_cksum;
+ uint16_t sum;
+
+ table->checksum = 0;
+ sum = atr_calc_rs_sum (table);
+ boot_cksum = BOOTABLE_CKSUM - sum;
+
+ if (boot) {
+ table->checksum = PED_CPU_TO_BE16 (boot_cksum);
+ return;
+ }
+
+ noboot_cksum = NONBOOT_CKSUM - sum;
+
+ while (atr_sign_is_forbidden (noboot_cksum)
+ || noboot_cksum == boot_cksum)
+ noboot_cksum++;
+
+ table->checksum = PED_CPU_TO_BE16 (noboot_cksum);
+}
+
+/* Fill an used partition entry */
+static void
+atr_fill_raw_entry (AtariRawPartition* rawpart, uint8_t flag, const char* id,
+ uint32_t start, uint32_t size )
+{
+ rawpart->flag = PART_FLAG_USED | flag;
+ atr_pid_assign (rawpart->id, id);
+ rawpart->start = PED_CPU_TO_BE32 (start);
+ rawpart->size = PED_CPU_TO_BE32 (size);
+}
+
+static int
+atr_write_logicals (const PedDisk* disk)
+{
+ AtariRawTable table;
+ PedPartition* log_curr;
+ PedPartition* log_next;
+ PedPartition* ext;
+ PedPartition* part;
+ PedSector exts;
+ PedSector parts;
+ AtariPart* atr_part;
+ int first_log, pnum, i;
+
+ PED_ASSERT (disk != NULL);
+
+ ext = ped_disk_extended_partition (disk);
+ exts = parts = ext->geom.start;
+
+ pnum = first_log = atr_find_first_log (disk);
+
+ while (1) {
+ if (pnum != -1) {
+ log_curr = ped_disk_get_partition (disk, pnum);
+ log_next = ped_disk_get_partition (disk, pnum + 1);
+ } else {
+ log_curr = log_next = NULL;
+ }
+
+ if (log_curr && !(log_curr->type & PED_PARTITION_LOGICAL))
+ log_curr = NULL;
+ if (log_next && !(log_next->type & PED_PARTITION_LOGICAL))
+ log_next = NULL;
+
+ PED_ASSERT (pnum == first_log || log_curr);
+
+ part = ped_disk_get_partition_by_sector (disk, parts);
+ if (part && ped_partition_is_active (part)) {
+ if (log_curr)
+ ped_exception_throw (
+ PED_EXCEPTION_ERROR,
+ PED_EXCEPTION_CANCEL,
+ _("No room at sector %lli to store ARS "
+ "of logical partition %d."),
+ parts, pnum );
+ else
+ ped_exception_throw (
+ PED_EXCEPTION_ERROR,
+ PED_EXCEPTION_CANCEL,
+ _("No room at sector %lli to store ARS."),
+ parts );
+ return 0;
+ }
+
+ if (!ped_device_read (disk->dev, &table, parts, 1))
+ return 0;
+
+ if (!log_curr) {
+ PED_ASSERT (!log_next);
+
+ for (i = 0; i < N_AHDI; i++)
+ table.part[i].flag &= ~PART_FLAG_USED;
+ } else {
+ atr_part = ATARI_PART (log_curr);
+ atr_fill_raw_entry (&table.part[0], atr_part->flag,
+ atr_part->part_id,
+ log_curr->geom.start - parts,
+ log_curr->geom.length );
+
+ for (i = 1; i < N_AHDI; i++)
+ table.part[i].flag &= ~PART_FLAG_USED;
+
+ if (log_next) {
+ atr_fill_raw_entry (&table.part[1], 0, "XGM",
+ log_next->geom.start - 1 - exts,
+ log_next->geom.length + 1 );
+ }
+ }
+
+ /* TODO: check if we can set that bootable, and when */
+ atr_table_set_boot (&table, 0);
+
+ if (!ped_device_write (disk->dev, &table, parts, 1))
+ return 0;
+
+ if (!log_next)
+ break;
+
+ parts = log_next->geom.start - 1;
+ pnum++;
+ }
+
+ return 1;
+}
+
+static int _GL_ATTRIBUTE_PURE
+_disk_logical_partition_count (const PedDisk* disk)
+{
+ PedPartition* walk;
+
+ int count = 0;
+
+ PED_ASSERT (disk != NULL);
+ for (walk = disk->part_list; walk;
+ walk = ped_disk_next_partition (disk, walk)) {
+ if (ped_partition_is_active (walk)
+ && (walk->type & PED_PARTITION_LOGICAL))
+ count++;
+ }
+
+ return count;
+}
+
+/* Load the HD size from the table and ask to fix it if != device size. */
+static int
+atr_load_fix_hdsize (const PedDisk* disk, uint32_t* rs_hd_size, AtariRawTable* table)
+{
+ AtariDisk* atr_disk = ATARI_DISK (disk);
+ int result = PED_EXCEPTION_UNHANDLED;
+
+ *rs_hd_size = PED_BE32_TO_CPU (table->hd_size);
+ if (*rs_hd_size != disk->dev->length) {
+ if (atr_disk->has_been_read) {
+ result = ped_exception_throw (
+ PED_EXCEPTION_WARNING,
+ PED_EXCEPTION_FIX | PED_EXCEPTION_IGNORE_CANCEL,
+ _("The sector count that is stored in the "
+ "partition table does not correspond "
+ "to the size of your device. Do you "
+ "want to fix the partition table?") );
+ if (result == PED_EXCEPTION_CANCEL)
+ return 0;
+ }
+
+ if (result == PED_EXCEPTION_UNHANDLED)
+ result = PED_EXCEPTION_FIX;
+
+ if (result == PED_EXCEPTION_FIX) {
+ *rs_hd_size = disk->dev->length;
+ table->hd_size = PED_CPU_TO_BE32(*rs_hd_size);
+ }
+ }
+ return 1;
+}
+
+/* Try to init the HDX compatibility Bad Sectors List. */
+static int
+atr_empty_init_bsl (const PedDisk* disk)
+{
+ uint8_t zeros[PED_SECTOR_SIZE_DEFAULT];
+ PedSector sec;
+ PedPartition* part;
+ AtariDisk* atr_disk = ATARI_DISK (disk);
+
+ memset (zeros, 0, PED_SECTOR_SIZE_DEFAULT);
+ for (sec = atr_disk->bsl_start;
+ sec < atr_disk->bsl_start + atr_disk->bsl_count;
+ sec++ ) {
+ if (sec == atr_disk->bsl_start)
+ zeros[3] = 0xA5;
+ else
+ zeros[3] = 0;
+ part = ped_disk_get_partition_by_sector (disk, sec);
+ if (part && ped_partition_is_active (part)) {
+ ped_exception_throw (
+ PED_EXCEPTION_ERROR,
+ PED_EXCEPTION_CANCEL,
+ _("No room at sector %lli to store BSL."),
+ sec );
+ return 0;
+ }
+ ped_device_write (disk->dev, zeros, sec, 1);
+ }
+ atr_disk->HDX_comp = 0;
+ return 1;
+}
+
+static int
+atari_write (const PedDisk* disk)
+{
+ AtariRawTable table;
+ AtariDisk* atr_disk;
+ AtariPart* atr_part;
+ PedPartition* log;
+ PedPartition* ext_part;
+ PedPartition* part = NULL;
+ uint32_t rs_hd_size;
+ int i, xgm_begin, pnum, append_ext;
+ int put_sign, boot, prim_count, last_num;
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
+ atr_disk = ATARI_DISK (disk);
+ PED_ASSERT (atr_disk != NULL);
+
+ prim_count = ped_disk_get_primary_partition_count (disk);
+ last_num = ped_disk_get_last_partition_num (disk);
+ ext_part = ped_disk_extended_partition (disk);
+
+ /* WARNING: similar/related code in atari_enumerate */
+ xgm_begin = ((log = ped_disk_get_partition (disk, 1))
+ && (log->type & PED_PARTITION_LOGICAL));
+ PED_ASSERT (atr_disk->format != FMT_ICD || ext_part == NULL);
+ PED_ASSERT (atr_disk->format != FMT_XGM || prim_count + xgm_begin <= N_AHDI);
+ PED_ASSERT (atr_disk->format != FMT_AHDI || (ext_part == NULL && prim_count + xgm_begin <= N_AHDI));
+
+ /* Device Spec ok for Atari label? */
+ if (!atr_can_use_dev (disk->dev))
+ goto error;
+
+ if (!ped_device_read (disk->dev, (void*) &table, 0, 1))
+ goto error;
+
+ boot = atr_is_boot_table (&table);
+
+ table.bsl_start = PED_CPU_TO_BE32 (atr_disk->bsl_start);
+ table.bsl_count = PED_CPU_TO_BE32 (atr_disk->bsl_count);
+
+ /* Before anything else check the sector count and */
+ /* fix it if necessary */
+ if (!atr_load_fix_hdsize (disk, &rs_hd_size, &table))
+ goto error;
+
+ append_ext = (ext_part != NULL)
+ && (_disk_logical_partition_count (disk) == 0);
+
+ /* Fill the AHDI table */
+ put_sign = (prim_count == 0);
+ pnum = 1;
+ for (i = 0; i < N_AHDI; i++) {
+ if (pnum > last_num)
+ part = NULL;
+ else while (pnum <= last_num
+ && !(part = ped_disk_get_partition (disk, pnum)))
+ pnum++;
+
+ if (put_sign) {
+ atr_put_signature_entry (&table.part[i]);
+ continue;
+ }
+
+ if (!part && i != 0 && append_ext) {
+ part = ext_part;
+ append_ext = 0;
+ }
+
+ if (!part || (i == 0 && xgm_begin)) {
+ table.part[i].flag &= ~PART_FLAG_USED;
+ continue;
+ }
+
+ if (part->type & PED_PARTITION_LOGICAL)
+ part = ext_part;
+
+ PED_ASSERT (part != NULL);
+
+ atr_part = ATARI_PART (part);
+ atr_fill_raw_entry (&table.part[i], atr_part->flag,
+ atr_part->part_id, part->geom.start,
+ part->geom.length );
+
+ if (part->type & PED_PARTITION_EXTENDED) {
+ while (pnum <= last_num) {
+ part = ped_disk_get_partition (disk, pnum);
+ if (part &&
+ !(part->type & PED_PARTITION_LOGICAL))
+ break;
+ pnum++;
+ }
+ } else
+ pnum++;
+ }
+
+ if ((ext_part != NULL || atr_disk->format == FMT_AHDI)
+ && pnum <= last_num) {
+ ped_exception_throw (PED_EXCEPTION_BUG, PED_EXCEPTION_CANCEL,
+ _("There were remaining partitions after filling "
+ "the main AHDI table.") );
+ goto error;
+ }
+
+ /* Leave XGM or ICD mode if uneeded */
+ if (pnum > last_num
+ && (atr_disk->format == FMT_ICD || ext_part == NULL))
+ atr_disk->format = FMT_AHDI;
+
+ /* If AHDI mode, check that no ICD will be detected */
+ /* and propose to fix */
+ if (atr_disk->format == FMT_AHDI
+ && atr_part_valid (&table.icd_part[0], rs_hd_size)
+ && atr_part_known (&table.icd_part[0], atr_known_icd_pid)) {
+ int result = PED_EXCEPTION_UNHANDLED;
+ result = ped_exception_throw (
+ PED_EXCEPTION_WARNING,
+ PED_EXCEPTION_YES_NO_CANCEL,
+ _("The main AHDI table has been filled with all "
+ "partitions but the ICD table is not empty "
+ "so more partitions of unknown size and position "
+ "will be detected by ICD compatible software. Do "
+ "you want to invalidate the ICD table?") );
+ if (result == PED_EXCEPTION_YES
+ || result == PED_EXCEPTION_UNHANDLED)
+ table.icd_part[0].flag &= ~PART_FLAG_USED;
+ else if (result == PED_EXCEPTION_CANCEL)
+ goto error;
+ }
+
+ if (put_sign)
+ goto write_to_dev;
+
+ /* Fill the ICD table */
+ if (atr_disk->format == FMT_ICD)
+ for (i = 0; i < N_ICD; i++) {
+ if (pnum > last_num)
+ part = NULL;
+ else while (pnum <= last_num
+ && !(part = ped_disk_get_partition (disk, pnum)))
+ pnum++;
+
+ if (!part) {
+ table.icd_part[i].flag &= ~PART_FLAG_USED;
+ continue;
+ }
+
+ if (part->type & PED_PARTITION_EXTENDED
+ || part->type & PED_PARTITION_LOGICAL) {
+ ped_exception_throw (
+ PED_EXCEPTION_BUG,
+ PED_EXCEPTION_CANCEL,
+ _("ICD entries can't contain extended or "
+ "logical partitions.") );
+ goto error;
+ }
+
+ atr_part = ATARI_PART (part);
+ atr_fill_raw_entry (&table.icd_part[i], atr_part->flag,
+ atr_part->icd_id, part->geom.start,
+ part->geom.length );
+
+ pnum++;
+ }
+
+ /* Write the chained list of logical partitions */
+ if (atr_disk->format == FMT_XGM) {
+ if (!atr_write_logicals (disk))
+ goto error;
+ }
+
+write_to_dev:
+ if (pnum <= last_num) {
+ ped_exception_throw (PED_EXCEPTION_BUG, PED_EXCEPTION_CANCEL,
+ _("There were remaining partitions after filling "
+ "the tables.") );
+ goto error;
+ }
+
+ /* Do we need to do that in case of failure too??? */
+ atr_table_set_boot (&table, boot);
+
+ /* Commit the root sector... */
+ if (!ped_device_write (disk->dev, (void*) &table, 0, 1)
+ || !ped_device_sync (disk->dev))
+ goto error;
+
+ /* Try to init the HDX compatibility Bad Sectors List if needed. */
+ if (atr_disk->HDX_comp && !atr_empty_init_bsl (disk))
+ goto error;
+
+ atr_disk->has_been_read = 1;
+ return ped_device_sync (disk->dev);
+
+error:
+ atr_disk->has_been_read = 0;
+ return 0;
+}
+#endif
+
+/* If extended partition in ICD mode, generate an error and returns 1 */
+/* else returns 0 */
+static int
+atr_xgm_in_icd (const PedDisk* disk, PedPartitionType part_type)
+{
+ AtariDisk* atrdisk;
+
+ PED_ASSERT (disk != NULL);
+
+ if (part_type & PED_PARTITION_EXTENDED) {
+ atrdisk = ATARI_DISK (disk);
+ if (atrdisk->format == FMT_ICD) {
+ ped_exception_throw (
+ PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("You can't use an extended XGM partition in "
+ "ICD mode (more than %d primary partitions, if "
+ "XGM is the first one it counts for two)."),
+ N_AHDI );
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+static PedPartition*
+atari_partition_new (const PedDisk* disk, PedPartitionType part_type,
+ const PedFileSystemType* fs_type,
+ PedSector start, PedSector end)
+{
+ PedPartition* part;
+ AtariPart* atrpart;
+
+ if (atr_xgm_in_icd(disk, part_type))
+ return 0;
+
+ part = _ped_partition_alloc (disk, part_type, fs_type, start, end);
+ if (!part)
+ goto error;
+ if (ped_partition_is_active (part)) {
+ part->disk_specific = atrpart = ped_malloc (sizeof (AtariPart));
+ if (!atrpart)
+ goto error_free_part;
+ memset (atrpart, 0, sizeof (AtariPart));
+ } else {
+ part->disk_specific = NULL;
+ }
+ return part;
+
+error_free_part:
+ _ped_partition_free (part);
+error:
+ return NULL;
+}
+
+static PedPartition*
+atari_partition_duplicate (const PedPartition* part)
+{
+ PedPartition* new_part;
+
+ new_part = ped_partition_new (part->disk, part->type,
+ part->fs_type, part->geom.start,
+ part->geom.end);
+ if (!new_part)
+ return NULL;
+ new_part->num = part->num;
+ if (ped_partition_is_active (part))
+ memcpy (new_part->disk_specific, part->disk_specific,
+ sizeof (AtariPart));
+
+ return new_part;
+}
+
+static void
+atari_partition_destroy (PedPartition* part)
+{
+ PED_ASSERT (part != NULL);
+
+ if (ped_partition_is_active (part)) {
+ PED_ASSERT (part->disk_specific != NULL);
+ free (part->disk_specific);
+ }
+ _ped_partition_free (part);
+}
+
+/* Note: fs_type is NULL for extended partitions */
+static int
+atari_partition_set_system (PedPartition* part,
+ const PedFileSystemType* fs_type)
+{
+ AtariPart* atrpart;
+ AtariFS2PartId* fs2id;
+ PED_ASSERT (part != NULL);
+ atrpart = ATARI_PART (part);
+ PED_ASSERT (atrpart != NULL);
+
+ part->fs_type = fs_type;
+
+ if (atr_xgm_in_icd(part->disk, part->type))
+ return 0;
+
+ if (part->type & PED_PARTITION_EXTENDED) {
+ strcpy (atrpart->part_id, "XGM");
+ strcpy (atrpart->icd_id, "XGM");
+ return 1;
+ }
+
+ if (!fs_type) {
+ strcpy (atrpart->part_id, "RAW");
+ strcpy (atrpart->icd_id, "RAW");
+ return 1;
+ }
+
+ for (fs2id = atr_fs2pid; fs2id->fs; fs2id++) {
+ if (!*fs2id->fs /* default entry */
+ || ((!strcmp (fs_type->name, fs2id->fs)
+ && part->geom.length < fs2id->max_sectors))) {
+
+ strcpy (atrpart->part_id, fs2id->pid);
+ if (atr_pid_known (fs2id->pid, atr_known_icd_pid))
+ strcpy (atrpart->icd_id, fs2id->pid);
+ else
+ strcpy (atrpart->icd_id, "RAW");
+
+ break;
+ }
+ }
+ PED_ASSERT (fs2id->fs != NULL);
+
+ return 1;
+}
+
+static int
+atari_partition_set_flag (PedPartition* part, PedPartitionFlag flag, int state)
+{
+ AtariPart* atr_part;
+ AtariPartID2BootFlag* bf;
+
+ PED_ASSERT (part != NULL);
+ atr_part = ATARI_PART (part);
+ PED_ASSERT (atr_part != NULL);
+
+ if (flag != PED_PARTITION_BOOT)
+ return 0;
+
+ if (state == 0) {
+ atr_part->flag = 0;
+ } else {
+ for (bf = atr_pid2bf; *bf->pid; bf++) {
+ if (atr_pid_eq (bf->pid, atr_part->part_id))
+ break;
+ }
+ atr_part->flag = bf->flag;
+ }
+
+ return 1;
+}
+
+static int _GL_ATTRIBUTE_PURE
+atari_partition_get_flag (const PedPartition* part, PedPartitionFlag flag)
+{
+ AtariPart* atr_part;
+
+ PED_ASSERT (part != NULL);
+ atr_part = ATARI_PART (part);
+ PED_ASSERT (atr_part != NULL);
+
+ if (flag != PED_PARTITION_BOOT)
+ return 0;
+
+ return (atr_part->flag != 0);
+}
+
+static int
+atari_partition_is_flag_available (const PedPartition* part,
+ PedPartitionFlag flag)
+{
+ if (flag == PED_PARTITION_BOOT)
+ return 1;
+
+ return 0;
+}
+
+/* Adapted from disk_dos */
+static PedConstraint*
+atr_log_constraint (const PedPartition* part)
+{
+ const PedGeometry* geom = &part->geom;
+ PedGeometry safe_space;
+ PedSector min_start;
+ PedSector max_end;
+ PedDisk* disk;
+ PedDevice* dev;
+ PedPartition* ext_part;
+ PedPartition* walk;
+ int first_log, not_first;
+
+ PED_ASSERT (part->disk != NULL);
+ PED_ASSERT (part->disk->dev != NULL);
+ ext_part = ped_disk_extended_partition (part->disk);
+ PED_ASSERT (ext_part != NULL);
+
+ dev = (disk = part->disk) -> dev;
+
+ first_log = atr_find_first_log (disk);
+ if (first_log == -1)
+ first_log = part->num;
+
+ not_first = (part->num != first_log);
+
+ walk = ext_part->part_list;
+
+ min_start = ext_part->geom.start + 1 + not_first;
+ max_end = ext_part->geom.end;
+
+ while (walk != NULL
+ && ( walk->geom.start - (walk->num != first_log)
+ < geom->start - not_first
+ || walk->geom.start - (walk->num != first_log)
+ < min_start ) ) {
+ if (walk != part && ped_partition_is_active (walk))
+ min_start = walk->geom.end + 1 + not_first;
+ walk = walk->next;
+ }
+
+ while (walk && (walk == part || !ped_partition_is_active (walk)))
+ walk = walk->next;
+
+ if (walk)
+ max_end = walk->geom.start - 1 - (walk->num != first_log);
+
+ if (min_start >= max_end)
+ return NULL;
+
+ ped_geometry_init (&safe_space, dev, min_start,
+ max_end - min_start + 1);
+ return ped_constraint_new_from_max (&safe_space);
+}
+
+/* Adapted from disk_dos */
+static PedGeometry*
+art_min_extended_geom (const PedPartition* ext_part)
+{
+ PedDisk* disk = ext_part->disk;
+ PedPartition* walk;
+ PedGeometry* min_geom;
+ int first_log;
+
+ first_log = atr_find_first_log (disk);
+ if (first_log == -1)
+ return NULL;
+
+ walk = ped_disk_get_partition (disk, first_log);
+ PED_ASSERT (walk->type & PED_PARTITION_LOGICAL);
+ min_geom = ped_geometry_duplicate (&walk->geom);
+ if (!min_geom)
+ return NULL;
+ ped_geometry_set_start (min_geom, walk->geom.start - 1);
+
+ for (walk = ext_part->part_list; walk; walk = walk->next) {
+ if (!ped_partition_is_active (walk) || walk->num == first_log)
+ continue;
+ if (walk->geom.start < min_geom->start)
+ ped_geometry_set_start (min_geom, walk->geom.start - 2);
+ if (walk->geom.end > min_geom->end)
+ ped_geometry_set_end (min_geom, walk->geom.end);
+ }
+
+ return min_geom;
+}
+
+/* Adapted from disk_dos */
+static PedConstraint*
+atr_ext_constraint (const PedPartition* part)
+{
+ PedGeometry start_range;
+ PedGeometry end_range;
+ PedConstraint* constraint;
+ PedDevice* dev;
+ PedDisk* disk;
+ PedGeometry* min;
+
+ PED_ASSERT (part->disk != NULL);
+ PED_ASSERT (part->disk->dev != NULL);
+
+ dev = (disk = part->disk) -> dev;
+ min = art_min_extended_geom (part);
+
+ if (min) {
+ ped_geometry_init (&start_range, dev, 1, min->start);
+ ped_geometry_init (&end_range, dev, min->end,
+ dev->length - min->end);
+ ped_geometry_destroy (min);
+ } else {
+ ped_geometry_init (&start_range, dev, 1, dev->length - 1);
+ ped_geometry_init (&end_range, dev, 1, dev->length - 1);
+ }
+
+ constraint = ped_constraint_new (ped_alignment_any, ped_alignment_any,
+ &start_range, &end_range, 1, dev->length);
+ return constraint;
+}
+
+static PedConstraint*
+atr_prim_constraint (const PedPartition* part)
+{
+ PedDevice* dev;
+ PedGeometry max;
+
+ PED_ASSERT (part->disk != NULL);
+ PED_ASSERT (part->disk->dev != NULL);
+
+ dev = part->disk->dev;
+
+ ped_geometry_init (&max, dev, 1, dev->length - 1);
+ return ped_constraint_new_from_max (&max);
+}
+
+/* inspiration from disk_dos */
+static PedGeometry*
+_best_solution (PedGeometry* a, PedGeometry* b)
+{
+ if (!a)
+ return b;
+ if (!b)
+ return a;
+
+ if (a->length < b->length)
+ goto choose_b;
+
+ ped_geometry_destroy (b);
+ return a;
+
+choose_b:
+ ped_geometry_destroy (a);
+ return b;
+}
+
+/* copied from disk_dos */
+static PedGeometry*
+_try_constraint (const PedPartition* part, const PedConstraint* external,
+ PedConstraint* internal)
+{
+ PedConstraint* intersection;
+ PedGeometry* solution;
+
+ intersection = ped_constraint_intersect (external, internal);
+ ped_constraint_destroy (internal);
+ if (!intersection)
+ return NULL;
+
+ solution = ped_constraint_solve_nearest (intersection, &part->geom);
+ ped_constraint_destroy (intersection);
+ return solution;
+}
+
+/*
+ * internal is either the primary or extented constraint.
+ * If there's no BSL, the is the only internal constraint considered.
+ * If there's a BSL, try to fit the partition before or after (and
+ * choose the best fit, the one which results in the greatest size...)
+ */
+static int
+atr_prim_align (PedPartition* part, const PedConstraint* constraint,
+ PedConstraint* internal)
+{
+ PedDevice* dev;
+ AtariDisk* atr_disk;
+ PedConstraint* cut;
+ PedGeometry* solution = NULL;
+ PedGeometry max;
+ PedSector bsl_end;
+
+ PED_ASSERT (part->disk != NULL);
+ PED_ASSERT (part->disk->dev != NULL);
+ dev = part->disk->dev;
+ atr_disk = ATARI_DISK (part->disk);
+ PED_ASSERT (atr_disk != NULL);
+
+ /* No BSL */
+ if (!atr_disk->bsl_start && !atr_disk->bsl_count) {
+ /* Note: _ped_partition_attempt_align will destroy internal */
+ return _ped_partition_attempt_align(part, constraint, internal);
+ }
+
+ /* BSL, try to fit before */
+ if (atr_disk->bsl_start > 1) {
+ ped_geometry_init (&max, dev, 1, atr_disk->bsl_start - 1);
+ cut = ped_constraint_new_from_max (&max);
+ solution = _best_solution (solution,
+ _try_constraint (part, constraint,
+ ped_constraint_intersect (internal, cut)));
+ ped_constraint_destroy (cut);
+ }
+
+ /* BSL, try to fit after, take the best solution */
+ bsl_end = atr_disk->bsl_start + atr_disk->bsl_count;
+ if (bsl_end < dev->length) {
+ ped_geometry_init (&max, dev, bsl_end, dev->length - bsl_end);
+ cut = ped_constraint_new_from_max (&max);
+ solution = _best_solution (solution,
+ _try_constraint (part, constraint,
+ ped_constraint_intersect (internal, cut)));
+ ped_constraint_destroy (cut);
+ }
+
+ ped_constraint_destroy (internal);
+
+ if (solution) {
+ ped_geometry_set (&part->geom, solution->start,
+ solution->length);
+ ped_geometry_destroy (solution);
+ return 1;
+ }
+
+ return 0;
+}
+
+static int
+atari_partition_align (PedPartition* part, const PedConstraint* constraint)
+{
+ PED_ASSERT (part != NULL);
+
+ switch (part->type) {
+ case PED_PARTITION_LOGICAL:
+ if (_ped_partition_attempt_align (part, constraint,
+ atr_log_constraint (part) ) )
+ return 1;
+ break;
+ case PED_PARTITION_EXTENDED:
+ if (atr_prim_align (part, constraint,
+ atr_ext_constraint (part) ) )
+ return 1;
+ break;
+ default:
+ if (atr_prim_align (part, constraint,
+ atr_prim_constraint (part) ) )
+ return 1;
+ break;
+ }
+
+#ifndef DISCOVER_ONLY
+ ped_exception_throw (
+ PED_EXCEPTION_ERROR,
+ PED_EXCEPTION_CANCEL,
+ _("Unable to satisfy all constraints on the partition."));
+#endif
+ return 0;
+}
+
+/* increment numbers of any non logical partition found after the last */
+/* logical one, to make room for a new logical partition */
+static int
+art_room_for_logic (PedDisk* disk)
+{
+ PedPartition* part;
+ int num, last_logic, last;
+
+ /* too many partitions ? */
+ last = ped_disk_get_last_partition_num (disk);
+ if (last >= MAXIMUM_PARTS)
+ return 0;
+
+ /* find the last logical partition */
+ last_logic = 0;
+ for (num = 1; num <= last; num++) {
+ part = ped_disk_get_partition (disk, num);
+ if (part && ped_partition_is_active (part)
+ && (part->type & PED_PARTITION_LOGICAL))
+ last_logic = num;
+ }
+
+ if (!last_logic)
+ return 1;
+
+ /* increment */
+ for (num = last; num > last_logic; num--) {
+ part = ped_disk_get_partition (disk, num);
+ if (part && ped_partition_is_active (part)
+ && !(part->type & ( PED_PARTITION_LOGICAL
+ | PED_PARTITION_EXTENDED))
+ && part->num > 0 )
+ part->num++;
+ }
+
+ return 1;
+}
+
+static int
+atari_partition_enumerate (PedPartition* part)
+{
+ AtariDisk* atrdisk;
+ PedPartition* ext_part;
+ PedPartition* log;
+ int i, want_icd, want_xgm, num_max, xgm_begin, prim_count;
+
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk != NULL);
+ atrdisk = ATARI_DISK (part->disk);
+ PED_ASSERT (atrdisk != NULL);
+
+ /* WARNING: some similar/related code in atari_write */
+ /* This is quite a <hack> : this function is probably the only way */
+ /* to know something has been / is going to be modified in the table.*/
+ /* So we detect the current operation mode (AHDI/XGM/ICD) and report */
+ /* errors (in which case we refuse to operate...) */
+
+ prim_count = ped_disk_get_primary_partition_count (part->disk);
+ ext_part = ped_disk_extended_partition (part->disk);
+
+ /* <hack in the hack> : we can't reorder (yet) , so if we begin with */
+ /* XGM the first slot must be empty */
+ xgm_begin = ((log = ped_disk_get_partition (part->disk, 1))
+ && (log->type & PED_PARTITION_LOGICAL))
+ || ((part->num == -1)
+ && (part->type & PED_PARTITION_LOGICAL)
+ && !ped_disk_get_partition (part->disk, 1));
+ /* </hack in the hack> */
+
+ PED_ASSERT (atrdisk->format != FMT_ICD || ext_part == NULL);
+ PED_ASSERT (atrdisk->format != FMT_XGM
+ || prim_count + xgm_begin <= N_AHDI);
+ PED_ASSERT (atrdisk->format != FMT_AHDI
+ || (ext_part == NULL && prim_count + xgm_begin <= N_AHDI));
+
+ want_icd = ( ( prim_count
+ + xgm_begin
+ + ( (part->num == -1)
+ && !(part->type & PED_PARTITION_LOGICAL) ) )
+ > N_AHDI );
+ want_xgm = ( (part->type & PED_PARTITION_EXTENDED)
+ || ext_part != NULL );
+
+ if (!want_xgm && !want_icd)
+ atrdisk->format = FMT_AHDI;
+ else if (want_xgm && !want_icd)
+ atrdisk->format = FMT_XGM;
+ else if (!want_xgm && want_icd)
+ atrdisk->format = FMT_ICD;
+ else {
+ if (atr_xgm_in_icd (part->disk, PED_PARTITION_EXTENDED))
+ return 0;
+ else {
+ ped_exception_throw (
+ PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("You can't use more than %d primary partitions "
+ "(ICD mode) if you use an extended XGM "
+ "partition. If XGM is the first partition "
+ "it counts for two."),
+ N_AHDI );
+ return 0;
+ }
+ }
+ /* End of </hack> */
+
+
+ /* Ext will be numbered 0 and will stay 0... */
+ if (part->num == 0)
+ return 1;
+
+ if (part->num == -1) {
+
+ /* Linux don't show the ext part itself for Atari disk labels */
+ /* so we use number 0 (could use a big number too, but that */
+ /* would be less cute ;) */
+ if (part->type & PED_PARTITION_EXTENDED) {
+ part->num = 0;
+ return 1;
+ }
+
+ switch (atrdisk->format) {
+ case FMT_AHDI:
+ case FMT_ICD:
+ num_max = N_ICD + N_AHDI;
+ break;
+ case FMT_XGM:
+ num_max = MAXIMUM_PARTS;
+ break;
+ default:
+ num_max = 0;
+ PED_ASSERT (0);
+ }
+
+ /* make room for logical partitions */
+ if (part->type & PED_PARTITION_LOGICAL) {
+ if (!art_room_for_logic (part->disk))
+ goto error_alloc_failed;
+ }
+
+ /* find an unused number */
+ for (i = 1; i <= num_max; i++) {
+ if (!ped_disk_get_partition (part->disk, i)) {
+ part->num = i;
+ return 1;
+ }
+ }
+
+ } else {
+ /* find an unused number before or don't re-number */
+ for (i = 1; i < part->num; i++) {
+ if (!ped_disk_get_partition (part->disk, i)) {
+ part->num = i;
+ }
+ }
+ return 1;
+ }
+
+ /* failed to allocate a number */
+error_alloc_failed:
+#ifndef DISCOVER_ONLY
+ ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Unable to allocate a partition number."));
+#endif
+ return 0;
+}
+
+static int
+atr_creat_add_metadata (PedDisk* disk, PedSector start, PedSector end,
+ PedPartitionType type )
+{
+ PedPartition* new_part;
+ PedConstraint* const_exact;
+ int added;
+
+ type |= PED_PARTITION_METADATA;
+ new_part = ped_partition_new (disk, type, NULL, start, end);
+ if (!new_part)
+ goto error;
+
+ const_exact = ped_constraint_exact (&new_part->geom);
+ added = ped_disk_add_partition (disk, new_part, const_exact);
+ ped_constraint_destroy (const_exact);
+ if (!added)
+ goto error_destroy_part;
+
+ return 1;
+
+error_destroy_part:
+ ped_partition_destroy (new_part);
+error:
+ return 0;
+}
+
+static int
+atari_alloc_metadata (PedDisk* disk)
+{
+ PedPartition* ext;
+ PedPartition* log;
+ AtariDisk* atr_disk;
+ int i;
+
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
+ atr_disk = ATARI_DISK (disk);
+ PED_ASSERT (atr_disk != NULL);
+
+ /* allocate 1 sector for the disk label at the start */
+ if (!atr_creat_add_metadata (disk, 0, 0, 0))
+ return 0;
+
+ /* allocate the sectors containing the BSL */
+ if (atr_disk->bsl_start || atr_disk->bsl_count) {
+ if (!atr_creat_add_metadata (disk, atr_disk->bsl_start,
+ atr_disk->bsl_start
+ + atr_disk->bsl_count - 1, 0 ) )
+ return 0;
+ }
+
+ ext = ped_disk_extended_partition (disk);
+ if (ext) {
+ if (!atr_creat_add_metadata (disk, ext->geom.start,
+ ext->geom.start,
+ PED_PARTITION_LOGICAL ) )
+ return 0;
+
+ /* Find the first logical part */
+ for (i = 1; i <= ped_disk_get_last_partition_num (disk); i++)
+ if ((log = ped_disk_get_partition (disk, i))
+ && (log->type & PED_PARTITION_LOGICAL))
+ break;
+
+ for (log = ext->part_list; log; log = log->next) {
+ if ((log->type & ( PED_PARTITION_METADATA
+ | PED_PARTITION_FREESPACE))
+ || log->num == i)
+ continue;
+
+ if (!atr_creat_add_metadata (disk, log->geom.start-1,
+ log->geom.start-1,
+ PED_PARTITION_LOGICAL ) )
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+static int _GL_ATTRIBUTE_PURE
+atari_get_max_primary_partition_count (const PedDisk* disk)
+{
+ AtariDisk* atr_disk;
+
+ PED_ASSERT (disk != NULL);
+ atr_disk = ATARI_DISK (disk);
+ PED_ASSERT (atr_disk != NULL);
+
+ return atr_disk->format == FMT_XGM ? N_AHDI : N_AHDI + N_ICD;
+}
+
+static bool
+atari_get_max_supported_partition_count (const PedDisk* disk, int *max_n)
+{
+ AtariDisk* atr_disk;
+
+ PED_ASSERT (disk != NULL);
+ atr_disk = ATARI_DISK (disk);
+ PED_ASSERT (atr_disk != NULL);
+
+ *max_n = atr_disk->format == FMT_XGM ? N_AHDI : N_AHDI + N_ICD;
+ return true;
+}
+
+#include "pt-common.h"
+PT_define_limit_functions(atari)
+
+static PedDiskOps atari_disk_ops = {
+ clobber: NULL_IF_DISCOVER_ONLY (atari_clobber),
+ write: NULL_IF_DISCOVER_ONLY (atari_write),
+
+ partition_set_name: NULL,
+ partition_get_name: NULL,
+
+ PT_op_function_initializers (atari)
+};
+
+static PedDiskType atari_disk_type = {
+ next: NULL,
+ name: "atari",
+ ops: &atari_disk_ops,
+ features: PED_DISK_TYPE_EXTENDED
+};
+
+void
+ped_disk_atari_init ()
+{
+ PED_ASSERT (sizeof (AtariRawPartition) == 12);
+ PED_ASSERT (sizeof (AtariRawTable) == 512);
+ /* GNU Libc doesn't support NULL instead of the locale name */
+ PED_ASSERT ((atr_c_locale = newlocale(LC_ALL_MASK, "C", NULL)) != NULL);
+
+ ped_disk_type_register (&atari_disk_type);
+}
+
+void
+ped_disk_atari_done ()
+{
+ ped_disk_type_unregister (&atari_disk_type);
+ freelocale(atr_c_locale);
+}
diff --git a/libparted/libparted.c b/libparted/libparted.c
index d5cbb3a..d855d0e 100644
--- a/libparted/libparted.c
+++ b/libparted/libparted.c
@@ -75,6 +75,7 @@ extern void ped_disk_pc98_init ();
extern void ped_disk_sun_init ();
extern void ped_disk_amiga_init ();
extern void ped_disk_dasd_init ();
+extern void ped_disk_atari_init ();
static void
init_disk_types ()
@@ -96,6 +97,7 @@ init_disk_types ()
ped_disk_bsd_init ();
ped_disk_amiga_init ();
ped_disk_aix_init ();
+ ped_disk_atari_init ();
}
extern void ped_file_system_amiga_init (void);
@@ -139,6 +141,7 @@ extern void ped_disk_pc98_done ();
extern void ped_disk_sun_done ();
extern void ped_disk_amiga_done ();
extern void ped_disk_dasd_done ();
+extern void ped_disk_atari_done ();
static void
done_disk_types ()
@@ -158,6 +161,7 @@ done_disk_types ()
ped_disk_bsd_done ();
ped_disk_amiga_done ();
ped_disk_aix_done ();
+ ped_disk_atari_done ();
}
static void _init() __attribute__ ((constructor));
diff --git a/po/POTFILES.in b/po/POTFILES.in
index a8e5994..7a196f7 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -27,6 +27,7 @@ libparted/debug.c
libparted/disk.c
libparted/exception.c
libparted/labels/aix.c
+libparted/labels/atari.c
libparted/labels/bsd.c
libparted/labels/dasd.c
libparted/labels/dos.c
--
2.9.3
More information about the Parted-maintainers
mailing list