path: root/src/bin/writembr/mbr.S

/*
 * Partly from:
 * $FreeBSD: src/sys/boot/i386/pmbr/pmbr.s,v 1.2 2007/11/26 21:29:59 jhb Exp $
 *
 * Copyright (c) 2007 Yahoo!, Inc.
 * All rights reserved.
 * Written by: John Baldwin <jhb@FreeBSD.org>
 *
 * 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. Neither the name of the author nor the names of any co-contributors
 *    may 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.
 *
 *
 * Partly from:
 * $FreeBSD: src/sys/boot/i386/mbr/mbr.s,v 1.7 2004/08/28 08:39:35 yar Exp $
 *
 * Copyright (c) 1999 Robert Nordier
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are freely
 * permitted provided that the above copyright notice and this
 * paragraph and the following disclaimer are duplicated in all
 * such forms.
 *
 * This software is provided "AS IS" and without any express or
 * implied warranties, including, without limitation, the implied
 * warranties of merchantability and fitness for a particular
 * purpose.
 *
 *
 * "Hybridisation" and modifications for booting Haiku by Andre' Braga
 * (me@andrebraga.com), with valuable input from Jean-Loïc Charroud
 * (jcharroud@free.fr). The modifications contained herein are released into
 * the Public Domain.
 *
 *
 * 		A 432 bytes MBR IPL (Initial Program Loader) that looks for the UUID of
 * a Haiku Boot GUID partition and boots it, falling back to MBR partitions if
 * said UUID isn't found or if the (primary) GPT is corrupted or non-existent.
 * 		Its usefulness is in being a versatile, "universal" IPL that supports
 * both partitioning styles, allowing it to be used transparently and even
 * facilitating the conversion between partitioning styles, should the need
 * for more partitions or volumes over 2TiB arise (for instance when cloning
 * an older disk to a newer, more capacious one).
 * 		It also paves the way for Haiku to create and support booting from
 * multiple volumes larger than 2TiB, which we're in the very privileged
 * position of enjoying efficiently in the near future due to BFS. Another use
 * case is taking a disk from a Intel EFI machine, plugging it on a BIOS
 * machine and boot just fine; and vice-versa.
 * 		As mentioned, if there are valid partitions defined in the MBR, and the
 * primary GPT becomes corrupt, it can fall back to loading the MBR partition
 * with the active flag set, if one is defined.
 * 		Currently there's no provision for falling back to the GPT copy that
 * lives in the end of the disk, due to the 512 bytes constraint; supporting
 * this is unlikely given that the code is packed tight. An alternative would be
 * disabling support for booting from MBR using BIOS calls other than Int13h
 * function 42h, "Extended Read From Disk" (i.e., LBA mode). It's unlikely that
 * any machine that Haiku supports won't have this BIOS function, but having an
 * "universal" IPL should be quite useful to, say, people using Haiku to
 * rewrite a corrupt MBR on another disk using the excellent DiskProbe.
 * 		The number of sectors loaded depends on the boot style. Booting from a
 * MBR partition assumes that the Partition Boot Record is one sector long,
 * whereas booting from a GPT partition assumes a partition exclusive for a
 * system loader and will either copy its entirety into memory starting from
 * address 0x7c00, or will copy up to circa 545KiB, whichever is smaller. Thus,
 * it remains compatible with the FreeBSD gptloader and should work for loading
 * Bootman from an exclusive Haiku boot manager partition as well.
 * 		It should be easy to adjust the UUID signature as needed. It lives at
 * offset 0x1a0 (416), leaving plenty of space before the 32-bit disk signature
 * at offset 0x1b8 (440), so compatibility with Microsoft Windows and other OSs
 * is maintained.
 */

			.set LOAD,0x7c00
			.set EXEC,0x600
			.set MAGIC,0xaa55
			.set HANDSHAKE,0x55aa
			.set SECSIZE,0x200

			/* data offsets */
			.set UUID,0x1a0
			.set DISKSIG,0x1b8
			.set PT_OFF,0x1be

			.set GPTSTACK,EXEC+SECSIZE*4-8	/* Stack address */
			.set LBABUF,GPTSTACK			/* LBA address pointer buffer, */
											/*  8 bytes long, after stack */

			.set GPT_ADDR,LBABUF+8			/* GPT header address */
			.set GPT_SIG,0					/* Signature offset from LBA 1 */
			.set GPT_SIG_0,0x20494645		/* "EFI ", bswapped */
			.set GPT_SIG_1,0x54524150		/* "PART", bswapped */
			.set GPT_MYLBA,24				/* Offs of curr header copy addr */
			.set GPT_PART_LBA,72			/* Offs of partitions start LBA */
			.set GPT_NPART,80				/* Offs to number of partitions */
			.set GPT_PART_SIZE,84			/* Offs to size of partition */
			.set PART_ADDR,GPT_ADDR+SECSIZE	/* GPT partition array addr. */
			.set PART_TYPE,0
			.set PART_START_LBA,32			/* Offs to 1st LBA on part entry */
			.set PART_END_LBA,40			/* Offs to last LBA */

			.set NHRDRV,0x475				/* Number of hard drives */

			.globl start					/* Entry point */
			.code16

/*
 * Setup the segment registers for flat addressing and setup the stack.
 */
start:		cli								/* Clear interrupts before relocation */

			xorw %ax,%ax					/* Zero */
			movw %ax,%es					/* Address */
			movw %ax,%ds					/*  data */

			movw %ax,%ss					/* Set up */
			movw $GPTSTACK,%sp				/*  stack */

			std								/* String ops set to decrement */
			movw $LOAD,%si					/* We'll clear working memory starting */
			leaw -1(%si),%di				/*  from $LOAD-1 and stopping at EXEC. */
			movw $(LOAD-EXEC-1),%cx			/*  In the end we have %si pointing */
			rep stosb						/*  at LOAD and %di at EXEC. */


/*
 * Relocate ourself to a lower address so that we have more room to load
 * other sectors.
 */
reloc:		cld								/* String ops set to increment */
			movw $SECSIZE,%cx				/* Now we walk forward and relocate. */
			rep	movsb						/*  Tricky, but works great! */

/*
 * Jump to the relocated code.
 */
			jmp $0,$main					/* Absolute address (far) jump */

/*
 * Will land here; we're now at %cs = 0x0000 and %ip a little above 0x0600
 */
main:		sti								/* Re-enable interrupts */

#ifdef VALIDATE_DRV
/*
 * Validate drive number in %dl. Certain BIOSes might not like it.
 */
validate_drv:
			cmpb $0x80,%dl					/* Drive valid? (>= 0x80) */
			jb validate_drv.1				/* No */
			movb NHRDRV,%dh					/* Calculate the highest */
			addb $0x80,%dh					/*  drive number available */
			cmpb %dh,%dl					/* Within range? */
			jb test_extensions				/* Yes, proceed */
validate_drv.1:
			movb $0x80,%dl					/* Else, assume drive 0x80 */
#endif

/*
 * Test if BIOS supports Int13h extensions. If so, will try GPT scheme first.
 * Else, sets flag (%dh = 1) and goes straight to MBR code.
 * (%dl still contains the drive number from BIOS bootstrap)
 */
test_extensions:
			movb $0,%dh						/* We'll test for EDD extensions. */
											/*  LBA read (Int13,42) uses only */
											/*  %dl to get drive number and if */
											/*  we must fall back to CHS read */
											/*  (Int13,02), %dh receives head */
											/*  number, so it's clear to use */
											/*  %dh to hold a "use CHS" flag */

			movw $HANDSHAKE,%bx				/* EDD extensions magic number */
			movb $0x41,%ah					/* BIOS:	EDD extensions */
			int $0x13						/*  present? */
			jc set_chs						/* No, fall back to CHS read */
test_magic:
			cmpw $MAGIC,%bx					/* Magic ok? */
			jne set_chs						/* No, fall back to CHS read */
test_packet:
			testb $0x1,%cl					/* Packet mode present? */
			jnz load_gpt_hdr				/* Yes! */
set_chs:
			movb $1,%dh						/* read_chs overwrites this, and */
											/*  Int13,42 only uses %dl, so */
											/*  it's clear to use %dh as flag */
			jmp try_mbr


/*
 * If we reached here, drive is valid, LBA reads are available, will try GPT.
 * Load the primary GPT header from LBA 1 and verify signature.
 */
load_gpt_hdr:
			movw $GPT_ADDR,%bx
			movw $LBABUF,%si				/* Will load LBA sector 1 from disk */
			movb $1,(%si)					/*  (64-bit value! Memory was zeroed so */
											/*  it's OK to write only the LSB) */
			call read
			cmpl $GPT_SIG_0,GPT_ADDR+GPT_SIG
			jnz try_mbr						/* If invalid GPT header */
			cmpl $GPT_SIG_1,GPT_ADDR+GPT_SIG+4
			jnz try_mbr						/* Fluke :( Try MBR now */

/*
 * GPT is valid. Load a partition table sector from disk and look for a
 * partition matching the UUID found in boot_uuid.
 */
load_part:
			movw $GPT_ADDR+GPT_PART_LBA,%si
			movw $PART_ADDR,%bx
			call read
scan:
			movw %bx,%si					/* Compare partition UUID */
			movw $boot_uuid,%di				/*  with Haiku boot UUID */
			movb $0x10,%cl					/*  (16 bytes) */
			repe cmpsb
			jnz next_part					/* Didn't match, next partition */

/*
 * We found a partition. Load it into RAM starting at 0x7c00.
 */
			movw %bx,%di					/* Save partition pointer in %di */
			leaw PART_START_LBA(%di),%si
			movw $LOAD/16,%bx
			movw %bx,%es
			xorw %bx,%bx
load_bootcode:
			push %si						/* Save %si */
			call read
			pop %si							/* Restore */
			movl PART_END_LBA(%di),%eax		/* See if this was the last LBA */
			cmpl (%si),%eax
			jnz next_boot_lba
			movl PART_END_LBA+4(%di),%eax
			cmpl 4(%si),%eax
			jnz next_boot_lba
			jmp start_loader				/* Jump to boot code */

next_boot_lba:
			incl (%si)						/* Next LBA */
			adcl $0,4(%si)
			mov %es,%ax						/* Adjust segment for next */
			addw $SECSIZE/16,%ax			/*  sector */
			cmp $0x9000,%ax					/* Don't load past 0x90000, */
			jae start_loader				/*  545k should be enough for */
			mov %ax,%es						/*  any boot code. :) */
			jmp load_bootcode

/*
 * Move to the next partition. If we walk off the end of the sector, load
 * the next sector.
 */
next_part:
			decl GPT_ADDR+GPT_NPART			/* Was this the last partition? */
			jz try_mbr						/* UUID boot signature not found */
			movw GPT_ADDR+GPT_PART_SIZE,%ax
			addw %ax,%bx					/* Next partition */
			cmpw $PART_ADDR+0x200,%bx		/* Still in sector? */
			jb scan
			incl GPT_ADDR+GPT_PART_LBA		/* Next sector */
			adcl $0,GPT_ADDR+GPT_PART_LBA+4
			jmp load_part

/*
 * If loading boot sectors from a GPT partition fails, try booting a MBR part.
 * Reset stack/segment. Could have been tainted by the GPT loading code.
 */
try_mbr:
			xorw %ax,%ax					/* Zero */
			movw %ax,%es					/*  extra segment */
			movw $LOAD,%sp					/* Reset stack */

			xorw %si,%si					/* Will point to active partition */
			movw $(EXEC+PT_OFF),%bx			/* Point to partition table start */
			movw $0x4,%cx					/* Tested entries counter (4 total) */
read_mbr_entry:
			cmpb %ch,(%bx)					/* Null entry? (%ch just zeroed) */
			je next_mbr_entry				/* Yes */
			jg err_part_table				/* If 0x1..0x7f */
			testw %si,%si					/* Active already found? */
			jnz err_part_table				/* Yes */
			movw %bx,%si					/* Point to active */
next_mbr_entry:
			addb $0x10,%bl					/* Till */
			loop read_mbr_entry				/*  done */
			testw %si,%si					/* Active found? */
			jnz read_bootsect				/* Yes, read OS loader */
try_diskless:
			int $0x18						/* Else, BIOS: Diskless boot */


/*
 * Ok, now that we have a valid drive and partition entry, load either CHS
 * or LBA from the partition entry and read the boot sector from the partition.
 */
read_bootsect:
			movw %sp,%bx					/* Write addr. (%sp points to LOAD) */
			pushw %si						/* Points at active part. entry; */
											/*  save, else 'read' will trash it */
test_flag:
			cmpb $1,%dh						/* Test flag set by set_chs above */
			jz read_chs						/* CHS read if set */
read_lba:
			addw $0x8,%si					/* Start LBA of partition, 32-bit */
			movw $LBABUF,%di				/* So far either QWORD 1 or 0, so */
			movsl							/*  more significant bytes are all 0 */
			xchg %di,%si					/*  Copy to buffer and swap pointers */
			subw $0x4,%si					/* Adjust back to start of buffer */
			call read
			jmp finished_read				/* Skip the CHS setup */
read_chs:
			movb 0x1(%si),%dh				/* Load head */
			movw 0x2(%si),%cx				/* Load cylinder:sector */
			movb $2,%al						/* Read two sectors */
			movb $2,%ah						/* BIOS: Read sectors from disk */
			int $0x13						/* Call the BIOS */
finished_read:
			jc err_reading					/* If error */


/*
 * Now that we've loaded the bootstrap, check for the 0xaa55 signature. If it
 * is present, execute the bootstrap we just loaded.
 */
			popw %si						/* Restore %si (active part entry) */
			movb %dl,(%si)					/* Patch part record with drive num */
			cmpw $MAGIC,0x1fe(%bx)			/* Bootable? */
			jne err_noboot					/* No, error out. */
											/*  Else, start loader */
start_loader:
			xorw %ax,%ax
			movw %ax,%es					/* Reset %es to zero */
			jmp $0,$LOAD					/* Jump to boot code */


/* Auxiliary functions */


/*
 * Load a sector (64-bit LBA at %si) from disk %dl into %es:%bx by creating
 * a EDD packet on the stack and passing it to the BIOS. Trashes %ax and %si.
 */
read:
			pushl 0x4(%si)					/* Set the LBA */
			pushl 0x0(%si)					/*  address */
			pushw %es						/* Set the address of */
			pushw %bx						/*  the transfer buffer */
			pushw $0x1						/* Read 1 sector */
			pushw $0x10						/* Packet length */
			movw %sp,%si					/* Packet pointer */
			movw $0x4200,%ax				/* BIOS:	LBA Read from disk */
			int $0x13						/* Call the BIOS */
			add $0x10,%sp					/* Restore stack */
			jc err_reading					/* If error */
			ret


/*
 * Output an ASCIZ string pointed at by %si to the console via the BIOS.
 */
putstr.0:
			movw $0x7,%bx					/* Page:attribute */
			movb $0xe,%ah					/* BIOS: Display */
			int $0x10						/*  character */
putstr:
			lodsb							/* Get character */
			testb %al,%al					/* End of string? */
			jnz putstr.0					/* No */
			ret


/*
 * Various error message entry points.
 */
err_part_table:
			movw $msg_badtable,%si			/* "Bad Part. Table!" */
			call putstr
			jmp halt


err_reading:
			movw $msg_ioerror,%si			/* "Read Error!" */
			call putstr
			jmp halt


err_noboot:
			movw $msg_noloader,%si			/* "No Sys Loader!" */
			call putstr
			/* fall-through to halt */


halt:
			cli
			hlt
			jmp halt


/* Data section */


#ifdef VALIDATE_DRV
/* Messages must be shortened so the code fits 440 bytes */
msg_badtable:	.asciz "BadPTbl!"
msg_ioerror:	.asciz "IOErr!"
msg_noloader:	.asciz "NoSysLdr!"
#else
msg_badtable:	.asciz "Bad Part. Table!"
msg_ioerror:	.asciz "Read Error!"
msg_noloader:	.asciz "No Sys Loader!"
#endif

/* Boot partition UUID signature */
			.org UUID,0x0					/* Zero-pad up to UUID offset */

boot_uuid:
			.long 0x42465331				/* 'BFS1' (formally, UUID time-low) */
			.word 0x3ba3					/* UUID time-mid */
			.word 0x10f1					/* UUID time-high & version (v1) */
			.byte 0x80						/* UUID DCE 1.1 variant */
			.byte 0x2a						/* '*' (formally, UUID clock-seq-low) */
			.byte 0x48						/* 'H' */
			.byte 0x61						/* 'a' */
			.byte 0x69						/* 'i' */
			.byte 0x6b						/* 'k' */
			.byte 0x75						/* 'u' */
			.byte 0x21						/* '!' */

#ifndef MBR_CODE_ONLY
/* Disk signature */
			.org DISKSIG,0x0				/* Zero-pad up to signature offset */

sig:
			.long 0							/* OS Disk Signature */
			.word 0							/* "Unknown" in PMBR */

/* Partition table */
			.org PT_OFF,0x0					/* Won't pad, just documenting */

partbl:
			.fill 0x10,0x4,0x0				/* Partition table */
			.word MAGIC						/* Magic number */
#endif