[deliverable/binutils-gdb.git] / sim / ppc / pk_disklabel.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_ */
Commit	Line	Data
c906108c SS	1	/* This file is part of the program psim.
	2
	3	Copyright (C) 1994-1997, 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	block0_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
198	/* Verify that the device contains an ISO-9660 File system */
199
200	static int
201	is_iso9660(device_instance *raw_disk)
202	{
203	/* ref PowerPC Microprocessor CHRP bindings 1.2b - page 47 */
204	unsigned8 block[512];
205	if (device_instance_seek(raw_disk, 0, 512 * 64) < 0)
206	return 0;
207	if (device_instance_read(raw_disk, block, sizeof(block)) != sizeof(block))
208	return 0;
209	if (block[0] == 0x01
210	&& block[1] == 'C'
211	&& block[2] == 'D'
212	&& block[3] == '0'
213	&& block[4] == '0'
214	&& block[5] == '1')
215	return 1;
216	return 0;
217	}
218
219
220	/* Verify that the disk block contains a valid DOS partition table.
221	While we're at it have a look around for active partitions etc.
222
223	Return 0: invalid
224	Return 1..4: valid, value returned is the first active partition
225	Return -1: no active partition */
226
227	static int
228	block0_is_fdisk(const unsigned8 block[])
229	{
230	const int partition_type_fields[] = { 0, 0x1c2, 0x1d2, 0x1e2, 0x1f2 };
231	const int partition_active_fields[] = { 0, 0x1be, 0x1ce, 0x1de, 0xee };
232	int partition;
233	int active = -1;
234	/* ref PowerPC Microprocessor CHRP bindings 1.2b - page 47 */
235	/* must have LE 0xAA55 signature at offset 510 */
236	if (block[511/0x1ff/] != 0xAA && block[510/0x1fe/] != 0x55)
237	return 0;
238	/* must contain valid partition types */
239	for (partition = 1; partition <= 4 && active != 0; partition++) {
240	int partition_type = block[partition_type_fields[partition]];
241	int is_active = block[partition_active_fields[partition]] == 0x80;
242	const char *type;
243	switch (partition_type) {
244	case 0x00:
245	type = "UNUSED";
246	break;
247	case 0x01:
248	type = "FAT 12 File system";
249	break;
250	case 0x04:
251	type = "FAT 16 File system";
252	break;
253	case 0x05:
254	case 0x06:
255	type = "rejected - extended/chained partition not supported";
256	active = 0;
257	break;
258	case 0x41:
259	type = "Single program image";
260	break;
261	case 0x82:
262	type = "Solaris?";
263	break;
264	case 0x96:
265	type = "ISO 9660 File system";
266	break;
267	default:
268	type = "rejected - unknown type";
269	active = 0;
270	break;
271	}
272	PTRACE(disklabel, ("partition %d of type 0x%02x - %s%s\n",
273	partition,
274	partition_type,
275	type,
276	is_active && active != 0 ? " (active)" : ""));
277	if (partition_type != 0 && is_active && active < 0)
278	active = partition;
279	}
280	return active;
281	}
282
283
284	/* Verify that block0 corresponds to a MAC disk */
285
286	static int
287	block0_is_mac_disk(const unsigned8 block[])
288	{
289	/* ref PowerPC Microprocessor CHRP bindings 1.2b - page 47 */
290	/* signature - BEx4552 at offset 0 */
291	if (block[0] != 0x45 \|\| block[1] != 0x52)
292	return 0;
293	return 1;
294	}
295
296
297	/* Open a logical disk/file */
298
299	device_instance *
300	pk_disklabel_create_instance(device_instance *raw_disk,
301	const char *args)
302	{
303	int partition;
304	char *filename;
305
306	/* parse the arguments */
307	if (args == NULL) {
308	partition = 0;
309	filename = NULL;
310	}
311	else {
312	partition = strtoul((char*)args, &filename, 0);
313	if (filename == args)
314	partition = -1; /* not specified */
315	if (*filename == ',')
316	filename++;
317	if (*filename == '\0')
318	filename = NULL; /* easier */
319	}
320
321	if (partition == 0) {
322	/* select the raw disk */
323	return raw_disk;
324	}
325	else {
326	unsigned8 boot_block[512];
327	/* get the boot block for examination */
328	if (device_instance_seek(raw_disk, 0, 0) < 0)
329	device_error(device_instance_device(raw_disk),
330	"Problem seeking on raw disk");
331	if (device_instance_read(raw_disk, &boot_block, sizeof(boot_block))
332	!= sizeof(boot_block))
333	device_error(device_instance_device(raw_disk), "Problem reading boot block");
334
335	if (partition < 0) {
336	/* select the active partition */
337	if (block0_is_bpb(boot_block)) {
338	device_error(device_instance_device(raw_disk), "Unimplemented active BPB");
339	}
340	else if (block0_is_fdisk(boot_block)) {
341	int active = block0_is_fdisk(boot_block);
342	device_error(device_instance_device(raw_disk), "Unimplemented active FDISK (%d)",
343	active);
344	}
345	else if (is_iso9660(raw_disk)) {
346	device_error(device_instance_device(raw_disk), "Unimplemented active ISO9660");
347	}
348	else if (block0_is_mac_disk(boot_block)) {
349	device_error(device_instance_device(raw_disk), "Unimplemented active MAC DISK");
350	}
351	else {
352	device_error(device_instance_device(raw_disk), "Unreconized bootblock");
353	}
354	}
355	else {
356	/* select the specified disk partition */
357	if (block0_is_bpb(boot_block)) {
358	device_error(device_instance_device(raw_disk), "Unimplemented BPB");
359	}
360	else if (block0_is_fdisk(boot_block)) {
361	/* return an instance */
362	ppcboot_partition_t partition_table = (ppcboot_partition_t) &boot_block[446];
363	ppcboot_partition_t *partition_entry;
364	disklabel *label;
365	if (partition > 4)
366	device_error(device_instance_device(raw_disk),
367	"Only FDISK partitions 1..4 supported");
368	partition_entry = &partition_table[partition - 1];
369	label = ZALLOC(disklabel);
370	label->raw_disk = raw_disk;
371	label->pos = 0;
372	label->sector_begin = 512 * sector2uw(partition_entry->sector_begin);
373	label->sector_length = 512 * sector2uw(partition_entry->sector_length);
374	PTRACE(disklabel, ("partition %ld, sector-begin %ld, length %ld\n",
375	(long)partition,
376	(long)label->sector_begin,
377	(long)label->sector_length));
378	if (filename != NULL)
379	device_error(device_instance_device(raw_disk),
380	"FDISK file names not yet supported");
381	return device_create_instance_from(NULL, raw_disk,
382	label,
383	NULL, args,
384	&package_disklabel_callbacks);
385	}
386	else if (block0_is_mac_disk(boot_block)) {
387	device_error(device_instance_device(raw_disk), "Unimplemented MAC DISK");
388	}
389	else {
390	device_error(device_instance_device(raw_disk),
391	"Unreconized bootblock");
392	}
393	}
394	}
395
396	return NULL;
397	}
398
399
400	#endif /* _PK_DISKLABEL_C_ */
401