402 lines
11 KiB
C
402 lines
11 KiB
C
/* 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_ */
|
|
|