src/disk/bootblock.c

/*
 *  Copyright (C) 2003-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: bootblock.c,v 1.1 2007/03/16 14:45:30 debug Exp $
 *
 *  Bootblock handling:
 *
 *      o)  For some machines (e.g. DECstation or the Dreamcast), it is
 *          possible to load a bootblock from a fixed location on disk, and
 *          simply execute it in memory.
 *
 *      o)  For booting from generic CDROM ISO9660 images, a filename of
 *          a file to load must be supplied (the kernel filename). It is
 *          loaded, possibly gunzipped, and then executed as if it was a
 *          separate file.
 *
 *  TODO: This module needs some cleanup.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "cpu.h"
#include "diskimage.h"
#include "emul.h"
#include "machine.h"
#include "misc.h"

static char *diskimage_types[] = DISKIMAGE_TYPES;


/*
 *  load_bootblock():
 *
 *  For some emulation modes, it is possible to boot from a harddisk image by
 *  loading a bootblock from a specific disk offset into memory, and executing
 *  that, instead of requiring a separate kernel file.  It is then up to the
 *  bootblock to load a kernel.
 *
 *  Returns 1 on success, 0 on failure.
 */
int load_bootblock(struct machine *m, struct cpu *cpu,
        int *n_loadp, char ***load_namesp)
{
        int boot_disk_id, boot_disk_type = 0, n_blocks, res, readofs,
            iso_type, retval = 0;
        unsigned char minibuf[0x20];
        unsigned char *bootblock_buf;
        uint64_t bootblock_offset, base_offset;
        uint64_t bootblock_loadaddr, bootblock_pc;

        boot_disk_id = diskimage_bootdev(m, &boot_disk_type);
        if (boot_disk_id < 0)
                return 0;

        base_offset = diskimage_get_baseoffset(m, boot_disk_id, boot_disk_type);

        switch (m->machine_type) {

        case MACHINE_DREAMCAST:
                if (!diskimage_is_a_cdrom(cpu->machine, boot_disk_id,
                    boot_disk_type)) {
                        fatal("The Dreamcast emulation mode can only boot"
                            " from CD images, not from other disk types.\n");
                        exit(1);
                }

                bootblock_buf = malloc(32768);
                if (bootblock_buf == NULL) {
                        fprintf(stderr, "Out of memory.\n");
                        exit(1);
                }

                debug("loading Dreamcast IP.BIN from %s id %i\n",
                    diskimage_types[boot_disk_type], boot_disk_id);

                res = diskimage_access(m, boot_disk_id, boot_disk_type,
                    0, base_offset, bootblock_buf, 0x8000);
                if (!res) {
                        fatal("Couldn't read the disk image. Aborting.\n");
                        return 0;
                }

                if (strncmp((char *)bootblock_buf, "SEGA ", 5) != 0) {
                        fatal("This is not a Dreamcast IP.BIN header.\n");
                        free(bootblock_buf);
                        return 0;
                }

                /*  Store IP.BIN at 0x8c008000, and set entry point.  */
                store_buf(cpu, 0x8c008000, (char *)bootblock_buf, 32768);
                cpu->pc = 0x8c008300;

                /*  Remember the name of the file to boot (1ST_READ.BIN):  */
                if (cpu->machine->boot_kernel_filename == NULL ||
                    cpu->machine->boot_kernel_filename[0] == '\0') {
                        int i = 0x60;
                        while (i < 0x70) {
                                if (bootblock_buf[i] == ' ')
                                        bootblock_buf[i] = 0;
                                i ++;
                        }
                        cpu->machine->boot_kernel_filename = strdup(
                            (char *)bootblock_buf + 0x60);
                }

                debug("boot filename: %s\n",
                    cpu->machine->boot_kernel_filename);

                free(bootblock_buf);

                break;

        case MACHINE_PMAX:
                /*
                 *  The first few bytes of a disk contains information about
                 *  where the bootblock(s) are located. (These are all 32-bit
                 *  little-endian words.)
                 *
                 *  Offset 0x10 = load address
                 *         0x14 = initial PC value
                 *         0x18 = nr of 512-byte blocks to read
                 *         0x1c = offset on disk to where the bootblocks
                 *                are (in 512-byte units)
                 *         0x20 = nr of blocks to read...
                 *         0x24 = offset...
                 *
                 *  nr of blocks to read and offset are repeated until nr of
                 *  blocks to read is zero.
                 */
                res = diskimage_access(m, boot_disk_id, boot_disk_type, 0, 0,
                    minibuf, sizeof(minibuf));

                bootblock_loadaddr = minibuf[0x10] + (minibuf[0x11] << 8)
                  + (minibuf[0x12] << 16) + ((uint64_t)minibuf[0x13] << 24);

                /*  Convert loadaddr to uncached:  */
                if ((bootblock_loadaddr & 0xf0000000ULL) != 0x80000000 &&
                    (bootblock_loadaddr & 0xf0000000ULL) != 0xa0000000) {
                        fatal("\nWARNING! Weird load address 0x%08"PRIx32
                            " for SCSI id %i.\n\n",
                            (uint32_t)bootblock_loadaddr, boot_disk_id);
                        if (bootblock_loadaddr == 0) {
                                fatal("I'm assuming that this is _not_ a "
                                    "DEC bootblock.\nAre you sure you are"
                                    " booting from the correct disk?\n");
                                exit(1);
                        }
                }

                bootblock_loadaddr &= 0x0fffffffULL;
                bootblock_loadaddr |= 0xffffffffa0000000ULL;

                bootblock_pc = minibuf[0x14] + (minibuf[0x15] << 8)
                  + (minibuf[0x16] << 16) + ((uint64_t)minibuf[0x17] << 24);

                bootblock_pc &= 0x0fffffffULL;
                bootblock_pc |= 0xffffffffa0000000ULL;
                cpu->pc = bootblock_pc;

                debug("DEC boot: loadaddr=0x%08x, pc=0x%08x",
                    (int)bootblock_loadaddr, (int)bootblock_pc);

                readofs = 0x18;

                for (;;) {
                        res = diskimage_access(m, boot_disk_id, boot_disk_type,
                            0, readofs, minibuf, sizeof(minibuf));
                        if (!res) {
                                fatal("Couldn't read the disk image. "
                                    "Aborting.\n");
                                return 0;
                        }

                        n_blocks = minibuf[0] + (minibuf[1] << 8)
                          + (minibuf[2] << 16) + ((uint64_t)minibuf[3] << 24);

                        bootblock_offset = (minibuf[4] + (minibuf[5] << 8) +
                          (minibuf[6]<<16) + ((uint64_t)minibuf[7]<<24)) * 512;

                        if (n_blocks < 1)
                                break;

                        debug(readofs == 0x18? ": %i" : " + %i", n_blocks);

                        if (n_blocks * 512 > 65536)
                                fatal("\nWARNING! Unusually large bootblock "
                                    "(%i bytes)\n\n", n_blocks * 512);

                        bootblock_buf = malloc(n_blocks * 512);
                        if (bootblock_buf == NULL) {
                                fprintf(stderr, "out of memory in "
                                    "load_bootblock()\n");
                                exit(1);
                        }

                        res = diskimage_access(m, boot_disk_id, boot_disk_type,
                            0, bootblock_offset, bootblock_buf, n_blocks * 512);
                        if (!res) {
                                fatal("WARNING: could not load bootblocks from"
                                    " disk offset 0x%llx\n",
                                    (long long)bootblock_offset);
                        }

                        store_buf(cpu, bootblock_loadaddr,
                            (char *)bootblock_buf, n_blocks * 512);

                        bootblock_loadaddr += 512*n_blocks;
                        free(bootblock_buf);
                        readofs += 8;
                }

                debug(readofs == 0x18? ": no blocks?\n" : " blocks\n");
                return 1;
        }


        /*
         *  Try reading a kernel manually from the disk. The code here
         *  does not rely on machine-dependent boot blocks etc.
         */
        /*  ISO9660: (0x800 bytes at 0x8000 + base_offset)  */
        bootblock_buf = malloc(0x800);
        if (bootblock_buf == NULL) {
                fprintf(stderr, "Out of memory.\n");
                exit(1);
        }

        res = diskimage_access(m, boot_disk_id, boot_disk_type,
            0, base_offset + 0x8000, bootblock_buf, 0x800);
        if (!res) {
                fatal("Couldn't read the disk image. Aborting.\n");
                return 0;
        }

        iso_type = 0;
        if (strncmp((char *)bootblock_buf+1, "CD001", 5) == 0)
                iso_type = 1;
        if (strncmp((char *)bootblock_buf+1, "CDW01", 5) == 0)
                iso_type = 2;
        if (strncmp((char *)bootblock_buf+1, "CDROM", 5) == 0)
                iso_type = 3;

        if (iso_type != 0) {
                /*
                 *  If the user specified a kernel name, then load it from
                 *  disk.
                 */
                if (cpu->machine->boot_kernel_filename == NULL ||
                    cpu->machine->boot_kernel_filename[0] == '\0')
                        fatal("\nISO9660 filesystem, but no kernel "
                            "specified? (Use the -j option.)\n");
                else
                        retval = iso_load_bootblock(m, cpu, boot_disk_id,
                            boot_disk_type, iso_type, bootblock_buf,
                            n_loadp, load_namesp);
        }

        if (retval != 0)
                goto ret_ok;

        /*  Apple parition table:  */
        res = diskimage_access(m, boot_disk_id, boot_disk_type,
            0, 0x0, bootblock_buf, 0x800);
        if (!res) {
                fatal("Couldn't read the disk image. Aborting.\n");
                return 0;
        }
        if (bootblock_buf[0x000] == 'E' && bootblock_buf[0x001] == 'R' &&
            bootblock_buf[0x200] == 'P' && bootblock_buf[0x201] == 'M') {
                if (cpu->machine->boot_kernel_filename == NULL ||
                    cpu->machine->boot_kernel_filename[0] == '\0')
                        fatal("\nApple partition table, but no kernel "
                            "specified? (Use the -j option.)\n");
                else
                        retval = apple_load_bootblock(m, cpu, boot_disk_id,
                            boot_disk_type, n_loadp, load_namesp);
        }

ret_ok:
        free(bootblock_buf);
        return retval;
}


1	dpavlin	36	/*
2			* Copyright (C) 2003-2007 Anders Gavare. All rights reserved.
3			*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28			* $Id: bootblock.c,v 1.1 2007/03/16 14:45:30 debug Exp $
29			*
30			* Bootblock handling:
31			*
32			* o) For some machines (e.g. DECstation or the Dreamcast), it is
33			* possible to load a bootblock from a fixed location on disk, and
34			* simply execute it in memory.
35			*
36			* o) For booting from generic CDROM ISO9660 images, a filename of
37			* a file to load must be supplied (the kernel filename). It is
38			* loaded, possibly gunzipped, and then executed as if it was a
39			* separate file.
40			*
41			* TODO: This module needs some cleanup.
42			*/
43
44			#include <stdio.h>
45			#include <stdlib.h>
46			#include <string.h>
47
48			#include "cpu.h"
49			#include "diskimage.h"
50			#include "emul.h"
51			#include "machine.h"
52			#include "misc.h"
53
54			static char *diskimage_types[] = DISKIMAGE_TYPES;
55
56
57			/*
58			* load_bootblock():
59			*
60			* For some emulation modes, it is possible to boot from a harddisk image by
61			* loading a bootblock from a specific disk offset into memory, and executing
62			* that, instead of requiring a separate kernel file. It is then up to the
63			* bootblock to load a kernel.
64			*
65			* Returns 1 on success, 0 on failure.
66			*/
67			int load_bootblock(struct machine m, struct cpu cpu,
68			int n_loadp, char **load_namesp)
69			{
70			int boot_disk_id, boot_disk_type = 0, n_blocks, res, readofs,
71			iso_type, retval = 0;
72			unsigned char minibuf[0x20];
73			unsigned char *bootblock_buf;
74			uint64_t bootblock_offset, base_offset;
75			uint64_t bootblock_loadaddr, bootblock_pc;
76
77			boot_disk_id = diskimage_bootdev(m, &boot_disk_type);
78			if (boot_disk_id < 0)
79			return 0;
80
81			base_offset = diskimage_get_baseoffset(m, boot_disk_id, boot_disk_type);
82
83			switch (m->machine_type) {
84
85			case MACHINE_DREAMCAST:
86			if (!diskimage_is_a_cdrom(cpu->machine, boot_disk_id,
87			boot_disk_type)) {
88			fatal("The Dreamcast emulation mode can only boot"
89			" from CD images, not from other disk types.\n");
90			exit(1);
91			}
92
93			bootblock_buf = malloc(32768);
94			if (bootblock_buf == NULL) {
95			fprintf(stderr, "Out of memory.\n");
96			exit(1);
97			}
98
99			debug("loading Dreamcast IP.BIN from %s id %i\n",
100			diskimage_types[boot_disk_type], boot_disk_id);
101
102			res = diskimage_access(m, boot_disk_id, boot_disk_type,
103			0, base_offset, bootblock_buf, 0x8000);
104			if (!res) {
105			fatal("Couldn't read the disk image. Aborting.\n");
106			return 0;
107			}
108
109			if (strncmp((char *)bootblock_buf, "SEGA ", 5) != 0) {
110			fatal("This is not a Dreamcast IP.BIN header.\n");
111			free(bootblock_buf);
112			return 0;
113			}
114
115			/* Store IP.BIN at 0x8c008000, and set entry point. */
116			store_buf(cpu, 0x8c008000, (char *)bootblock_buf, 32768);
117			cpu->pc = 0x8c008300;
118
119			/* Remember the name of the file to boot (1ST_READ.BIN): */
120			if (cpu->machine->boot_kernel_filename == NULL \|\|
121			cpu->machine->boot_kernel_filename[0] == '\0') {
122			int i = 0x60;
123			while (i < 0x70) {
124			if (bootblock_buf[i] == ' ')
125			bootblock_buf[i] = 0;
126			i ++;
127			}
128			cpu->machine->boot_kernel_filename = strdup(
129			(char *)bootblock_buf + 0x60);
130			}
131
132			debug("boot filename: %s\n",
133			cpu->machine->boot_kernel_filename);
134
135			free(bootblock_buf);
136
137			break;
138
139			case MACHINE_PMAX:
140			/*
141			* The first few bytes of a disk contains information about
142			* where the bootblock(s) are located. (These are all 32-bit
143			* little-endian words.)
144			*
145			* Offset 0x10 = load address
146			* 0x14 = initial PC value
147			* 0x18 = nr of 512-byte blocks to read
148			* 0x1c = offset on disk to where the bootblocks
149			* are (in 512-byte units)
150			* 0x20 = nr of blocks to read...
151			* 0x24 = offset...
152			*
153			* nr of blocks to read and offset are repeated until nr of
154			* blocks to read is zero.
155			*/
156			res = diskimage_access(m, boot_disk_id, boot_disk_type, 0, 0,
157			minibuf, sizeof(minibuf));
158
159			bootblock_loadaddr = minibuf[0x10] + (minibuf[0x11] << 8)
160			+ (minibuf[0x12] << 16) + ((uint64_t)minibuf[0x13] << 24);
161
162			/* Convert loadaddr to uncached: */
163			if ((bootblock_loadaddr & 0xf0000000ULL) != 0x80000000 &&
164			(bootblock_loadaddr & 0xf0000000ULL) != 0xa0000000) {
165			fatal("\nWARNING! Weird load address 0x%08"PRIx32
166			" for SCSI id %i.\n\n",
167			(uint32_t)bootblock_loadaddr, boot_disk_id);
168			if (bootblock_loadaddr == 0) {
169			fatal("I'm assuming that this is _not_ a "
170			"DEC bootblock.\nAre you sure you are"
171			" booting from the correct disk?\n");
172			exit(1);
173			}
174			}
175
176			bootblock_loadaddr &= 0x0fffffffULL;
177			bootblock_loadaddr \|= 0xffffffffa0000000ULL;
178
179			bootblock_pc = minibuf[0x14] + (minibuf[0x15] << 8)
180			+ (minibuf[0x16] << 16) + ((uint64_t)minibuf[0x17] << 24);
181
182			bootblock_pc &= 0x0fffffffULL;
183			bootblock_pc \|= 0xffffffffa0000000ULL;
184			cpu->pc = bootblock_pc;
185
186			debug("DEC boot: loadaddr=0x%08x, pc=0x%08x",
187			(int)bootblock_loadaddr, (int)bootblock_pc);
188
189			readofs = 0x18;
190
191			for (;;) {
192			res = diskimage_access(m, boot_disk_id, boot_disk_type,
193			0, readofs, minibuf, sizeof(minibuf));
194			if (!res) {
195			fatal("Couldn't read the disk image. "
196			"Aborting.\n");
197			return 0;
198			}
199
200			n_blocks = minibuf[0] + (minibuf[1] << 8)
201			+ (minibuf[2] << 16) + ((uint64_t)minibuf[3] << 24);
202
203			bootblock_offset = (minibuf[4] + (minibuf[5] << 8) +
204			(minibuf[6]<<16) + ((uint64_t)minibuf[7]<<24)) * 512;
205
206			if (n_blocks < 1)
207			break;
208
209			debug(readofs == 0x18? ": %i" : " + %i", n_blocks);
210
211			if (n_blocks * 512 > 65536)
212			fatal("\nWARNING! Unusually large bootblock "
213			"(%i bytes)\n\n", n_blocks * 512);
214
215			bootblock_buf = malloc(n_blocks * 512);
216			if (bootblock_buf == NULL) {
217			fprintf(stderr, "out of memory in "
218			"load_bootblock()\n");
219			exit(1);
220			}
221
222			res = diskimage_access(m, boot_disk_id, boot_disk_type,
223			0, bootblock_offset, bootblock_buf, n_blocks * 512);
224			if (!res) {
225			fatal("WARNING: could not load bootblocks from"
226			" disk offset 0x%llx\n",
227			(long long)bootblock_offset);
228			}
229
230			store_buf(cpu, bootblock_loadaddr,
231			(char )bootblock_buf, n_blocks 512);
232
233			bootblock_loadaddr += 512*n_blocks;
234			free(bootblock_buf);
235			readofs += 8;
236			}
237
238			debug(readofs == 0x18? ": no blocks?\n" : " blocks\n");
239			return 1;
240			}
241
242
243			/*
244			* Try reading a kernel manually from the disk. The code here
245			* does not rely on machine-dependent boot blocks etc.
246			*/
247			/* ISO9660: (0x800 bytes at 0x8000 + base_offset) */
248			bootblock_buf = malloc(0x800);
249			if (bootblock_buf == NULL) {
250			fprintf(stderr, "Out of memory.\n");
251			exit(1);
252			}
253
254			res = diskimage_access(m, boot_disk_id, boot_disk_type,
255			0, base_offset + 0x8000, bootblock_buf, 0x800);
256			if (!res) {
257			fatal("Couldn't read the disk image. Aborting.\n");
258			return 0;
259			}
260
261			iso_type = 0;
262			if (strncmp((char *)bootblock_buf+1, "CD001", 5) == 0)
263			iso_type = 1;
264			if (strncmp((char *)bootblock_buf+1, "CDW01", 5) == 0)
265			iso_type = 2;
266			if (strncmp((char *)bootblock_buf+1, "CDROM", 5) == 0)
267			iso_type = 3;
268
269			if (iso_type != 0) {
270			/*
271			* If the user specified a kernel name, then load it from
272			* disk.
273			*/
274			if (cpu->machine->boot_kernel_filename == NULL \|\|
275			cpu->machine->boot_kernel_filename[0] == '\0')
276			fatal("\nISO9660 filesystem, but no kernel "
277			"specified? (Use the -j option.)\n");
278			else
279			retval = iso_load_bootblock(m, cpu, boot_disk_id,
280			boot_disk_type, iso_type, bootblock_buf,
281			n_loadp, load_namesp);
282			}
283
284			if (retval != 0)
285			goto ret_ok;
286
287			/* Apple parition table: */
288			res = diskimage_access(m, boot_disk_id, boot_disk_type,
289			0, 0x0, bootblock_buf, 0x800);
290			if (!res) {
291			fatal("Couldn't read the disk image. Aborting.\n");
292			return 0;
293			}
294			if (bootblock_buf[0x000] == 'E' && bootblock_buf[0x001] == 'R' &&
295			bootblock_buf[0x200] == 'P' && bootblock_buf[0x201] == 'M') {
296			if (cpu->machine->boot_kernel_filename == NULL \|\|
297			cpu->machine->boot_kernel_filename[0] == '\0')
298			fatal("\nApple partition table, but no kernel "
299			"specified? (Use the -j option.)\n");
300			else
301			retval = apple_load_bootblock(m, cpu, boot_disk_id,
302			boot_disk_type, n_loadp, load_namesp);
303			}
304
305			ret_ok:
306			free(bootblock_buf);
307			return retval;
308			}
309
310