static PedDisk*
pc98_alloc (const PedDevice* dev)
{
PED_ASSERT (dev != NULL);
return _ped_disk_alloc (dev, &pc98_disk_type);
}
static PedDisk*
bsd_alloc (const PedDevice* dev)
{
PedDisk* disk;
BSDDiskData* bsd_specific;
BSDRawLabel* label;
PED_ASSERT(dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
disk = _ped_disk_alloc ((PedDevice*)dev, &bsd_disk_type);
if (!disk)
goto error;
disk->disk_specific = bsd_specific = ped_malloc (sizeof (BSDDiskData));
if (!bsd_specific)
goto error_free_disk;
/* Initialize the first byte to zero, so that the code in bsd_write
knows to call _probe_and_add_boot_code. Initializing all of the
remaining buffer is a little wasteful, but the alternative is to
figure out why a block at offset 340 would otherwise be used
uninitialized. */
memset(bsd_specific->boot_code, 0, sizeof (bsd_specific->boot_code));
label = (BSDRawLabel*) (bsd_specific->boot_code + BSD_LABEL_OFFSET);
label->d_magic = PED_CPU_TO_LE32 (BSD_DISKMAGIC);
label->d_type = PED_CPU_TO_LE16 (BSD_DTYPE_SCSI);
label->d_flags = 0;
label->d_secsize = PED_CPU_TO_LE16 (dev->sector_size);
label->d_nsectors = PED_CPU_TO_LE32 (dev->bios_geom.sectors);
label->d_ntracks = PED_CPU_TO_LE32 (dev->bios_geom.heads);
label->d_ncylinders = PED_CPU_TO_LE32 (dev->bios_geom.cylinders);
label->d_secpercyl = PED_CPU_TO_LE32 (dev->bios_geom.sectors
* dev->bios_geom.heads);
label->d_secperunit
= PED_CPU_TO_LE32 (dev->bios_geom.sectors
* dev->bios_geom.heads
* dev->bios_geom.cylinders);
label->d_rpm = PED_CPU_TO_LE16 (3600);
label->d_interleave = PED_CPU_TO_LE16 (1);;
label->d_trackskew = 0;
label->d_cylskew = 0;
label->d_headswitch = 0;
label->d_trkseek = 0;
label->d_magic2 = PED_CPU_TO_LE32 (BSD_DISKMAGIC);
label->d_bbsize = PED_CPU_TO_LE32 (BSD_BBSIZE);
label->d_sbsize = PED_CPU_TO_LE32 (BSD_SBSIZE);
label->d_npartitions = 0;
label->d_checksum = xbsd_dkcksum (label);
return disk;
error_free_disk:
free (disk);
error:
return NULL;
}
static PedDisk*
loop_alloc (const PedDevice* dev)
{
PED_ASSERT (dev != NULL);
if (dev->length < 256)
return NULL;
return _ped_disk_alloc ((PedDevice*)dev, &loop_disk_type);
}
static PedDisk*
aix_alloc (const PedDevice* dev)
{
PedDisk* disk;
disk = _ped_disk_alloc (dev, &aix_disk_type);
if (!disk)
return NULL;
return disk;
}
static PedDisk*
dvh_alloc (const PedDevice* dev)
{
PedDisk* disk;
DVHDiskData* dvh_disk_data;
PedPartition* volume_part;
PedConstraint* constraint_any;
disk = _ped_disk_alloc (dev, &dvh_disk_type);
if (!disk)
goto error;
disk->disk_specific = dvh_disk_data
= ped_malloc (sizeof (DVHDiskData));
if (!dvh_disk_data)
goto error_free_disk;
memset (&dvh_disk_data->dev_params, 0,
sizeof (struct device_parameters));
dvh_disk_data->swap = 0;
dvh_disk_data->root = 0;
dvh_disk_data->boot = 0;
volume_part = ped_partition_new (disk, PED_PARTITION_EXTENDED, NULL,
0, PTYPE_VOLHDR_DFLTSZ - 1);
if (!volume_part)
goto error_free_disk_specific;
volume_part->num = PNUM_VOLHDR + 1;
constraint_any = ped_constraint_any (dev);
if (!ped_disk_add_partition (disk, volume_part, constraint_any))
goto error_destroy_constraint_any;
ped_constraint_destroy (constraint_any);
return disk;
error_destroy_constraint_any:
ped_constraint_destroy (constraint_any);
ped_partition_destroy (volume_part);
error_free_disk_specific:
free (disk->disk_specific);
error_free_disk:
free (disk);
error:
return NULL;
}
static PedDisk*
amiga_alloc (const PedDevice* dev)
{
PedDisk *disk;
struct RigidDiskBlock *rdb;
PedSector cyl_size;
int highest_cylinder, highest_block;
PED_ASSERT(dev != NULL);
cyl_size = dev->hw_geom.sectors * dev->hw_geom.heads;
if (!(disk = _ped_disk_alloc (dev, &amiga_disk_type)))
return NULL;
if (!(disk->disk_specific = ped_malloc (disk->dev->sector_size))) {
free (disk);
return NULL;
}
rdb = disk->disk_specific;
/* Upon failed assertion this does leak. That's fine, because
if the assertion fails, you have bigger problems than this leak. */
PED_ASSERT(sizeof(*rdb) <= disk->dev->sector_size);
memset(rdb, 0, disk->dev->sector_size);
rdb->rdb_ID = PED_CPU_TO_BE32 (IDNAME_RIGIDDISK);
rdb->rdb_SummedLongs = PED_CPU_TO_BE32 (64);
rdb->rdb_HostID = PED_CPU_TO_BE32 (0);
rdb->rdb_BlockBytes = PED_CPU_TO_BE32 (disk->dev->sector_size);
rdb->rdb_Flags = PED_CPU_TO_BE32 (0);
/* Block lists */
rdb->rdb_BadBlockList = PED_CPU_TO_BE32 (LINK_END);
rdb->rdb_PartitionList = PED_CPU_TO_BE32 (LINK_END);
rdb->rdb_FileSysHeaderList = PED_CPU_TO_BE32 (LINK_END);
rdb->rdb_DriveInit = PED_CPU_TO_BE32 (LINK_END);
rdb->rdb_BootBlockList = PED_CPU_TO_BE32 (LINK_END);
/* Physical drive characteristics */
rdb->rdb_Cylinders = PED_CPU_TO_BE32 (dev->hw_geom.cylinders);
rdb->rdb_Sectors = PED_CPU_TO_BE32 (dev->hw_geom.sectors);
rdb->rdb_Heads = PED_CPU_TO_BE32 (dev->hw_geom.heads);
rdb->rdb_Interleave = PED_CPU_TO_BE32 (0);
rdb->rdb_Park = PED_CPU_TO_BE32 (dev->hw_geom.cylinders);
rdb->rdb_WritePreComp = PED_CPU_TO_BE32 (dev->hw_geom.cylinders);
rdb->rdb_ReducedWrite = PED_CPU_TO_BE32 (dev->hw_geom.cylinders);
rdb->rdb_StepRate = PED_CPU_TO_BE32 (0);
highest_cylinder = 1 + MAX_RDB_BLOCK / cyl_size;
highest_block = highest_cylinder * cyl_size - 1;
/* Logical driver characteristics */
rdb->rdb_RDBBlocksLo = PED_CPU_TO_BE32 (0);
rdb->rdb_RDBBlocksHi = PED_CPU_TO_BE32 (highest_block);
rdb->rdb_LoCylinder = PED_CPU_TO_BE32 (highest_cylinder);
rdb->rdb_HiCylinder = PED_CPU_TO_BE32 (dev->hw_geom.cylinders -1);
rdb->rdb_CylBlocks = PED_CPU_TO_BE32 (cyl_size);
rdb->rdb_AutoParkSeconds = PED_CPU_TO_BE32 (0);
/* rdb_HighRDSKBlock will only be set when writing */
rdb->rdb_HighRDSKBlock = PED_CPU_TO_BE32 (0);
/* Driver identification */
_amiga_set_bstr("", rdb->rdb_DiskVendor, 8);
_amiga_set_bstr(dev->model, rdb->rdb_DiskProduct, 16);
_amiga_set_bstr("", rdb->rdb_DiskRevision, 4);
_amiga_set_bstr("", rdb->rdb_ControllerVendor, 8);
_amiga_set_bstr("", rdb->rdb_ControllerProduct, 16);
_amiga_set_bstr("", rdb->rdb_ControllerRevision, 4);
/* And calculate the checksum */
_amiga_calculate_checksum ((struct AmigaBlock *) rdb);
return disk;
}
