/*
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 <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
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);
-}
-
-#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);
+ free (mac_disk_data);
}
-#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_disk_type_register (&mac_disk_type);
}
{
ped_disk_type_unregister (&mac_disk_type);
}
-
OSDN Git Service
