| /* This file is part of the program psim. | |
| Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au> | |
| 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 | |
| (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, write to the Free Software | |
| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
| */ | |
| #ifndef _PK_DISKLABEL_C_ | |
| #define _PK_DISKLABEL_C_ | |
| #ifndef STATIC_INLINE_PK_DISKLABEL | |
| #define STATIC_INLINE_PK_DISKLABEL STATIC_INLINE | |
| #endif | |
| #include "device_table.h" | |
| #include "pk.h" | |
| #ifdef HAVE_STDLIB_H | |
| #include <stdlib.h> | |
| #endif | |
| /* PACKAGE | |
| disk-label - all knowing disk I/O package | |
| DESCRIPTION | |
| The disk-label package provides a generic interface to disk | |
| devices. It uses the arguments specified when an instance is being | |
| created to determine if the raw disk, a partition, or a file within | |
| a partition should be opened. | |
| An instance create call to disk-label could result, for instance, | |
| in the opening of a DOS file system contained within a dos | |
| partition contained within a physical disk. | |
| */ | |
| /* taken from bfd/ppcboot.c by Michael Meissner */ | |
| /* PPCbug location structure */ | |
| typedef struct ppcboot_location { | |
| unsigned8 ind; | |
| unsigned8 head; | |
| unsigned8 sector; | |
| unsigned8 cylinder; | |
| } ppcboot_location_t; | |
| /* PPCbug partition table layout */ | |
| typedef struct ppcboot_partition { | |
| ppcboot_location_t partition_begin; /* partition begin */ | |
| ppcboot_location_t partition_end; /* partition end */ | |
| unsigned8 sector_begin[4]; /* 32-bit start RBA (zero-based), little endian */ | |
| unsigned8 sector_length[4]; /* 32-bit RBA count (one-based), little endian */ | |
| } ppcboot_partition_t; | |
| #if 0 | |
| /* PPCbug boot layout. */ | |
| typedef struct ppcboot_hdr { | |
| unsigned8 pc_compatibility[446]; /* x86 instruction field */ | |
| ppcboot_partition_t partition[4]; /* partition information */ | |
| unsigned8 signature[2]; /* 0x55 and 0xaa */ | |
| unsigned8 entry_offset[4]; /* entry point offset, little endian */ | |
| unsigned8 length[4]; /* load image length, little endian */ | |
| unsigned8 flags; /* flag field */ | |
| unsigned8 os_id; /* OS_ID */ | |
| char partition_name[32]; /* partition name */ | |
| unsigned8 reserved1[470]; /* reserved */ | |
| } ppcboot_hdr_t; | |
| #endif | |
| typedef struct _disklabel { | |
| device_instance *parent; | |
| device_instance *raw_disk; | |
| unsigned_word pos; | |
| unsigned_word sector_begin; | |
| unsigned_word sector_length; | |
| } disklabel; | |
| static unsigned_word | |
| sector2uw(unsigned8 s[4]) | |
| { | |
| return ((s[3] << 24) | |
| + (s[2] << 16) | |
| + (s[1] << 8) | |
| + (s[0] << 0)); | |
| } | |
| static void | |
| disklabel_delete(device_instance *instance) | |
| { | |
| disklabel *label = device_instance_data(instance); | |
| device_instance_delete(label->raw_disk); | |
| zfree(label); | |
| } | |
| static int | |
| disklabel_read(device_instance *instance, | |
| void *buf, | |
| unsigned_word len) | |
| { | |
| disklabel *label = device_instance_data(instance); | |
| int nr_read; | |
| if (label->pos + len > label->sector_length) | |
| len = label->sector_length - label->pos; | |
| if (device_instance_seek(label->raw_disk, 0, | |
| label->sector_begin + label->pos) < 0) | |
| return -1; | |
| nr_read = device_instance_read(label->raw_disk, buf, len); | |
| if (nr_read > 0) | |
| label->pos += nr_read; | |
| return nr_read; | |
| } | |
| static int | |
| disklabel_write(device_instance *instance, | |
| const void *buf, | |
| unsigned_word len) | |
| { | |
| disklabel *label = device_instance_data(instance); | |
| int nr_written; | |
| if (label->pos + len > label->sector_length) | |
| len = label->sector_length - label->pos; | |
| if (device_instance_seek(label->raw_disk, 0, | |
| label->sector_begin + label->pos) < 0) | |
| return -1; | |
| nr_written = device_instance_write(label->raw_disk, buf, len); | |
| if (nr_written > 0) | |
| label->pos += nr_written; | |
| return nr_written; | |
| } | |
| static int | |
| disklabel_seek(device_instance *instance, | |
| unsigned_word pos_hi, | |
| unsigned_word pos_lo) | |
| { | |
| disklabel *label = device_instance_data(instance); | |
| if (pos_lo >= label->sector_length || pos_hi != 0) | |
| return -1; | |
| label->pos = pos_lo; | |
| return 0; | |
| } | |
| static const device_instance_callbacks package_disklabel_callbacks = { | |
| disklabel_delete, | |
| disklabel_read, | |
| disklabel_write, | |
| disklabel_seek, | |
| }; | |
| /* Reconize different types of boot block */ | |
| static int | |
| block0_is_bpb(const unsigned8 block[]) | |
| { | |
| const char ebdic_ibma[] = { 0xc9, 0xc2, 0xd4, 0xc1 }; | |
| /* ref PowerPC Microprocessor CHRP bindings 1.2b - page 47 */ | |
| /* can't start with IBMA */ | |
| if (memcmp(block, ebdic_ibma, sizeof(ebdic_ibma)) == 0) | |
| return 0; | |
| /* must have LE 0xAA55 signature at offset 510 */ | |
| if (block[511] != 0xAA && block[510] != 0x55) | |
| return 0; | |
| /* valid 16 bit LE bytes per sector - 256, 512, 1024 */ | |
| if (block[11] != 0 | |
| || (block[12] != 1 && block[12] != 2 && block[12] != 4)) | |
| return 0; | |
| /* nr fats is 1 or 2 */ | |
| if (block[16] != 1 && block[16] != 2) | |
| return 0; | |
| return 1; | |
| } | |
| /* Verify that the device contains an ISO-9660 File system */ | |
| static int | |
| is_iso9660(device_instance *raw_disk) | |
| { | |
| /* ref PowerPC Microprocessor CHRP bindings 1.2b - page 47 */ | |
| unsigned8 block[512]; | |
| if (device_instance_seek(raw_disk, 0, 512 * 64) < 0) | |
| return 0; | |
| if (device_instance_read(raw_disk, block, sizeof(block)) != sizeof(block)) | |
| return 0; | |
| if (block[0] == 0x01 | |
| && block[1] == 'C' | |
| && block[2] == 'D' | |
| && block[3] == '0' | |
| && block[4] == '0' | |
| && block[5] == '1') | |
| return 1; | |
| return 0; | |
| } | |
| /* Verify that the disk block contains a valid DOS partition table. | |
| While we're at it have a look around for active partitions etc. | |
| Return 0: invalid | |
| Return 1..4: valid, value returned is the first active partition | |
| Return -1: no active partition */ | |
| static int | |
| block0_is_fdisk(const unsigned8 block[]) | |
| { | |
| const int partition_type_fields[] = { 0, 0x1c2, 0x1d2, 0x1e2, 0x1f2 }; | |
| const int partition_active_fields[] = { 0, 0x1be, 0x1ce, 0x1de, 0xee }; | |
| int partition; | |
| int active = -1; | |
| /* ref PowerPC Microprocessor CHRP bindings 1.2b - page 47 */ | |
| /* must have LE 0xAA55 signature at offset 510 */ | |
| if (block[511/*0x1ff*/] != 0xAA && block[510/*0x1fe*/] != 0x55) | |
| return 0; | |
| /* must contain valid partition types */ | |
| for (partition = 1; partition <= 4 && active != 0; partition++) { | |
| int partition_type = block[partition_type_fields[partition]]; | |
| int is_active = block[partition_active_fields[partition]] == 0x80; | |
| const char *type; | |
| switch (partition_type) { | |
| case 0x00: | |
| type = "UNUSED"; | |
| break; | |
| case 0x01: | |
| type = "FAT 12 File system"; | |
| break; | |
| case 0x04: | |
| type = "FAT 16 File system"; | |
| break; | |
| case 0x05: | |
| case 0x06: | |
| type = "rejected - extended/chained partition not supported"; | |
| active = 0; | |
| break; | |
| case 0x41: | |
| type = "Single program image"; | |
| break; | |
| case 0x82: | |
| type = "Solaris?"; | |
| break; | |
| case 0x96: | |
| type = "ISO 9660 File system"; | |
| break; | |
| default: | |
| type = "rejected - unknown type"; | |
| active = 0; | |
| break; | |
| } | |
| PTRACE(disklabel, ("partition %d of type 0x%02x - %s%s\n", | |
| partition, | |
| partition_type, | |
| type, | |
| is_active && active != 0 ? " (active)" : "")); | |
| if (partition_type != 0 && is_active && active < 0) | |
| active = partition; | |
| } | |
| return active; | |
| } | |
| /* Verify that block0 corresponds to a MAC disk */ | |
| static int | |
| block0_is_mac_disk(const unsigned8 block[]) | |
| { | |
| /* ref PowerPC Microprocessor CHRP bindings 1.2b - page 47 */ | |
| /* signature - BEx4552 at offset 0 */ | |
| if (block[0] != 0x45 || block[1] != 0x52) | |
| return 0; | |
| return 1; | |
| } | |
| /* Open a logical disk/file */ | |
| device_instance * | |
| pk_disklabel_create_instance(device_instance *raw_disk, | |
| const char *args) | |
| { | |
| int partition; | |
| char *filename; | |
| /* parse the arguments */ | |
| if (args == NULL) { | |
| partition = 0; | |
| filename = NULL; | |
| } | |
| else { | |
| partition = strtoul((char*)args, &filename, 0); | |
| if (filename == args) | |
| partition = -1; /* not specified */ | |
| if (*filename == ',') | |
| filename++; | |
| if (*filename == '\0') | |
| filename = NULL; /* easier */ | |
| } | |
| if (partition == 0) { | |
| /* select the raw disk */ | |
| return raw_disk; | |
| } | |
| else { | |
| unsigned8 boot_block[512]; | |
| /* get the boot block for examination */ | |
| if (device_instance_seek(raw_disk, 0, 0) < 0) | |
| device_error(device_instance_device(raw_disk), | |
| "Problem seeking on raw disk"); | |
| if (device_instance_read(raw_disk, &boot_block, sizeof(boot_block)) | |
| != sizeof(boot_block)) | |
| device_error(device_instance_device(raw_disk), "Problem reading boot block"); | |
| if (partition < 0) { | |
| /* select the active partition */ | |
| if (block0_is_bpb(boot_block)) { | |
| device_error(device_instance_device(raw_disk), "Unimplemented active BPB"); | |
| } | |
| else if (block0_is_fdisk(boot_block)) { | |
| int active = block0_is_fdisk(boot_block); | |
| device_error(device_instance_device(raw_disk), "Unimplemented active FDISK (%d)", | |
| active); | |
| } | |
| else if (is_iso9660(raw_disk)) { | |
| device_error(device_instance_device(raw_disk), "Unimplemented active ISO9660"); | |
| } | |
| else if (block0_is_mac_disk(boot_block)) { | |
| device_error(device_instance_device(raw_disk), "Unimplemented active MAC DISK"); | |
| } | |
| else { | |
| device_error(device_instance_device(raw_disk), "Unreconized bootblock"); | |
| } | |
| } | |
| else { | |
| /* select the specified disk partition */ | |
| if (block0_is_bpb(boot_block)) { | |
| device_error(device_instance_device(raw_disk), "Unimplemented BPB"); | |
| } | |
| else if (block0_is_fdisk(boot_block)) { | |
| /* return an instance */ | |
| ppcboot_partition_t *partition_table = (ppcboot_partition_t*) &boot_block[446]; | |
| ppcboot_partition_t *partition_entry; | |
| disklabel *label; | |
| if (partition > 4) | |
| device_error(device_instance_device(raw_disk), | |
| "Only FDISK partitions 1..4 supported"); | |
| partition_entry = &partition_table[partition - 1]; | |
| label = ZALLOC(disklabel); | |
| label->raw_disk = raw_disk; | |
| label->pos = 0; | |
| label->sector_begin = 512 * sector2uw(partition_entry->sector_begin); | |
| label->sector_length = 512 * sector2uw(partition_entry->sector_length); | |
| PTRACE(disklabel, ("partition %ld, sector-begin %ld, length %ld\n", | |
| (long)partition, | |
| (long)label->sector_begin, | |
| (long)label->sector_length)); | |
| if (filename != NULL) | |
| device_error(device_instance_device(raw_disk), | |
| "FDISK file names not yet supported"); | |
| return device_create_instance_from(NULL, raw_disk, | |
| label, | |
| NULL, args, | |
| &package_disklabel_callbacks); | |
| } | |
| else if (block0_is_mac_disk(boot_block)) { | |
| device_error(device_instance_device(raw_disk), "Unimplemented MAC DISK"); | |
| } | |
| else { | |
| device_error(device_instance_device(raw_disk), | |
| "Unreconized bootblock"); | |
| } | |
| } | |
| } | |
| return NULL; | |
| } | |
| #endif /* _PK_DISKLABEL_C_ */ | |