sim/ppc/pk_disklabel.c

   1 /*  This file is part of the program psim.
   2
   3     Copyright (C) 1994-1996, Andrew Cagney <cagney@highland.com.au>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19     */
  20
  21
  22 #ifndef _PK_DISKLABEL_C_
  23 #define _PK_DISKLABEL_C_
  24
  25 #ifndef STATIC_INLINE_PK_DISKLABEL
  26 #define STATIC_INLINE_PK_DISKLABEL STATIC_INLINE
  27 #endif
  28
  29 #include "device_table.h"
  30
  31 #include "pk.h"
  32
  33 #ifdef HAVE_STDLIB_H
  34 #include <stdlib.h>
  35 #endif
  36
  37
  38
  39 /* PACKAGE
  40
  41    disk-label - all knowing disk I/O package
  42
  43    DESCRIPTION
  44
  45    The disk-label package provides a generic interface to disk
  46    devices.  It uses the arguments specified when an instance is being
  47    created to determine if the raw disk, a partition, or a file within
  48    a partition should be opened.
  49
  50    An instance create call to disk-label could result, for instance,
  51    in the opening of a DOS file system contained within a dos
  52    partition contained within a physical disk.
  53
  54    */
  55
  56 /* taken from bfd/ppcboot.c by Michael Meissner */
  57
  58 /* PPCbug location structure */
  59 typedef struct ppcboot_location {
  60   unsigned8 ind;
  61   unsigned8 head;
  62   unsigned8 sector;
  63   unsigned8 cylinder;
  64 } ppcboot_location_t;
  65
  66 /* PPCbug partition table layout */
  67 typedef struct ppcboot_partition {
  68   ppcboot_location_t partition_begin;   /* partition begin */
  69   ppcboot_location_t partition_end;     /* partition end */
  70   unsigned8 sector_begin[4];            /* 32-bit start RBA (zero-based), little endian */
  71   unsigned8 sector_length[4];           /* 32-bit RBA count (one-based), little endian */
  72 } ppcboot_partition_t;
  73
  74 #if 0
  75 /* PPCbug boot layout.  */
  76 typedef struct ppcboot_hdr {
  77   unsigned8             pc_compatibility[446];  /* x86 instruction field */
  78   ppcboot_partition_t   partition[4];           /* partition information */
  79   unsigned8             signature[2];           /* 0x55 and 0xaa */
  80   unsigned8             entry_offset[4];        /* entry point offset, little endian */
  81   unsigned8             length[4];              /* load image length, little endian */
  82   unsigned8             flags;                  /* flag field */
  83   unsigned8             os_id;                  /* OS_ID */
  84   char                  partition_name[32];     /* partition name */
  85   unsigned8             reserved1[470];         /* reserved */
  86 } ppcboot_hdr_t;
  87 #endif
  88
  89
  90 typedef struct _disklabel {
  91   device_instance *parent;
  92   device_instance *raw_disk;
  93   unsigned_word pos;
  94   unsigned_word sector_begin;
  95   unsigned_word sector_length;
  96 } disklabel;
  97
  98
  99 static unsigned_word
 100 sector2uw(unsigned8 s[4])
 101 {
 102   return ((s[3] << 24)
 103           + (s[2] << 16)
 104           + (s[1] << 8)
 105           + (s[0] << 0));
 106 }
 107
 108
 109 static void
 110 disklabel_delete(device_instance *instance)
 111 {
 112   disklabel *label = device_instance_data(instance);
 113   device_instance_delete(label->raw_disk);
 114   zfree(label);
 115 }
 116
 117
 118 static int
 119 disklabel_read(device_instance *instance,
 120                void *buf,
 121                unsigned_word len)
 122 {
 123   disklabel *label = device_instance_data(instance);
 124   int nr_read;
 125   if (label->pos + len > label->sector_length)
 126     len = label->sector_length - label->pos;
 127   if (device_instance_seek(label->raw_disk, 0,
 128                            label->sector_begin + label->pos) < 0)
 129     return -1;
 130   nr_read = device_instance_read(label->raw_disk, buf, len);
 131   if (nr_read > 0)
 132     label->pos += nr_read;
 133   return nr_read;
 134 }
 135
 136 static int
 137 disklabel_write(device_instance *instance,
 138                 const void *buf,
 139                 unsigned_word len)
 140 {
 141   disklabel *label = device_instance_data(instance);
 142   int nr_written;
 143   if (label->pos + len > label->sector_length)
 144     len = label->sector_length - label->pos;
 145   if (device_instance_seek(label->raw_disk, 0,
 146                            label->sector_begin + label->pos) < 0)
 147     return -1;
 148   nr_written = device_instance_write(label->raw_disk, buf, len);
 149   if (nr_written > 0)
 150     label->pos += nr_written;
 151   return nr_written;
 152 }
 153
 154 static int
 155 disklabel_seek(device_instance *instance,
 156                unsigned_word pos_hi,
 157                unsigned_word pos_lo)
 158 {
 159   disklabel *label = device_instance_data(instance);
 160   if (pos_lo >= label->sector_length || pos_hi != 0)
 161     return -1;
 162   label->pos = pos_lo;
 163   return 0;
 164 }
 165
 166
 167 static const device_instance_callbacks package_disklabel_callbacks = {
 168   disklabel_delete,
 169   disklabel_read,
 170   disklabel_write,
 171   disklabel_seek,
 172 };
 173
 174 /* Reconize different types of boot block */
 175
 176 static int
 177 block_is_bpb(const unsigned8 block[])
 178 {
 179   const char ebdic_ibma[] = { 0xc9, 0xc2, 0xd4, 0xc1 };
 180   /* ref PowerPC Microprocessor CHRP bindings 1.2b - page 47 */
 181   /* can't start with IBMA */
 182   if (memcmp(block, ebdic_ibma, sizeof(ebdic_ibma)) == 0)
 183     return 0;
 184   /* must have LE 0xAA55 signature at offset 510 */
 185   if (block[511] != 0xAA && block[510] != 0x55)
 186     return 0;
 187   /* valid 16 bit LE bytes per sector - 256, 512, 1024 */
 188   if (block[11] != 0
 189       || (block[12] != 1 && block[12] != 2 && block[12] != 4))
 190     return 0;
 191   /* nr fats is 1 or 2 */
 192   if (block[16] != 1 && block[16] != 2)
 193     return 0;
 194   return 1;
 195 }
 196
 197 /* is_iso9660() later ... */
 198
 199 static int
 200 block_is_fdisk(const unsigned8 block[])
 201 {
 202   const int partition_type_fields[] = { 0x1c2, 0x1d2, 0x1e2, 0x1f2, 0 };
 203   int partition;
 204   /* ref PowerPC Microprocessor CHRP bindings 1.2b - page 47 */
 205   /* must have LE 0xAA55 signature at offset 510 */
 206   if (block[511] != 0xAA && block[510] != 0x55)
 207     return 0;
 208   /* must contain valid partition types */
 209   for (partition = 0;
 210        partition_type_fields[partition] != 0;
 211        partition++) {
 212     switch (block[partition_type_fields[partition]]) {
 213     case 4: case 0x41: case 0x96:
 214       break;
 215     case 5: case 6:
 216       PTRACE(disklabel, ("extended partition types not supported\n"));
 217       return 0;
 218     case 0x82:
 219       PTRACE(disklabel, ("warning - partition %d of type 0x82 - Solaris?\n", partition));
 220       break;
 221     case 0x1:
 222       PTRACE(disklabel, ("warning - partition %d of type 1 - DOS12\n", partition));
 223       break;
 224     case 0:
 225       break;
 226     default:
 227       PTRACE(disklabel, ("rejecting partition %d of type 0x%x\n", partition,
 228                          block[partition_type_fields[partition]]));
 229       return 0;
 230     }
 231   }
 232   return 1;
 233 }
 234
 235 static int
 236 block_is_mac_disk(const unsigned8 block[])
 237 {
 238   /* ref PowerPC Microprocessor CHRP bindings 1.2b - page 47 */
 239   /* signature - BEx4552 at offset 0 */
 240   if (block[0] != 0x45 || block[1] != 0x52)
 241     return 0;
 242   return 1;
 243 }
 244
 245
 246 /* Open a logical disk/file */
 247
 248 device_instance *
 249 pk_disklabel_create_instance(device_instance *raw_disk,
 250                              const char *args)
 251 {
 252   int partition;
 253   char *filename;
 254   unsigned8 boot_block[512];
 255
 256   /* parse the arguments */
 257   if (args == NULL) {
 258     partition = 0;
 259     filename = NULL;
 260   }
 261   else {
 262     partition = strtoul((char*)args, &filename, 0);
 263     if (filename == args)
 264       partition = -1; /* not specified */
 265     if (*filename == ',')
 266       filename++;
 267     if (*filename == '\0')
 268       filename = NULL; /* easier */
 269   }
 270
 271   if (device_instance_seek(raw_disk, 0, 0) < 0)
 272     device_error(device_instance_device(raw_disk),
 273                  "Problem seeking on raw disk\n");
 274
 275   if (partition < 0) {
 276     /* select the active partition */
 277     if (device_instance_read(raw_disk, &boot_block, sizeof(boot_block))
 278         != sizeof(boot_block))
 279       return raw_disk;
 280     device_error(device_instance_device(raw_disk),
 281                  "selection of the active partition unimplemented\n");
 282     return (device_instance *)0;        /* silence warnings */
 283   }
 284   else if (partition == 0) {
 285     /* select the raw disk */
 286     return raw_disk;
 287   }
 288   else {
 289     /* select the specified disk partition */
 290     /* read in the boot record */
 291     if (device_instance_read(raw_disk, &boot_block, sizeof(boot_block))
 292         != sizeof(boot_block))
 293       return raw_disk;
 294     if (block_is_bpb(boot_block)) {
 295       device_error(device_instance_device(raw_disk), "Unimplemented\n");
 296     }
 297     else if (block_is_fdisk(boot_block)) {
 298       /* return an instance */
 299       ppcboot_partition_t *partition_table = (ppcboot_partition_t*) &boot_block[446];
 300       ppcboot_partition_t *partition_entry;
 301       disklabel *label;
 302       if (partition > 3)
 303         device_error(device_instance_device(raw_disk),
 304                      "Invalid fdisk partition number %d\n", partition);
 305       partition_entry = &partition_table[partition-1];
 306       label = ZALLOC(disklabel);
 307       label->raw_disk = raw_disk;
 308       label->pos = 0;
 309       label->sector_begin = 512 * sector2uw(partition_entry->sector_begin);
 310       label->sector_length = 512 * sector2uw(partition_entry->sector_length);
 311       PTRACE(disklabel, ("partition %ld, sector-begin %ld, length %ld\n",
 312                          (long)partition, (long)label->sector_begin, (long)label->sector_length));
 313       if (filename != NULL)
 314         device_error(device_instance_device(raw_disk),
 315                      "File names not yet supported\n");
 316       return device_create_instance_from(NULL, raw_disk,
 317                                          label,
 318                                          NULL, args,
 319                                          &package_disklabel_callbacks);
 320     }
 321     else if (block_is_mac_disk(boot_block)) {
 322       device_error(device_instance_device(raw_disk), "Unimplemented\n");
 323     }
 324     else {
 325       device_error(device_instance_device(raw_disk),
 326                    "Unreconized bootblock\n");
 327     }
 328     return raw_disk;
 329   }
 330
 331 }
 332
 333
 334 #endif /* _PK_DISKLABEL_C_ */
 335