Context Navigation

source: bootcd/isolinux/syslinux-6.03/memdisk/setup.c

Last change on this file was e16e8f2, checked in by Edwin Eefting <edwin@datux.nl>, 3 years ago
bootstuff
Property mode set to `100644`
File size: 35.3 KB

Rev	Line
[e16e8f2]	1	/* ----------------------------------------------------------------------- *
	2	*
	3	* Copyright 2001-2009 H. Peter Anvin - All Rights Reserved
	4	* Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
	5	* Portions copyright 2009-2010 Shao Miller
	6	* [El Torito code, mBFT, "safe hook"]
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation, Inc., 53 Temple Place Ste 330,
	11	* Boston MA 02111-1307, USA; either version 2 of the License, or
	12	* (at your option) any later version; incorporated herein by reference.
	13	*
	14	* ----------------------------------------------------------------------- */
	15
	16	#include <stdint.h>
	17	#include <minmax.h>
	18	#include <suffix_number.h>
	19	#include "bda.h"
	20	#include "dskprobe.h"
	21	#include "e820.h"
	22	#include "conio.h"
	23	#include "version.h"
	24	#include "memdisk.h"
	25	#include <version.h>
	26
	27	const char memdisk_version[] = "MEMDISK " VERSION_STR " " DATE;
	28	const char copyright[] =
	29	"Copyright " FIRSTYEAR "-" YEAR_STR " H. Peter Anvin et al";
	30
	31	extern const char _binary_memdisk_chs_512_bin_start[];
	32	extern const char _binary_memdisk_chs_512_bin_end[];
	33	extern const char _binary_memdisk_chs_512_bin_size[];
	34	extern const char _binary_memdisk_edd_512_bin_start[];
	35	extern const char _binary_memdisk_edd_512_bin_end[];
	36	extern const char _binary_memdisk_edd_512_bin_size[];
	37	extern const char _binary_memdisk_iso_512_bin_start[];
	38	extern const char _binary_memdisk_iso_512_bin_end[];
	39	extern const char _binary_memdisk_iso_512_bin_size[];
	40	extern const char _binary_memdisk_iso_2048_bin_start[];
	41	extern const char _binary_memdisk_iso_2048_bin_end[];
	42	extern const char _binary_memdisk_iso_2048_bin_size[];
	43
	44	/* Pull in structures common to MEMDISK and MDISKCHK.COM */
	45	#include "mstructs.h"
	46
	47	/* An EDD disk packet */
	48	struct edd_dsk_pkt {
	49	uint8_t size; /* Packet size */
	50	uint8_t res1; /* Reserved */
	51	uint16_t count; /* Count to transfer */
	52	uint32_t buf; /* Buffer pointer */
	53	uint64_t start; /* LBA to start from */
	54	uint64_t buf64; /* 64-bit buf pointer */
	55	} __attribute__ ((packed));
	56
	57	/* Change to 1 for El Torito debugging */
	58	#define DBG_ELTORITO 0
	59
	60	#if DBG_ELTORITO
	61	extern void eltorito_dump(uint32_t);
	62	#endif
	63
	64	/*
	65	* Routine to seek for a command-line item and return a pointer
	66	* to the data portion, if present
	67	*/
	68
	69	/* Magic return values */
	70	#define CMD_NOTFOUND ((char )-1) / Not found */
	71	#define CMD_BOOL ((char )-2) / Found boolean option */
	72	#define CMD_HASDATA(X) ((int)(X) >= 0)
	73
	74	static const char getcmditem(const char what)
	75	{
	76	const char *p;
	77	const char *wp = what;
	78	int match = 0;
	79
	80	for (p = shdr->cmdline; *p; p++) {
	81	switch (match) {
	82	case 0: /* Ground state */
	83	if (*p == ' ')
	84	break;
	85
	86	wp = what;
	87	match = 1;
	88	/* Fall through */
	89
	90	case 1: /* Matching */
	91	if (*wp == '\0') {
	92	if (*p == '=')
	93	return p + 1;
	94	else if (*p == ' ')
	95	return CMD_BOOL;
	96	else {
	97	match = 2;
	98	break;
	99	}
	100	}
	101	if (p != wp++)
	102	match = 2;
	103	break;
	104
	105	case 2: /* Mismatch, skip rest of option */
	106	if (*p == ' ')
	107	match = 0; /* Next option */
	108	break;
	109	}
	110	}
	111
	112	/* Check for matching string at end of line */
	113	if (match == 1 && *wp == '\0')
	114	return CMD_BOOL;
	115
	116	return CMD_NOTFOUND;
	117	}
	118
	119	/*
	120	* Check to see if this is a gzip image
	121	*/
	122	#define UNZIP_ALIGN 512
	123
	124	extern const char _end[]; /* Symbol signalling end of data */
	125
	126	void unzip_if_needed(uint32_t * where_p, uint32_t * size_p)
	127	{
	128	uint32_t where = *where_p;
	129	uint32_t size = *size_p;
	130	uint32_t zbytes;
	131	uint32_t startrange, endrange;
	132	uint32_t gzdatasize, gzwhere;
	133	uint32_t orig_crc, offset;
	134	uint32_t target = 0;
	135	int i, okmem;
	136
	137	/* Is it a gzip image? */
	138	if (check_zip((void *)where, size, &zbytes, &gzdatasize,
	139	&orig_crc, &offset) == 0) {
	140
	141	if (offset + zbytes > size) {
	142	/*
	143	* Assertion failure; check_zip is supposed to guarantee this
	144	* never happens.
	145	*/
	146	die("internal error: check_zip returned nonsense\n");
	147	}
	148
	149	/*
	150	* Find a good place to put it: search memory ranges in descending
	151	* order until we find one that is legal and fits
	152	*/
	153	okmem = 0;
	154	for (i = nranges - 1; i >= 0; i--) {
	155	/*
	156	* We can't use > 4G memory (32 bits only.) Truncate to 2^32-1
	157	* so we don't have to deal with funny wraparound issues.
	158	*/
	159
	160	/* Must be memory */
	161	if (ranges[i].type != 1)
	162	continue;
	163
	164	/* Range start */
	165	if (ranges[i].start >= 0xFFFFFFFF)
	166	continue;
	167
	168	startrange = (uint32_t) ranges[i].start;
	169
	170	/* Range end (0 for end means 2^64) */
	171	endrange = ((ranges[i + 1].start >= 0xFFFFFFFF \|\|
	172	ranges[i + 1].start == 0)
	173	? 0xFFFFFFFF : (uint32_t) ranges[i + 1].start);
	174
	175	/* Make sure we don't overwrite ourselves */
	176	if (startrange < (uint32_t) _end)
	177	startrange = (uint32_t) _end;
	178
	179	/* Allow for alignment */
	180	startrange =
	181	(ranges[i].start + (UNZIP_ALIGN - 1)) & ~(UNZIP_ALIGN - 1);
	182
	183	/* In case we just killed the whole range... */
	184	if (startrange >= endrange)
	185	continue;
	186
	187	/*
	188	* Must be large enough... don't rely on gzwhere for this
	189	* (wraparound)
	190	*/
	191	if (endrange - startrange < gzdatasize)
	192	continue;
	193
	194	/*
	195	* This is where the gz image would be put if we put it in this
	196	* range...
	197	*/
	198	gzwhere = (endrange - gzdatasize) & ~(UNZIP_ALIGN - 1);
	199
	200	/* Cast to uint64_t just in case we're flush with the top byte */
	201	if ((uint64_t) where + size >= gzwhere && where < endrange) {
	202	/*
	203	* Need to move source data to avoid compressed/uncompressed
	204	* overlap
	205	*/
	206	uint32_t newwhere;
	207
	208	if (gzwhere - startrange < size)
	209	continue; /* Can't fit both old and new */
	210
	211	newwhere = (gzwhere - size) & ~(UNZIP_ALIGN - 1);
	212	printf("Moving compressed data from 0x%08x to 0x%08x\n",
	213	where, newwhere);
	214
	215	memmove((void )newwhere, (void )where, size);
	216	where = newwhere;
	217	}
	218
	219	target = gzwhere;
	220	okmem = 1;
	221	break;
	222	}
	223
	224	if (!okmem)
	225	die("Not enough memory to decompress image (need 0x%08x bytes)\n",
	226	gzdatasize);
	227
	228	printf("gzip image: decompressed addr 0x%08x, len 0x%08x: ",
	229	target, gzdatasize);
	230
	231	*size_p = gzdatasize;
	232	where_p = (uint32_t) unzip((void )(where + offset), zbytes,
	233	gzdatasize, orig_crc, (void *)target);
	234	}
	235	}
	236
	237	/*
	238	* Figure out the "geometry" of the disk in question
	239	*/
	240	struct geometry {
	241	uint32_t sectors; /* Sector count */
	242	uint32_t c, h, s; /* C/H/S geometry */
	243	uint32_t offset; /* Byte offset for disk */
	244	uint32_t boot_lba; /* LBA of bootstrap code */
	245	uint8_t type; /* Type byte for INT 13h AH=08h */
	246	uint8_t driveno; /* Drive no */
	247	uint8_t sector_shift; /* Sector size as a power of 2 */
	248	const char hsrc, ssrc; /* Origins of H and S geometries */
	249	};
	250
	251	/* Format of a DOS partition table entry */
	252	struct ptab_entry {
	253	uint8_t active;
	254	uint8_t start_h, start_s, start_c;
	255	uint8_t type;
	256	uint8_t end_h, end_s, end_c;
	257	uint32_t start;
	258	uint32_t size;
	259	} __attribute__ ((packed));
	260
	261	/* Format of a FAT filesystem superblock */
	262	struct fat_extra {
	263	uint8_t bs_drvnum;
	264	uint8_t bs_resv1;
	265	uint8_t bs_bootsig;
	266	uint32_t bs_volid;
	267	char bs_vollab[11];
	268	char bs_filsystype[8];
	269	} __attribute__ ((packed));
	270	struct fat_super {
	271	uint8_t bs_jmpboot[3];
	272	char bs_oemname[8];
	273	uint16_t bpb_bytspersec;
	274	uint8_t bpb_secperclus;
	275	uint16_t bpb_rsvdseccnt;
	276	uint8_t bpb_numfats;
	277	uint16_t bpb_rootentcnt;
	278	uint16_t bpb_totsec16;
	279	uint8_t bpb_media;
	280	uint16_t bpb_fatsz16;
	281	uint16_t bpb_secpertrk;
	282	uint16_t bpb_numheads;
	283	uint32_t bpb_hiddsec;
	284	uint32_t bpb_totsec32;
	285	union {
	286	struct {
	287	struct fat_extra extra;
	288	} fat16;
	289	struct {
	290	uint32_t bpb_fatsz32;
	291	uint16_t bpb_extflags;
	292	uint16_t bpb_fsver;
	293	uint32_t bpb_rootclus;
	294	uint16_t bpb_fsinfo;
	295	uint16_t bpb_bkbootsec;
	296	char bpb_reserved[12];
	297	/* Clever, eh? Same fields, different offset... */
	298	struct fat_extra extra;
	299	} fat32 __attribute__ ((packed));
	300	} x;
	301	} __attribute__ ((packed));
	302
	303	/* Format of a DOSEMU header */
	304	struct dosemu_header {
	305	uint8_t magic[7]; /* DOSEMU\0 */
	306	uint32_t h;
	307	uint32_t s;
	308	uint32_t c;
	309	uint32_t offset;
	310	uint8_t pad[105];
	311	} __attribute__ ((packed));
	312
	313	#define FOUR(a,b,c,d) (((a) << 24)\|((b) << 16)\|((c) << 8)\|(d))
	314
	315	static const struct geometry *get_disk_image_geometry(uint32_t where,
	316	uint32_t size)
	317	{
	318	static struct geometry hd_geometry;
	319	struct dosemu_header dosemu;
	320	unsigned int sectors, xsectors, v;
	321	unsigned int offset;
	322	int i;
	323	const char *p;
	324
	325	printf("command line: %s\n", shdr->cmdline);
	326
	327	hd_geometry.sector_shift = 9; /* Assume floppy/HDD at first */
	328
	329	offset = 0;
	330	if (CMD_HASDATA(p = getcmditem("offset")) && (v = atou(p)))
	331	offset = v;
	332
	333	sectors = xsectors = (size - offset) >> hd_geometry.sector_shift;
	334
	335	hd_geometry.hsrc = "guess";
	336	hd_geometry.ssrc = "guess";
	337	hd_geometry.sectors = sectors;
	338	hd_geometry.offset = offset;
	339
	340	if ((p = getcmditem("iso")) != CMD_NOTFOUND) {
	341	#if DBG_ELTORITO
	342	eltorito_dump(where);
	343	#endif
	344	struct edd4_bvd bvd = (struct edd4_bvd )(where + 17 * 2048);
	345	/* Tiny sanity check */
	346	if ((bvd->boot_rec_ind != 0) \|\| (bvd->ver != 1))
	347	printf("El Torito BVD sanity check failed.\n");
	348	struct edd4_bootcat *boot_cat =
	349	(struct edd4_bootcat )(where + bvd->boot_cat 2048);
	350	/* Another tiny sanity check */
	351	if ((boot_cat->validation_entry.platform_id != 0) \|\|
	352	(boot_cat->validation_entry.key55 != 0x55) \|\|
	353	(boot_cat->validation_entry.keyAA != 0xAA))
	354	printf("El Torito boot catalog sanity check failed.\n");
	355	/* If we have an emulation mode, set the offset to the image */
	356	if (boot_cat->initial_entry.media_type)
	357	hd_geometry.offset += boot_cat->initial_entry.load_block * 2048;
	358	else
	359	/* We're a no-emulation mode, so we will boot to an offset */
	360	hd_geometry.boot_lba = boot_cat->initial_entry.load_block * 4;
	361	if (boot_cat->initial_entry.media_type < 4) {
	362	/* We're a floppy emulation mode or our params will be
	363	* overwritten by the no emulation mode case
	364	*/
	365	hd_geometry.driveno = 0x00;
	366	hd_geometry.c = 80;
	367	hd_geometry.h = 2;
	368	}
	369	switch (boot_cat->initial_entry.media_type) {
	370	case 0: /* No emulation */
	371	hd_geometry.driveno = 0xE0;
	372	hd_geometry.type = 10; /* ATAPI removable media device */
	373	hd_geometry.c = 65535;
	374	hd_geometry.h = 255;
	375	hd_geometry.s = 15;
	376	/* 2048-byte sectors, so adjust the size and count */
	377	hd_geometry.sector_shift = 11;
	378	break;
	379	case 1: /* 1.2 MB floppy */
	380	hd_geometry.s = 15;
	381	hd_geometry.type = 2;
	382	sectors = 2400;
	383	break;
	384	case 2: /* 1.44 MB floppy */
	385	hd_geometry.s = 18;
	386	hd_geometry.type = 4;
	387	sectors = 2880;
	388	break;
	389	case 3: /* 2.88 MB floppy */
	390	hd_geometry.s = 36;
	391	hd_geometry.type = 6;
	392	sectors = 5760;
	393	break;
	394	case 4:
	395	hd_geometry.driveno = 0x80;
	396	hd_geometry.type = 0;
	397	break;
	398	}
	399	sectors = (size - hd_geometry.offset) >> hd_geometry.sector_shift;
	400
	401	/* For HDD emulation, we figure out the geometry later. Otherwise: */
	402	if (hd_geometry.s) {
	403	hd_geometry.hsrc = hd_geometry.ssrc = "El Torito";
	404	}
	405	hd_geometry.sectors = sectors;
	406	}
	407
	408	/* Do we have a DOSEMU header? */
	409	memcpy(&dosemu, (char *)where + hd_geometry.offset, sizeof dosemu);
	410	if (!memcmp("DOSEMU", dosemu.magic, 7)) {
	411	/* Always a hard disk unless overruled by command-line options */
	412	hd_geometry.driveno = 0x80;
	413	hd_geometry.type = 0;
	414	hd_geometry.c = dosemu.c;
	415	hd_geometry.h = dosemu.h;
	416	hd_geometry.s = dosemu.s;
	417	hd_geometry.offset += dosemu.offset;
	418	sectors = (size - hd_geometry.offset) >> hd_geometry.sector_shift;
	419
	420	hd_geometry.hsrc = hd_geometry.ssrc = "DOSEMU";
	421	}
	422
	423	if (CMD_HASDATA(p = getcmditem("c")) && (v = atou(p)))
	424	hd_geometry.c = v;
	425	if (CMD_HASDATA(p = getcmditem("h")) && (v = atou(p))) {
	426	hd_geometry.h = v;
	427	hd_geometry.hsrc = "cmd";
	428	}
	429	if (CMD_HASDATA(p = getcmditem("s")) && (v = atou(p))) {
	430	hd_geometry.s = v;
	431	hd_geometry.ssrc = "cmd";
	432	}
	433
	434	if (!hd_geometry.h \|\| !hd_geometry.s) {
	435	int h, s, max_h, max_s;
	436
	437	max_h = hd_geometry.h;
	438	max_s = hd_geometry.s;
	439
	440	if (!(max_h \| max_s)) {
	441	/* Look for a FAT superblock and if we find something that looks
	442	enough like one, use geometry from that. This takes care of
	443	megafloppy images and unpartitioned hard disks. */
	444	const struct fat_extra *extra = NULL;
	445	const struct fat_super fs = (const struct fat_super )
	446	((char *)where + hd_geometry.offset);
	447
	448	if ((fs->bpb_media == 0xf0 \|\| fs->bpb_media >= 0xf8) &&
	449	(fs->bs_jmpboot[0] == 0xe9 \|\| fs->bs_jmpboot[0] == 0xeb) &&
	450	fs->bpb_bytspersec == 512 &&
	451	fs->bpb_numheads >= 1 && fs->bpb_numheads <= 256 &&
	452	fs->bpb_secpertrk >= 1 && fs->bpb_secpertrk <= 63) {
	453	extra =
	454	fs->bpb_fatsz16 ? &fs->x.fat16.extra : &fs->x.fat32.extra;
	455	if (!
	456	(extra->bs_bootsig == 0x29 && extra->bs_filsystype[0] == 'F'
	457	&& extra->bs_filsystype[1] == 'A'
	458	&& extra->bs_filsystype[2] == 'T'))
	459	extra = NULL;
	460	}
	461	if (extra) {
	462	hd_geometry.driveno = extra->bs_drvnum & 0x80;
	463	max_h = fs->bpb_numheads;
	464	max_s = fs->bpb_secpertrk;
	465	hd_geometry.hsrc = hd_geometry.ssrc = "FAT";
	466	}
	467	}
	468
	469	if (!(max_h \| max_s)) {
	470	/* No FAT filesystem found to steal geometry from... */
	471	if ((sectors < 4096 * 2) && (hd_geometry.sector_shift == 9)) {
	472	int ok = 0;
	473	unsigned int xsectors = sectors;
	474
	475	hd_geometry.driveno = 0; /* Assume floppy */
	476
	477	while (!ok) {
	478	/* Assume it's a floppy drive, guess a geometry */
	479	unsigned int type, track;
	480	int c, h, s = 0;
	481
	482	if (xsectors < 320 * 2) {
	483	c = 40;
	484	h = 1;
	485	type = 1;
	486	} else if (xsectors < 640 * 2) {
	487	c = 40;
	488	h = 2;
	489	type = 1;
	490	} else if (xsectors < 1200 * 2) {
	491	c = 80;
	492	h = 2;
	493	type = 3;
	494	} else if (xsectors < 1440 * 2) {
	495	c = 80;
	496	h = 2;
	497	type = 2;
	498	} else if (xsectors < 2880 * 2) {
	499	c = 80;
	500	h = 2;
	501	type = 4;
	502	} else {
	503	c = 80;
	504	h = 2;
	505	type = 6;
	506	}
	507	track = c * h;
	508	while (c < 256) {
	509	s = xsectors / track;
	510	if (s < 63 && (xsectors % track) == 0) {
	511	ok = 1;
	512	break;
	513	}
	514	c++;
	515	track += h;
	516	}
	517	if (ok) {
	518	max_h = h;
	519	max_s = s;
	520	hd_geometry.hsrc = hd_geometry.ssrc = "fd";
	521	} else {
	522	/* No valid floppy geometry, fake it by simulating broken
	523	sectors at the end of the image... */
	524	xsectors++;
	525	}
	526
	527	hd_geometry.type = type;
	528	}
	529	} else {
	530	/* Assume it is a hard disk image and scan for a partition table */
	531	const struct ptab_entry ptab = (const struct ptab_entry )
	532	((char )where + hd_geometry.offset + (512 - 2 - 4 16));
	533
	534	/* Assume hard disk */
	535	if (!hd_geometry.driveno)
	536	hd_geometry.driveno = 0x80;
	537
	538	if ((uint16_t ) ((char *)where + hd_geometry.offset + 512 - 2) == 0xaa55) {
	539	for (i = 0; i < 4; i++) {
	540	if (ptab[i].type && !(ptab[i].active & 0x7f)) {
	541	s = (ptab[i].start_s & 0x3f);
	542	h = ptab[i].start_h + 1;
	543
	544	if (max_h < h)
	545	max_h = h;
	546	if (max_s < s)
	547	max_s = s;
	548
	549	s = (ptab[i].end_s & 0x3f);
	550	h = ptab[i].end_h + 1;
	551
	552	if (max_h < h) {
	553	max_h = h;
	554	hd_geometry.hsrc = "MBR";
	555	}
	556	if (max_s < s) {
	557	max_s = s;
	558	hd_geometry.ssrc = "MBR";
	559	}
	560	}
	561	}
	562	}
	563
	564	hd_geometry.type = 0;
	565	}
	566	}
	567
	568	if (!max_h)
	569	max_h = xsectors > 2097152 ? 255 : 64;
	570	if (!max_s)
	571	max_s = xsectors > 2097152 ? 63 : 32;
	572
	573	hd_geometry.h = max_h;
	574	hd_geometry.s = max_s;
	575	}
	576
	577	if (!hd_geometry.c)
	578	hd_geometry.c = xsectors / (hd_geometry.h * hd_geometry.s);
	579
	580	if ((p = getcmditem("floppy")) != CMD_NOTFOUND) {
	581	hd_geometry.driveno = CMD_HASDATA(p) ? atou(p) & 0x7f : 0;
	582	} else if ((p = getcmditem("harddisk")) != CMD_NOTFOUND) {
	583	hd_geometry.driveno = CMD_HASDATA(p) ? atou(p) \| 0x80 : 0x80;
	584	}
	585
	586	if (hd_geometry.driveno & 0x80) {
	587	hd_geometry.type = 0; /* Type = hard disk */
	588	} else {
	589	if (hd_geometry.type == 0)
	590	hd_geometry.type = 0x10; /* ATAPI floppy, e.g. LS-120 */
	591	}
	592
	593	if ((size - hd_geometry.offset) & 0x1ff) {
	594	puts("MEMDISK: Image has fractional end sector\n");
	595	}
	596	if (sectors % (hd_geometry.h * hd_geometry.s)) {
	597	puts("MEMDISK: Image seems to have fractional end cylinder\n");
	598	}
	599	if ((hd_geometry.c * hd_geometry.h * hd_geometry.s) > sectors) {
	600	puts("MEMDISK: Image appears to be truncated\n");
	601	}
	602
	603	return &hd_geometry;
	604	}
	605
	606	/*
	607	* Find a $PnP installation check structure; return (ES << 16) + DI value
	608	*/
	609	static uint32_t pnp_install_check(void)
	610	{
	611	uint32_t *seg;
	612	unsigned char *p, csum;
	613	int i, len;
	614
	615	for (seg = (uint32_t ) 0xf0000; seg < (uint32_t ) 0x100000; seg += 4) {
	616	if (*seg == ('$' + ('P' << 8) + ('n' << 16) + ('P' << 24))) {
	617	p = (unsigned char *)seg;
	618	len = p[5];
	619	if (len < 0x21)
	620	continue;
	621	csum = 0;
	622	for (i = len; i; i--)
	623	csum += *p++;
	624	if (csum != 0)
	625	continue;
	626
	627	return (0xf000 << 16) + (uint16_t) (unsigned long)seg;
	628	}
	629	}
	630
	631	return 0;
	632	}
	633
	634	/*
	635	* Relocate the real-mode code to a new segment
	636	*/
	637	struct gdt_ptr {
	638	uint16_t limit;
	639	uint32_t base;
	640	} __attribute__ ((packed));
	641
	642	static void set_seg_base(uint32_t gdt_base, int seg, uint32_t v)
	643	{
	644	(uint16_t ) (gdt_base + seg + 2) = v;
	645	(uint8_t ) (gdt_base + seg + 4) = v >> 16;
	646	(uint8_t ) (gdt_base + seg + 7) = v >> 24;
	647	}
	648
	649	static void relocate_rm_code(uint32_t newbase)
	650	{
	651	uint32_t gdt_base;
	652	uint32_t oldbase = rm_args.rm_base;
	653	uint32_t delta = newbase - oldbase;
	654
	655	cli();
	656	memmove((void )newbase, (void )oldbase, rm_args.rm_size);
	657
	658	rm_args.rm_return += delta;
	659	rm_args.rm_intcall += delta;
	660	rm_args.rm_bounce += delta;
	661	rm_args.rm_base += delta;
	662	rm_args.rm_gdt += delta;
	663	rm_args.rm_pmjmp += delta;
	664	rm_args.rm_rmjmp += delta;
	665
	666	gdt_base = rm_args.rm_gdt;
	667
	668	(uint32_t ) (gdt_base + 2) = gdt_base; /* GDT self-pointer */
	669
	670	/* Segments 0x10 and 0x18 are real-mode-based */
	671	set_seg_base(gdt_base, 0x10, rm_args.rm_base);
	672	set_seg_base(gdt_base, 0x18, rm_args.rm_base);
	673
	674	#if __SIZEOF_POINTER__ == 4
	675	asm volatile ("lgdtl %0"::"m" ((char )gdt_base));
	676	#elif __SIZEOF_POINTER__ == 8
	677	asm volatile ("lgdt %0"::"m" ((char )gdt_base));
	678	#else
	679	#error "unsupported architecture"
	680	#endif
	681
	682	(uint32_t ) rm_args.rm_pmjmp += delta;
	683	(uint16_t ) rm_args.rm_rmjmp += delta >> 4;
	684
	685	rm_args.rm_handle_interrupt += delta;
	686
	687	sti();
	688	}
	689
	690	static uint8_t checksum_buf(const void *buf, int count)
	691	{
	692	const uint8_t *p = buf;
	693	uint8_t c = 0;
	694
	695	while (count--)
	696	c += *p++;
	697
	698	return c;
	699	}
	700
	701	static int stack_needed(void)
	702	{
	703	const unsigned int min_stack = 128; /* Minimum stack size */
	704	const unsigned int def_stack = 512; /* Default stack size */
	705	unsigned int v = 0;
	706	const char *p;
	707
	708	if (CMD_HASDATA(p = getcmditem("stack")))
	709	v = atou(p);
	710
	711	if (!v)
	712	v = def_stack;
	713
	714	if (v < min_stack)
	715	v = min_stack;
	716
	717	return v;
	718	}
	719
	720	/*
	721	* Set max memory by reservation
	722	* Adds reservations to data in INT15h to prevent access to the top of RAM
	723	* if there's any above the point specified.
	724	*/
	725	void setmaxmem(unsigned long long restop_ull)
	726	{
	727	uint32_t restop;
	728	struct e820range *ep;
	729	const int int15restype = 2;
	730
	731	/* insertrange() works on uint32_t */
	732	restop = min(restop_ull, UINT32_MAX);
	733	/* printf(" setmaxmem '%08x%08x' => %08x\n",
	734	(unsigned int)(restop_ull>>32), (unsigned int)restop_ull, restop); */
	735
	736	for (ep = ranges; ep->type != -1U; ep++) {
	737	if (ep->type == 1) { /* Only if available */
	738	if (ep->start >= restop) {
	739	/* printf(" %08x -> 2\n", ep->start); */
	740	ep->type = int15restype;
	741	} else if (ep[1].start > restop) {
	742	/* printf(" +%08x =2; cut %08x\n", restop, ep->start); */
	743	insertrange(restop, (ep[1].start - restop), int15restype);
	744	}
	745	}
	746	}
	747	parse_mem();
	748	}
	749
	750	struct real_mode_args rm_args;
	751
	752	/*
	753	* Actual setup routine
	754	* Returns the drive number (which is then passed in %dl to the
	755	* called routine.)
	756	*/
	757	void setup(const struct real_mode_args *rm_args_ptr)
	758	{
	759	unsigned int bin_size;
	760	char *memdisk_hook;
	761	struct memdisk_header *hptr;
	762	struct patch_area *pptr;
	763	struct mBFT *mbft;
	764	uint16_t driverseg;
	765	uint32_t driverptr, driveraddr;
	766	uint16_t dosmem_k;
	767	uint32_t stddosmem;
	768	const struct geometry *geometry;
	769	unsigned int total_size;
	770	unsigned int cmdline_len, stack_len, e820_len;
	771	const struct edd4_bvd *bvd;
	772	const struct edd4_bootcat *boot_cat = 0;
	773	com32sys_t regs;
	774	uint32_t ramdisk_image, ramdisk_size;
	775	uint32_t boot_base, rm_base;
	776	int bios_drives;
	777	int do_edd = 1; /* 0 = no, 1 = yes, default is yes */
	778	int do_eltorito = 0; /* default is no */
	779	int no_bpt; /* No valid BPT presented */
	780	uint32_t boot_seg = 0; /* Meaning 0000:7C00 */
	781	uint32_t boot_len = 512; /* One sector */
	782	const char *p;
	783
	784	/* We need to copy the rm_args into their proper place */
	785	memcpy(&rm_args, rm_args_ptr, sizeof rm_args);
	786	sti(); /* ... then interrupts are safe */
	787
	788	/* Show signs of life */
	789	printf("%s %s\n", memdisk_version, copyright);
	790
	791	if (!shdr->ramdisk_image \|\| !shdr->ramdisk_size)
	792	die("MEMDISK: No ramdisk image specified!\n");
	793
	794	ramdisk_image = shdr->ramdisk_image;
	795	ramdisk_size = shdr->ramdisk_size;
	796
	797	e820map_init(); /* Initialize memory data structure */
	798	get_mem(); /* Query BIOS for memory map */
	799	parse_mem(); /* Parse memory map */
	800
	801	printf("Ramdisk at 0x%08x, length 0x%08x\n", ramdisk_image, ramdisk_size);
	802
	803	unzip_if_needed(&ramdisk_image, &ramdisk_size);
	804
	805	geometry = get_disk_image_geometry(ramdisk_image, ramdisk_size);
	806
	807	if (getcmditem("edd") != CMD_NOTFOUND \|\|
	808	getcmditem("ebios") != CMD_NOTFOUND)
	809	do_edd = 1;
	810	else if (getcmditem("noedd") != CMD_NOTFOUND \|\|
	811	getcmditem("noebios") != CMD_NOTFOUND \|\|
	812	getcmditem("cbios") != CMD_NOTFOUND)
	813	do_edd = 0;
	814	else
	815	do_edd = (geometry->driveno & 0x80) ? 1 : 0;
	816
	817	if (getcmditem("iso") != CMD_NOTFOUND) {
	818	do_eltorito = 1;
	819	do_edd = 1; /* Mandatory */
	820	}
	821
	822	/* Choose the appropriate installable memdisk hook */
	823	if (do_eltorito) {
	824	if (geometry->sector_shift == 11) {
	825	bin_size = (int)&_binary_memdisk_iso_2048_bin_size;
	826	memdisk_hook = (char *)&_binary_memdisk_iso_2048_bin_start;
	827	} else {
	828	bin_size = (int)&_binary_memdisk_iso_512_bin_size;
	829	memdisk_hook = (char *)&_binary_memdisk_iso_512_bin_start;
	830	}
	831	} else {
	832	if (do_edd) {
	833	bin_size = (int)&_binary_memdisk_edd_512_bin_size;
	834	memdisk_hook = (char *)&_binary_memdisk_edd_512_bin_start;
	835	} else {
	836	bin_size = (int)&_binary_memdisk_chs_512_bin_size;
	837	memdisk_hook = (char *)&_binary_memdisk_chs_512_bin_start;
	838	}
	839	}
	840
	841	/* Reserve the ramdisk memory */
	842	insertrange(ramdisk_image, ramdisk_size, 2);
	843	parse_mem(); /* Recompute variables */
	844
	845	/* Figure out where it needs to go */
	846	hptr = (struct memdisk_header *)memdisk_hook;
	847	pptr = (struct patch_area *)(memdisk_hook + hptr->patch_offs);
	848
	849	dosmem_k = rdz_16(BIOS_BASEMEM);
	850	pptr->mdi.olddosmem = dosmem_k;
	851	stddosmem = dosmem_k << 10;
	852	/* If INT 15 E820 and INT 12 disagree, go with the most conservative */
	853	if (stddosmem > dos_mem)
	854	stddosmem = dos_mem;
	855
	856	pptr->driveno = geometry->driveno;
	857	pptr->drivetype = geometry->type;
	858	pptr->cylinders = geometry->c; /* Possible precision loss */
	859	pptr->heads = geometry->h;
	860	pptr->sectors = geometry->s;
	861	pptr->mdi.disksize = geometry->sectors;
	862	pptr->mdi.diskbuf = ramdisk_image + geometry->offset;
	863	pptr->mdi.sector_shift = geometry->sector_shift;
	864	pptr->statusptr = (geometry->driveno & 0x80) ? 0x474 : 0x441;
	865
	866	pptr->mdi.bootloaderid = shdr->type_of_loader;
	867
	868	pptr->configflags = CONFIG_SAFEINT; /* Default */
	869	/* Set config flags */
	870	if (getcmditem("ro") != CMD_NOTFOUND) {
	871	pptr->configflags \|= CONFIG_READONLY;
	872	}
	873	if (getcmditem("raw") != CMD_NOTFOUND) {
	874	pptr->configflags &= ~CONFIG_MODEMASK;
	875	pptr->configflags \|= CONFIG_RAW;
	876	}
	877	if (getcmditem("bigraw") != CMD_NOTFOUND) {
	878	pptr->configflags &= ~CONFIG_MODEMASK;
	879	pptr->configflags \|= CONFIG_BIGRAW \| CONFIG_RAW;
	880	}
	881	if (getcmditem("int") != CMD_NOTFOUND) {
	882	pptr->configflags &= ~CONFIG_MODEMASK;
	883	/* pptr->configflags \|= 0; */
	884	}
	885	if (getcmditem("safeint") != CMD_NOTFOUND) {
	886	pptr->configflags &= ~CONFIG_MODEMASK;
	887	pptr->configflags \|= CONFIG_SAFEINT;
	888	}
	889
	890	printf("Disk is %s%d, %u%s K, C/H/S = %u/%u/%u (%s/%s), EDD %s, %s\n",
	891	(geometry->driveno & 0x80) ? "hd" : "fd",
	892	geometry->driveno & 0x7f,
	893	geometry->sectors >> 1,
	894	(geometry->sectors & 1) ? ".5" : "",
	895	geometry->c, geometry->h, geometry->s,
	896	geometry->hsrc, geometry->ssrc,
	897	do_edd ? "on" : "off",
	898	pptr->configflags & CONFIG_READONLY ? "ro" : "rw");
	899
	900	puts("Using ");
	901	switch (pptr->configflags & CONFIG_MODEMASK) {
	902	case 0:
	903	puts("standard INT 15h");
	904	break;
	905	case CONFIG_SAFEINT:
	906	puts("safe INT 15h");
	907	break;
	908	case CONFIG_RAW:
	909	puts("raw");
	910	break;
	911	case CONFIG_RAW \| CONFIG_BIGRAW:
	912	puts("big real mode raw");
	913	break;
	914	default:
	915	printf("unknown %#x", pptr->configflags & CONFIG_MODEMASK);
	916	break;
	917	}
	918	puts(" access to high memory\n");
	919
	920	/* Set up a drive parameter table */
	921	if (geometry->driveno & 0x80) {
	922	/* Hard disk */
	923	pptr->dpt.hd.max_cyl = geometry->c - 1;
	924	pptr->dpt.hd.max_head = geometry->h - 1;
	925	pptr->dpt.hd.ctrl = (geometry->h > 8) ? 0x08 : 0;
	926	} else {
	927	/* Floppy - most of these fields are bogus and mimic
	928	a 1.44 MB floppy drive */
	929	pptr->dpt.fd.specify1 = 0xdf;
	930	pptr->dpt.fd.specify2 = 0x02;
	931	pptr->dpt.fd.delay = 0x25;
	932	pptr->dpt.fd.sectors = geometry->s;
	933	pptr->dpt.fd.bps = 0x02;
	934	pptr->dpt.fd.isgap = 0x12;
	935	pptr->dpt.fd.dlen = 0xff;
	936	pptr->dpt.fd.fgap = 0x6c;
	937	pptr->dpt.fd.ffill = 0xf6;
	938	pptr->dpt.fd.settle = 0x0f;
	939	pptr->dpt.fd.mstart = 0x05;
	940	pptr->dpt.fd.maxtrack = geometry->c - 1;
	941	pptr->dpt.fd.cmos = geometry->type > 5 ? 5 : geometry->type;
	942
	943	pptr->dpt.fd.old_fd_dpt = rdz_32(BIOS_INT1E);
	944	}
	945
	946	/* Set up an EDD drive parameter table */
	947	if (do_edd) {
	948	pptr->edd_dpt.sectors = geometry->sectors;
	949	/* The EDD spec has this as <= 15482880 sectors (1024x240x63);
	950	this seems to make very little sense. Try for something saner. */
	951	if (geometry->c <= 1024 && geometry->h <= 255 && geometry->s <= 63) {
	952	pptr->edd_dpt.c = geometry->c;
	953	pptr->edd_dpt.h = geometry->h;
	954	pptr->edd_dpt.s = geometry->s;
	955	/* EDD-4 states that invalid geometry should be returned
	956	* for INT 0x13, AH=0x48 "EDD Get Disk Parameters" call on an
	957	* El Torito ODD. Check for 2048-byte sector size
	958	*/
	959	if (geometry->sector_shift != 11)
	960	pptr->edd_dpt.flags \|= 0x0002; /* Geometry valid */
	961	}
	962	if (!(geometry->driveno & 0x80)) {
	963	/* Floppy drive. Mark it as a removable device with
	964	media change notification; media is present. */
	965	pptr->edd_dpt.flags \|= 0x0014;
	966	}
	967
	968	pptr->edd_dpt.devpath[0] = pptr->mdi.diskbuf;
	969	pptr->edd_dpt.chksum = -checksum_buf(&pptr->edd_dpt.dpikey, 73 - 30);
	970	}
	971
	972	if (do_eltorito) {
	973	bvd = (struct edd4_bvd )(ramdisk_image + 17 2048);
	974	boot_cat =
	975	(struct edd4_bootcat )(ramdisk_image + bvd->boot_cat 2048);
	976	pptr->cd_pkt.type = boot_cat->initial_entry.media_type; /* Cheat */
	977	pptr->cd_pkt.driveno = geometry->driveno;
	978	pptr->cd_pkt.start = boot_cat->initial_entry.load_block;
	979	boot_seg = pptr->cd_pkt.load_seg = boot_cat->initial_entry.load_seg;
	980	pptr->cd_pkt.sect_count = boot_cat->initial_entry.sect_count;
	981	boot_len = pptr->cd_pkt.sect_count * 512;
	982	pptr->cd_pkt.geom1 = (uint8_t)(pptr->cylinders) & 0xFF;
	983	pptr->cd_pkt.geom2 =
	984	(uint8_t)(pptr->sectors) \| (uint8_t)((pptr->cylinders >> 2) & 0xC0);
	985	pptr->cd_pkt.geom3 = (uint8_t)(pptr->heads);
	986	}
	987
	988	if ((p = getcmditem("mem")) != CMD_NOTFOUND) {
	989	setmaxmem(suffix_number(p));
	990	}
	991
	992	/* The size is given by hptr->total_size plus the size of the E820
	993	map -- 12 bytes per range; we may need as many as 2 additional
	994	ranges (each insertrange() can worst-case turn 1 area into 3)
	995	plus the terminating range, over what nranges currently show. */
	996	total_size = hptr->total_size; /* Actual memdisk code */
	997	e820_len = (nranges + 3) * sizeof(ranges[0]);
	998	total_size += e820_len; /* E820 memory ranges */
	999	cmdline_len = strlen(shdr->cmdline) + 1;
	1000	total_size += cmdline_len; /* Command line */
	1001	stack_len = stack_needed();
	1002	total_size += stack_len; /* Stack */
	1003	printf("Code %u, meminfo %u, cmdline %u, stack %u\n",
	1004	hptr->total_size, e820_len, cmdline_len, stack_len);
	1005	printf("Total size needed = %u bytes, allocating %uK\n",
	1006	total_size, (total_size + 0x3ff) >> 10);
	1007
	1008	if (total_size > dos_mem)
	1009	die("MEMDISK: Insufficient low memory\n");
	1010
	1011	driveraddr = stddosmem - total_size;
	1012	driveraddr &= ~0x3FF;
	1013
	1014	printf("Old dos memory at 0x%05x (map says 0x%05x), loading at 0x%05x\n",
	1015	stddosmem, dos_mem, driveraddr);
	1016
	1017	/* Reserve this range of memory */
	1018	wrz_16(BIOS_BASEMEM, driveraddr >> 10);
	1019	insertrange(driveraddr, dos_mem - driveraddr, 2);
	1020	parse_mem();
	1021
	1022	pptr->mem1mb = low_mem >> 10;
	1023	pptr->mem16mb = high_mem >> 16;
	1024	if (low_mem == (15 << 20)) {
	1025	/* lowmem maxed out */
	1026	uint32_t int1588mem = (high_mem >> 10) + (low_mem >> 10);
	1027	pptr->memint1588 = (int1588mem > 0xffff) ? 0xffff : int1588mem;
	1028	} else {
	1029	pptr->memint1588 = low_mem >> 10;
	1030	}
	1031
	1032	printf("1588: 0x%04x 15E801: 0x%04x 0x%04x\n",
	1033	pptr->memint1588, pptr->mem1mb, pptr->mem16mb);
	1034
	1035	driverseg = driveraddr >> 4;
	1036	driverptr = driverseg << 16;
	1037
	1038	/* Anything beyond the end is for the stack */
	1039	pptr->mystack = (uint16_t) (stddosmem - driveraddr);
	1040
	1041	pptr->mdi.oldint13.uint32 = rdz_32(BIOS_INT13);
	1042	pptr->mdi.oldint15.uint32 = rdz_32(BIOS_INT15);
	1043
	1044	/* Adjust the E820 table: if there are null ranges (type 0)
	1045	at the end, change them to type end of list (-1).
	1046	This is necessary for the driver to be able to report end
	1047	of list correctly. */
	1048	while (nranges && ranges[nranges - 1].type == 0) {
	1049	ranges[--nranges].type = -1;
	1050	}
	1051
	1052	if (getcmditem("nopassany") != CMD_NOTFOUND) {
	1053	printf("nopassany specified - we're the only drive of any kind\n");
	1054	bios_drives = 0;
	1055	pptr->drivecnt = 0;
	1056	no_bpt = 1;
	1057	pptr->mdi.oldint13.uint32 = driverptr + hptr->iret_offs;
	1058	wrz_8(BIOS_EQUIP, rdz_8(BIOS_EQUIP) & ~0xc1);
	1059	wrz_8(BIOS_HD_COUNT, 0);
	1060	} else if (getcmditem("nopass") != CMD_NOTFOUND) {
	1061	printf("nopass specified - we're the only drive\n");
	1062	bios_drives = 0;
	1063	pptr->drivecnt = 0;
	1064	no_bpt = 1;
	1065	} else {
	1066	/* Query drive parameters of this type */
	1067	memset(&regs, 0, sizeof regs);
	1068	regs.es = 0;
	1069	regs.eax.b[1] = 0x08;
	1070	regs.edx.b[0] = geometry->driveno & 0x80;
	1071	intcall(0x13, &regs, &regs);
	1072
	1073	/* Note: per suggestion from the Interrupt List, consider
	1074	INT 13 08 to have failed if the sector count in CL is zero. */
	1075	if ((regs.eflags.l & 1) \|\| !(regs.ecx.b[0] & 0x3f)) {
	1076	printf("INT 13 08: Failure, assuming this is the only drive\n");
	1077	pptr->drivecnt = 0;
	1078	no_bpt = 1;
	1079	} else {
	1080	printf("INT 13 08: Success, count = %u, BPT = %04x:%04x\n",
	1081	regs.edx.b[0], regs.es, regs.edi.w[0]);
	1082	pptr->drivecnt = regs.edx.b[0];
	1083	no_bpt = !(regs.es \| regs.edi.w[0]);
	1084	}
	1085
	1086	/* Compare what INT 13h returned with the appropriate equipment byte */
	1087	if (geometry->driveno & 0x80) {
	1088	bios_drives = rdz_8(BIOS_HD_COUNT);
	1089	} else {
	1090	uint8_t equip = rdz_8(BIOS_EQUIP);
	1091
	1092	if (equip & 1)
	1093	bios_drives = (equip >> 6) + 1;
	1094	else
	1095	bios_drives = 0;
	1096	}
	1097
	1098	if (pptr->drivecnt > bios_drives) {
	1099	printf("BIOS equipment byte says count = %d, go with that\n",
	1100	bios_drives);
	1101	pptr->drivecnt = bios_drives;
	1102	}
	1103	}
	1104
	1105	/* Add ourselves to the drive count */
	1106	pptr->drivecnt++;
	1107
	1108	/* Discontiguous drive space. There is no really good solution for this. */
	1109	if (pptr->drivecnt <= (geometry->driveno & 0x7f))
	1110	pptr->drivecnt = (geometry->driveno & 0x7f) + 1;
	1111
	1112	/* Probe for contiguous range of BIOS drives starting with driveno */
	1113	pptr->driveshiftlimit = probe_drive_range(geometry->driveno) + 1;
	1114	if ((pptr->driveshiftlimit & 0x80) != (geometry->driveno & 0x80))
	1115	printf("We lost the last drive in our class of drives.\n");
	1116	printf("Drive probing gives drive shift limit: 0x%02x\n",
	1117	pptr->driveshiftlimit);
	1118
	1119	/* Pointer to the command line */
	1120	pptr->mdi.cmdline.seg_off.offset = bin_size + (nranges + 1) * sizeof(ranges[0]);
	1121	pptr->mdi.cmdline.seg_off.segment = driverseg;
	1122
	1123	/* Copy driver followed by E820 table followed by command line */
	1124	{
	1125	unsigned char dpp = (unsigned char )(driverseg << 4);
	1126
	1127	/* Adjust these pointers to point to the installed image */
	1128	/* Careful about the order here... the image isn't copied yet! */
	1129	pptr = (struct patch_area *)(dpp + hptr->patch_offs);
	1130	hptr = (struct memdisk_header *)dpp;
	1131
	1132	/* Actually copy to low memory */
	1133	dpp = mempcpy(dpp, memdisk_hook, bin_size);
	1134	dpp = mempcpy(dpp, ranges, (nranges + 1) * sizeof(ranges[0]));
	1135	dpp = mempcpy(dpp, shdr->cmdline, cmdline_len);
	1136	}
	1137
	1138	/* Note the previous INT 13h hook in the "safe hook" structure */
	1139	hptr->safe_hook.old_hook.uint32 = pptr->mdi.oldint13.uint32;
	1140
	1141	/* Re-fill the "safe hook" mBFT field with the physical address */
	1142	mbft = (struct mBFT )(((const char )hptr) + hptr->safe_hook.mbft);
	1143	hptr->safe_hook.mbft = (size_t)mbft;
	1144
	1145	/* Update various BIOS magic data areas (gotta love this shit) */
	1146
	1147	if (geometry->driveno & 0x80) {
	1148	/* Update BIOS hard disk count */
	1149	uint8_t nhd = pptr->drivecnt;
	1150
	1151	if (nhd > 128)
	1152	nhd = 128;
	1153
	1154	if (!do_eltorito)
	1155	wrz_8(BIOS_HD_COUNT, nhd);
	1156	} else {
	1157	/* Update BIOS floppy disk count */
	1158	uint8_t equip = rdz_8(BIOS_EQUIP);
	1159	uint8_t nflop = pptr->drivecnt;
	1160
	1161	if (nflop > 4) /* Limit of equipment byte */
	1162	nflop = 4;
	1163
	1164	equip &= 0x3E;
	1165	if (nflop)
	1166	equip \|= ((nflop - 1) << 6) \| 0x01;
	1167
	1168	wrz_8(BIOS_EQUIP, equip);
	1169
	1170	/* Install DPT pointer if this was the only floppy */
	1171	if (getcmditem("dpt") != CMD_NOTFOUND \|\|
	1172	((nflop == 1 \|\| no_bpt) && getcmditem("nodpt") == CMD_NOTFOUND)) {
	1173	/* Do install a replacement DPT into INT 1Eh */
	1174	pptr->mdi.dpt_ptr =
	1175	hptr->patch_offs + offsetof(struct patch_area, dpt);
	1176	}
	1177	}
	1178
	1179	/* Complete the mBFT */
	1180	mbft->acpi.signature[0] = 'm'; /* "mBFT" */
	1181	mbft->acpi.signature[1] = 'B';
	1182	mbft->acpi.signature[2] = 'F';
	1183	mbft->acpi.signature[3] = 'T';
	1184	mbft->safe_hook = (size_t)&hptr->safe_hook;
	1185	mbft->acpi.checksum = -checksum_buf(mbft, mbft->acpi.length);
	1186
	1187	/* Install the interrupt handlers */
	1188	printf("old: int13 = %08x int15 = %08x int1e = %08x\n",
	1189	rdz_32(BIOS_INT13), rdz_32(BIOS_INT15), rdz_32(BIOS_INT1E));
	1190
	1191	wrz_32(BIOS_INT13, driverptr + hptr->int13_offs);
	1192	wrz_32(BIOS_INT15, driverptr + hptr->int15_offs);
	1193	if (pptr->mdi.dpt_ptr)
	1194	wrz_32(BIOS_INT1E, driverptr + pptr->mdi.dpt_ptr);
	1195
	1196	printf("new: int13 = %08x int15 = %08x int1e = %08x\n",
	1197	rdz_32(BIOS_INT13), rdz_32(BIOS_INT15), rdz_32(BIOS_INT1E));
	1198
	1199	/* Figure out entry point */
	1200	if (!boot_seg) {
	1201	boot_base = 0x7c00;
	1202	shdr->sssp = 0x7c00;
	1203	shdr->csip = 0x7c00;
	1204	} else {
	1205	boot_base = boot_seg << 4;
	1206	shdr->sssp = boot_seg << 16;
	1207	shdr->csip = boot_seg << 16;
	1208	}
	1209
	1210	/* Relocate the real-mode code to below the stub */
	1211	rm_base = (driveraddr - rm_args.rm_size) & ~15;
	1212	if (rm_base < boot_base + boot_len)
	1213	die("MEMDISK: bootstrap too large to load\n");
	1214
	1215	relocate_rm_code(rm_base);
	1216
	1217	/* Reboot into the new "disk" */
	1218	puts("Loading boot sector... ");
	1219
	1220	memcpy((void *)boot_base,
	1221	(char )pptr->mdi.diskbuf + geometry->boot_lba 512,
	1222	boot_len);
	1223
	1224	if (getcmditem("pause") != CMD_NOTFOUND) {
	1225	puts("press any key to boot... ");
	1226	memset(&regs, 0, sizeof regs);
	1227	regs.eax.w[0] = 0;
	1228	intcall(0x16, &regs, NULL);
	1229	}
	1230
	1231	puts("booting...\n");
	1232
	1233	/* On return the assembly code will jump to the boot vector */
	1234	shdr->esdi = pnp_install_check();
	1235	shdr->edx = geometry->driveno;
	1236	}
	1237

Note: See TracBrowser for help on using the repository browser.

Download in other formats: