/*
libparted - a library for manipulating disk partitions
- Copyright (C) 2000, 2002, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2002, 2004, 2007-2011 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 2 of the License, or
+ 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,
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, write to the Free Software
- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#include "config.h"
+#include <config.h>
#include <parted/parted.h>
#include <parted/debug.h>
#include <parted/endian.h>
-#include <string.h>
+#include <stdbool.h>
#if ENABLE_NLS
# include <libintl.h>
# define _(String) (String)
#endif /* ENABLE_NLS */
+#include "misc.h"
+#include "pt-tools.h"
+
/* struct's hacked from Linux source: fs/partitions/mac.h
* I believe it was originally written by Paul Mackerras (from comments in
* Quik source)
* Apple_partition_map partition map (table)
* Apple_Driver device driver
* Apple_Driver43 SCSI Manager 4.3 device driver
- * Apple_MFS original Macintosh File System
+ * Apple_MFS original Macintosh File System
* Apple_HFS Hierarchical File System (and +)
* Apple_HFSX HFS+ with case sensitivity and more
* Apple_UNIX_SVR2 UNIX file system (UFS?)
- * Apple_PRODOS ProDOS file system
+ * Apple_PRODOS ProDOS file system
* Apple_Free unused space
* Apple_Scratch empty
* Apple_Void padding for iso9660
#define MAC_STATUS_BOOTABLE 8 /* partition is bootable */
-typedef struct {
+typedef struct _MacRawPartition MacRawPartition;
+typedef struct _MacRawDisk MacRawDisk;
+typedef struct _MacDeviceDriver MacDeviceDriver;
+typedef struct _MacPartitionData MacPartitionData;
+typedef struct _MacDiskData MacDiskData;
+
+struct __attribute__ ((packed)) _MacRawPartition {
uint16_t signature; /* expected to be MAC_PARTITION_MAGIC */
uint16_t res1;
uint32_t map_count; /* # blocks in partition map */
char processor[16]; /* Contains 680x0, x=0,2,3,4; or empty */
uint32_t driver_sig;
char _padding[372];
-} __attribute__ ((packed)) MacRawPartition;
+};
/* Driver descriptor structure, in block 0 */
-typedef struct {
+struct __attribute__ ((packed)) _MacRawDisk {
uint16_t signature; /* expected to be MAC_DRIVER_MAGIC */
uint16_t block_size; /* physical sector size */
uint32_t block_count; /* size of device in blocks */
uint16_t dev_id; /* reserved */
uint32_t data; /* reserved */
uint16_t driver_count; /* # of driver descriptor entries */
- uint8_t driverlist[488]; /* info about available drivers */
+ uint8_t driverlist[488];/* info about available drivers */
uint16_t padding[3]; /* pad to 512 bytes */
-} __attribute__ ((packed)) MacRawDisk;
+};
-typedef struct {
+struct __attribute__ ((packed)) _MacDeviceDriver {
uint32_t block; /* startblock in MacRawDisk->block_size units */
uint16_t size; /* size in 512 byte units */
uint16_t type; /* operating system type (MacOS = 1) */
-} __attribute__ ((packed)) MacDeviceDriver;
+};
-typedef struct {
+struct _MacPartitionData {
char volume_name[33]; /* eg: "Games" */
char system_name[33]; /* eg: "Apple_Unix_SVR2" */
char processor_name[17];
uint32_t status;
uint32_t driver_sig;
-} MacPartitionData;
+};
-typedef struct {
+struct _MacDiskData {
int ghost_size; /* sectors per "driver" block */
int part_map_entry_count; /* # entries (incl. ghost) */
int part_map_entry_num; /* partition map location */
uint16_t block_size; /* physical sector size */
uint16_t driver_count;
MacDeviceDriver driverlist[1 + 60]; /* 488 bytes */
-} MacDiskData;
+};
static PedDiskType mac_disk_type;
static int
-_check_signature (MacRawDisk* raw_disk)
+_check_signature (MacRawDisk const *raw_disk)
{
if (PED_BE16_TO_CPU (raw_disk->signature) != MAC_DISK_MAGIC) {
#ifdef DISCOVER_ONLY
static int
mac_probe (const PedDevice * dev)
{
- MacRawDisk buf;
-
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
- if (dev->sector_size != 512)
+ if (dev->sector_size < sizeof (MacRawDisk))
return 0;
- if (!ped_device_read (dev, &buf, 0, 1))
+ void *label;
+ if (!ptt_read_sector (dev, 0, &label))
return 0;
- return _check_signature (&buf);
+ int valid = _check_signature (label);
+
+ free (label);
+ return valid;
}
static int
if (part_map_size == 0)
part_map_size = 64;
- new_part = ped_partition_new (disk, 0, NULL, 1, part_map_size - 1);
+ new_part = ped_partition_new (disk, PED_PARTITION_NORMAL, NULL,
+ 1, part_map_size - 1);
if (!new_part)
goto error;
return 0;
}
-PedDisk*
+static PedDisk*
mac_alloc (const PedDevice* dev)
{
PedDisk* disk;
MacDiskData* mac_disk_data;
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
#ifndef DISCOVER_ONLY
if (dev->length < 256) {
PedDisk* new_disk;
MacDiskData* new_mac_data;
MacDiskData* old_mac_data = (MacDiskData*) disk->disk_specific;
- PedPartition* partition_map;
-
+
new_disk = ped_disk_new_fresh (disk->dev, &mac_disk_type);
if (!new_disk)
- goto error;
+ return NULL;
new_mac_data = (MacDiskData*) new_disk->disk_specific;
/* remove the partition map partition - it will be duplicated
* later.
*/
- partition_map = ped_disk_get_partition_by_sector (new_disk, 1);
- PED_ASSERT (partition_map != NULL, return 0);
+ PedSector first_part_map_sector = old_mac_data->ghost_size;
+ PedPartition *partition_map
+ = ped_disk_get_partition_by_sector (new_disk, first_part_map_sector);
+ PED_ASSERT (partition_map != NULL);
+
+ /* ped_disk_remove_partition may be used only to delete a "normal"
+ partition. Trying to delete at least "freespace" or "metadata"
+ partitions leads to a violation of assumptions in
+ ped_disk_remove_partition, since it calls _disk_push_update_mode,
+ which destroys all "freespace" and "metadata" partitions, and
+ depends on that destruction not freeing its PART parameter. */
+ PED_ASSERT (partition_map->type == PED_PARTITION_NORMAL);
ped_disk_remove_partition (new_disk, partition_map);
/* ugly, but C is ugly :p */
memcpy (new_mac_data, old_mac_data, sizeof (MacDiskData));
return new_disk;
-
-error_free_new_disk:
- _ped_disk_free (new_disk);
-error:
- return NULL;
}
static void
MacDiskData* mac_disk_data = disk->disk_specific;
_ped_disk_free (disk);
- ped_free (mac_disk_data);
+ free (mac_disk_data);
}
-#ifndef DISCOVER_ONLY
static int
-_clobber_part_map (PedDevice* dev)
-{
- MacRawPartition raw_part;
- PedSector sector;
-
- for (sector=1; 1; sector++) {
- if (!ped_device_read (dev, &raw_part, sector, 1))
- return 0;
- if (!_rawpart_check_signature (&raw_part))
- return 1;
- memset (&raw_part, 0, 512);
- if (!ped_device_write (dev, &raw_part, sector, 1))
- return 0;
- }
-}
-
-static int
-mac_clobber (PedDevice* dev)
-{
- MacRawDisk raw_disk;
-
- if (!ped_device_read (dev, &raw_disk, 0, 1))
- return 0;
- if (!_check_signature (&raw_disk))
- return 0;
- memset (&raw_disk, 0, 512);
- if (!ped_device_write (dev, &raw_disk, 0, 1))
- return 0;
-
- return _clobber_part_map (dev);
-}
-#endif /* !DISCOVER_ONLY */
-
-static int
-_rawpart_cmp_type (MacRawPartition* raw_part, char* type)
+_rawpart_cmp_type (const MacRawPartition* raw_part, const char* type)
{
return strncasecmp (raw_part->type, type, 32) == 0;
}
static int
-_rawpart_cmp_name (MacRawPartition* raw_part, char* name)
+_rawpart_cmp_name (const MacRawPartition* raw_part, const char* name)
{
return strncasecmp (raw_part->name, name, 32) == 0;
}
static int
-_rawpart_is_partition_map (MacRawPartition* raw_part)
+_rawpart_is_partition_map (const MacRawPartition* raw_part)
{
return _rawpart_cmp_type (raw_part, "Apple_partition_map");
}
}
static int
-_rawpart_is_boot (MacRawPartition* raw_part)
+_rawpart_is_boot (const MacRawPartition* raw_part)
{
if (!strcasecmp(raw_part->type, "Apple_Bootstrap"))
return 1;
}
static int
-_rawpart_is_driver (MacRawPartition* raw_part)
+_rawpart_is_driver (const MacRawPartition* raw_part)
{
if (strncmp (raw_part->type, "Apple_", 6) != 0)
return 0;
return 1;
}
-static int
-_rawpart_has_driver (MacRawPartition* raw_part, MacDiskData* mac_disk_data)
+static int _GL_ATTRIBUTE_PURE
+_rawpart_has_driver (const MacRawPartition* raw_part, MacDiskData* mac_disk_data)
{
MacDeviceDriver *driverlist;
uint16_t i, bsz;
#endif
return NULL;
}
- part = ped_partition_new (disk, 0, NULL, start, start + length - 1);
+ part = ped_partition_new (disk, PED_PARTITION_NORMAL, NULL,
+ start, start + length - 1);
if (!part)
goto error;
_disk_analyse_ghost_size (PedDisk* disk)
{
MacDiskData* mac_disk_data = disk->disk_specific;
- MacRawPartition raw_part;
- int i;
+ void *buf = ped_malloc (disk->dev->sector_size);
+ if (!buf)
+ return 0;
+
+ int i;
+ int found = 0;
for (i = 1; i < 64; i *= 2) {
- if (!ped_device_read (disk->dev, &raw_part, i, 1))
- return 0;
- if (_rawpart_check_signature (&raw_part)
- && !_rawpart_is_void (&raw_part)) {
+ if (!ped_device_read (disk->dev, buf, i, 1))
+ break;
+ if (_rawpart_check_signature (buf)
+ && !_rawpart_is_void (buf)) {
mac_disk_data->ghost_size = i;
- PED_ASSERT (i <= disk->dev->sector_size / 512,
- return 0);
- return 1;
+ PED_ASSERT (i <= disk->dev->sector_size / 512);
+ found = 1;
+ break;
}
}
+ free (buf);
#ifndef DISCOVER_ONLY
- ped_exception_throw (
- PED_EXCEPTION_ERROR,
- PED_EXCEPTION_CANCEL,
- _("No valid partition map found."));
+ if (!found)
+ ped_exception_throw (
+ PED_EXCEPTION_ERROR,
+ PED_EXCEPTION_CANCEL,
+ _("No valid partition map found."));
#endif
- return 0;
+ return found;
}
static int
mac_read (PedDisk* disk)
{
- MacRawDisk raw_disk;
- MacRawPartition raw_part;
MacDiskData* mac_disk_data;
PedPartition* part;
int num;
PedSector ghost_size;
- PedConstraint* constraint_exact;
int last_part_entry_num = 0;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
mac_disk_data = disk->disk_specific;
mac_disk_data->part_map_entry_num = 0; /* 0 == none */
- if (!ped_device_read (disk->dev, &raw_disk, 0, 1))
- goto error;
- if (!_check_signature (&raw_disk))
+ void *buf;
+ if (!ptt_read_sector (disk->dev, 0, &buf))
+ return 0;
+
+ MacRawDisk *raw_disk = (MacRawDisk *) buf;
+
+ if (!_check_signature (raw_disk))
goto error;
- if (!_disk_analyse_block_size (disk, &raw_disk))
+ if (!_disk_analyse_block_size (disk, raw_disk))
goto error;
if (!_disk_analyse_ghost_size (disk))
goto error;
if (!ped_disk_delete_all (disk))
goto error;
- if (raw_disk.driver_count && raw_disk.driver_count < 62) {
- memcpy(&mac_disk_data->driverlist[0], &raw_disk.driverlist[0],
+ if (raw_disk->driver_count && raw_disk->driver_count < 62) {
+ memcpy(&mac_disk_data->driverlist[0], &raw_disk->driverlist[0],
sizeof(mac_disk_data->driverlist));
- mac_disk_data->driver_count = raw_disk.driver_count;
- mac_disk_data->block_size = raw_disk.block_size;
+ mac_disk_data->driver_count = raw_disk->driver_count;
+ mac_disk_data->block_size = raw_disk->block_size;
}
for (num=1; num==1 || num <= last_part_entry_num; num++) {
- if (!ped_device_read (disk->dev, &raw_part,
+ void *raw_part = buf;
+ if (!ped_device_read (disk->dev, raw_part,
num * ghost_size, 1))
goto error_delete_all;
- if (!_rawpart_check_signature (&raw_part))
+ if (!_rawpart_check_signature (raw_part))
continue;
if (num == 1)
last_part_entry_num
- = _rawpart_get_partmap_size (&raw_part, disk);
- if (_rawpart_get_partmap_size (&raw_part, disk)
+ = _rawpart_get_partmap_size (raw_part, disk);
+ if (_rawpart_get_partmap_size (raw_part, disk)
!= last_part_entry_num) {
if (ped_exception_throw (
PED_EXCEPTION_ERROR,
"Entry 1 says it is %d, but entry %d says "
"it is %d!"),
last_part_entry_num,
- _rawpart_get_partmap_size (&raw_part, disk))
+ _rawpart_get_partmap_size (raw_part, disk))
!= PED_EXCEPTION_IGNORE)
goto error_delete_all;
}
- if (!_rawpart_is_active (&raw_part))
+ if (!_rawpart_is_active (raw_part))
continue;
- part = _rawpart_analyse (&raw_part, disk, num);
+ part = _rawpart_analyse (raw_part, disk, num);
if (!part)
goto error_delete_all;
part->num = num;
part->fs_type = ped_file_system_probe (&part->geom);
- constraint_exact = ped_constraint_exact (&part->geom);
- if (!ped_disk_add_partition (disk, part, constraint_exact))
+ PedConstraint *constraint_exact
+ = ped_constraint_exact (&part->geom);
+ if (constraint_exact == NULL)
goto error_delete_all;
+ bool ok = ped_disk_add_partition (disk, part, constraint_exact);
ped_constraint_destroy (constraint_exact);
+ if (!ok)
+ goto error_delete_all;
- if (_rawpart_is_partition_map (&raw_part)) {
+ if (_rawpart_is_partition_map (raw_part)) {
if (mac_disk_data->part_map_entry_num
&& ped_exception_throw (
PED_EXCEPTION_ERROR,
goto error_delete_all;
ped_disk_commit_to_dev (disk);
}
+ free (buf);
return 1;
error_delete_all:
ped_disk_delete_all (disk);
error:
+ free (buf);
return 0;
}
_pad_raw_part (PedDisk* disk, int num, MacRawPartition* part_map)
{
MacDiskData* mac_disk_data = disk->disk_specific;
- MacRawPartition ghost_entry;
int i;
- memset (&ghost_entry, 0, sizeof (ghost_entry));
- ghost_entry.signature = PED_CPU_TO_BE16 (MAC_PARTITION_MAGIC_2);
- strcpy (ghost_entry.type, "Apple_Void");
- ghost_entry.map_count
+ size_t ss = disk->dev->sector_size;
+ void *buf = ped_calloc (ss);
+ if (!buf)
+ return 0;
+
+ MacRawPartition *ghost_entry = buf;
+ ghost_entry->signature = PED_CPU_TO_BE16 (MAC_PARTITION_MAGIC_2);
+ strcpy (ghost_entry->type, "Apple_Void");
+ ghost_entry->map_count
= PED_CPU_TO_BE32 (mac_disk_data->last_part_entry_num);
- for (i=0; i < mac_disk_data->ghost_size - 1; i++)
- memcpy (&part_map [i + (num - 1) * mac_disk_data->ghost_size],
- &ghost_entry, sizeof (MacRawPartition));
+ for (i=0; i < mac_disk_data->ghost_size - 1; i++) {
+ PedSector idx = i + (num - 1) * mac_disk_data->ghost_size;
+ memcpy ((char*)part_map + idx * ss, ghost_entry, ss);
+ }
+ free (buf);
return 1;
}
}
}
+static MacRawPartition *
+get_pme (MacRawPartition const *part_map, PedSector i, PedDisk const *disk)
+{
+ MacDiskData const *mac_disk_data = disk->disk_specific;
+ PedSector idx = i * mac_disk_data->ghost_size - 1;
+ return (MacRawPartition *) ((char*)part_map
+ + idx * disk->dev->sector_size);
+}
+
+/* Initialize the disk->dev->sector_size bytes of part_map[part->num]. */
static int
_generate_raw_part (PedDisk* disk, PedPartition* part,
MacRawPartition* part_map, MacDiskData *mac_driverdata)
{
MacDiskData* mac_disk_data;
MacPartitionData* mac_part_data;
- MacRawPartition* part_map_entry;
PedSector block_size = disk->dev->sector_size / 512;
- PED_ASSERT (part->num > 0, goto error);
+ PED_ASSERT (part->num > 0);
mac_disk_data = disk->disk_specific;
mac_part_data = part->disk_specific;
- part_map_entry = &part_map [part->num * mac_disk_data->ghost_size - 1];
+ MacRawPartition *part_map_entry = get_pme (part_map, part->num, disk);
+ memset (part_map_entry, 0, disk->dev->sector_size);
part_map_entry->signature = PED_CPU_TO_BE16 (MAC_PARTITION_MAGIC_2);
part_map_entry->map_count
return 1;
error:
- return 0;
+ return 0;
}
static int
MacRawPartition* part_map)
{
MacDiskData* mac_disk_data = disk->disk_specific;
- MacRawPartition* part_map_entry;
PedSector block_size = disk->dev->sector_size / 512;
- PED_ASSERT (num > 0, goto error);
+ PED_ASSERT (num > 0);
- part_map_entry = &part_map [num * mac_disk_data->ghost_size - 1];
+ MacRawPartition *part_map_entry = get_pme (part_map, num, disk);
part_map_entry->signature = PED_CPU_TO_BE16 (MAC_PARTITION_MAGIC_2);
part_map_entry->map_count
return 1;
error:
- return 0;
+ return 0;
}
static int
_generate_empty_part (PedDisk* disk, int num, MacRawPartition* part_map)
{
MacDiskData* mac_disk_data = disk->disk_specific;
- MacRawPartition* part_map_entry;
- PED_ASSERT (num > 0, return 0);
+ PED_ASSERT (num > 0);
- part_map_entry = &part_map [num * mac_disk_data->ghost_size - 1];
+ MacRawPartition *part_map_entry = get_pme (part_map, num, disk);
part_map_entry->signature = PED_CPU_TO_BE16 (MAC_PARTITION_MAGIC_2);
part_map_entry->map_count
= PED_CPU_TO_BE32 (mac_disk_data->last_part_entry_num);
}
/* returns the first empty entry in the partition map */
-static int
+static int _GL_ATTRIBUTE_PURE
_get_first_empty_part_entry (PedDisk* disk, MacRawPartition* part_map)
{
MacDiskData* mac_disk_data = disk->disk_specific;
int i;
for (i=1; i <= mac_disk_data->last_part_entry_num; i++) {
- if (!part_map[i * mac_disk_data->ghost_size - 1].signature)
+ MacRawPartition *part_map_entry = get_pme (part_map, i, disk);
+ if (!part_map_entry->signature)
return i;
}
write_block_zero (PedDisk* disk, MacDiskData* mac_driverdata)
{
PedDevice* dev = disk->dev;
- MacRawDisk raw_disk;
-
- if (!ped_device_read (dev, &raw_disk, 0, 1))
+ void *s0;
+ if (!ptt_read_sector (dev, 0, &s0))
return 0;
+ MacRawDisk *raw_disk = (MacRawDisk *) s0;
- raw_disk.signature = PED_CPU_TO_BE16 (MAC_DISK_MAGIC);
- raw_disk.block_size = PED_CPU_TO_BE16 (dev->sector_size);
- raw_disk.block_count
+ raw_disk->signature = PED_CPU_TO_BE16 (MAC_DISK_MAGIC);
+ raw_disk->block_size = PED_CPU_TO_BE16 (dev->sector_size);
+ raw_disk->block_count
= PED_CPU_TO_BE32 (dev->length / (dev->sector_size / 512));
- raw_disk.driver_count = mac_driverdata->driver_count;
- memcpy(&raw_disk.driverlist[0], &mac_driverdata->driverlist[0],
- sizeof(raw_disk.driverlist));
+ raw_disk->driver_count = mac_driverdata->driver_count;
+ memcpy(&raw_disk->driverlist[0], &mac_driverdata->driverlist[0],
+ sizeof(raw_disk->driverlist));
- return ped_device_write (dev, &raw_disk, 0, 1);
+ int write_ok = ped_device_write (dev, raw_disk, 0, 1);
+ free (s0);
+ return write_ok;
}
static int
PedPartition* part;
int num;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->disk_specific != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
- PED_ASSERT (!disk->update_mode, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->disk_specific != NULL);
+ PED_ASSERT (disk->dev != NULL);
+ PED_ASSERT (!disk->update_mode);
mac_disk_data = disk->disk_specific;
goto error;
memset (mac_driverdata, 0, sizeof(MacDiskData));
- part_map = (MacRawPartition*)
- ped_malloc (mac_disk_data->part_map_entry_count * 512);
+ size_t pmap_bytes = (mac_disk_data->part_map_entry_count
+ * mac_disk_data->ghost_size
+ * disk->dev->sector_size);
+ part_map = (MacRawPartition*) ped_calloc (pmap_bytes);
if (!part_map)
goto error_free_driverdata;
- memset (part_map, 0, mac_disk_data->part_map_entry_count * 512);
/* write (to memory) the "real" partitions */
for (part = ped_disk_next_partition (disk, NULL); part;
if (!ped_device_write (disk->dev, part_map, 1,
mac_disk_data->part_map_entry_count))
goto error_free_part_map;
- ped_free (part_map);
- return write_block_zero (disk, mac_driverdata);
+ free (part_map);
+ int write_ok = write_block_zero (disk, mac_driverdata);
+ free (mac_driverdata);
+ return write_ok;
error_free_part_map:
- ped_free (part_map);
+ free (part_map);
error_free_driverdata:
- ped_free (mac_driverdata);
+ free (mac_driverdata);
error:
return 0;
}
}
return part;
-error_free_mac_data:
- ped_free (mac_data);
error_free_part:
- ped_free (part);
+ free (part);
error:
- return 0;
+ return NULL;
}
static PedPartition*
static void
mac_partition_destroy (PedPartition* part)
{
- PED_ASSERT (part != NULL, return);
+ PED_ASSERT (part != NULL);
if (ped_partition_is_active (part))
- ped_free (part->disk_specific);
- ped_free (part);
+ free (part->disk_specific);
+ free (part);
}
static int
part->fs_type = fs_type;
- if (fs_type && !strcmp (fs_type->name, "linux-swap"))
+ if (fs_type && is_linux_swap (fs_type->name))
ped_partition_set_flag (part, PED_PARTITION_SWAP, 1);
if (mac_data->is_boot) {
static int
mac_partition_set_flag (PedPartition* part, PedPartitionFlag flag, int state)
{
- PedFileSystemType* hfs = ped_file_system_type_get ("hfs");
MacPartitionData* mac_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
mac_data = part->disk_specific;
}
}
-static int
+static int _GL_ATTRIBUTE_PURE
mac_partition_get_flag (const PedPartition* part, PedPartitionFlag flag)
{
MacPartitionData* mac_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
mac_data = part->disk_specific;
switch (flag) {
MacPartitionData* mac_data;
int i;
- PED_ASSERT (part != NULL, return);
- PED_ASSERT (part->disk_specific != NULL, return);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
mac_data = part->disk_specific;
#ifndef DISCOVER_ONLY
mac_data->volume_name [i] = 0;
}
-static const char*
+static const char* _GL_ATTRIBUTE_PURE
mac_partition_get_name (const PedPartition* part)
{
MacPartitionData* mac_data;
- PED_ASSERT (part != NULL, return NULL);
- PED_ASSERT (part->disk_specific != NULL, return NULL);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
mac_data = part->disk_specific;
return mac_data->volume_name;
}
+static PedAlignment*
+mac_get_partition_alignment(const PedDisk *disk)
+{
+ PedSector sector_size = disk->dev->sector_size / 512;
+
+ return ped_alignment_new(0, sector_size);
+}
+
static PedConstraint*
_primary_constraint (PedDisk* disk)
{
static int
mac_partition_align (PedPartition* part, const PedConstraint* constraint)
{
- PED_ASSERT (part != NULL, return 0);
+ PED_ASSERT (part != NULL);
if (_ped_partition_attempt_align (part, constraint,
_primary_constraint (part->disk)))
int i;
int max_part_count;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk != NULL);
disk = part->disk;
mac_disk_data = (MacDiskData*) disk->disk_specific;
PedPartition* part = NULL;
PedPartition* last = NULL;
- PED_ASSERT (disk->update_mode, return 0);
+ PED_ASSERT (disk->update_mode);
mac_disk_data->active_part_entry_count = 0;
mac_disk_data->free_part_entry_count = 0;
PedPartition* new_part;
PedConstraint* constraint_any = ped_constraint_any (disk->dev);
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
new_part = ped_partition_new (disk, PED_PARTITION_METADATA, NULL,
start, end);
static int
mac_alloc_metadata (PedDisk* disk)
{
- MacDiskData* mac_disk_data;
-
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->disk_specific != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
-
- mac_disk_data = disk->disk_specific;
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->disk_specific != NULL);
+ PED_ASSERT (disk->dev != NULL);
if (!add_metadata_part (disk, 0, disk->dev->sector_size / 512 - 1))
return 0;
- mac_disk_data->free_part_entry_count + 1;
}
+static bool
+mac_get_max_supported_partition_count (const PedDisk* disk, int *max_n)
+{
+ *max_n = 65536;
+ return true;
+}
+
+#include "pt-common.h"
+PT_define_limit_functions (mac)
+
static PedDiskOps mac_disk_ops = {
- probe: mac_probe,
-#ifndef DISCOVER_ONLY
- clobber: mac_clobber,
-#else
- clobber: NULL,
-#endif
- alloc: mac_alloc,
- duplicate: mac_duplicate,
- free: mac_free,
- read: mac_read,
-#ifndef DISCOVER_ONLY
- write: mac_write,
-#else
- write: NULL,
-#endif
+ clobber: NULL,
+ /* FIXME: remove this cast, once mac_write is fixed not to
+ modify its *DISK parameter. */
+ write: NULL_IF_DISCOVER_ONLY ((int (*) (const PedDisk*)) mac_write),
- partition_new: mac_partition_new,
- partition_duplicate: mac_partition_duplicate,
- partition_destroy: mac_partition_destroy,
- partition_set_system: mac_partition_set_system,
- partition_set_flag: mac_partition_set_flag,
- partition_get_flag: mac_partition_get_flag,
- partition_is_flag_available: mac_partition_is_flag_available,
partition_set_name: mac_partition_set_name,
partition_get_name: mac_partition_get_name,
- partition_align: mac_partition_align,
- partition_enumerate: mac_partition_enumerate,
- alloc_metadata: mac_alloc_metadata,
- get_max_primary_partition_count:
- mac_get_max_primary_partition_count
+ get_partition_alignment: mac_get_partition_alignment,
+
+ PT_op_function_initializers (mac)
};
static PedDiskType mac_disk_type = {
void
ped_disk_mac_init ()
{
- PED_ASSERT (sizeof (MacRawPartition) == 512, return);
- PED_ASSERT (sizeof (MacRawDisk) == 512, return);
+ PED_ASSERT (sizeof (MacRawPartition) == 512);
+ PED_ASSERT (sizeof (MacRawDisk) == 512);
- ped_register_disk_type (&mac_disk_type);
+ ped_disk_type_register (&mac_disk_type);
}
void
ped_disk_mac_done ()
{
- ped_unregister_disk_type (&mac_disk_type);
+ ped_disk_type_unregister (&mac_disk_type);
}
-