Before going any further, read the first 4 paragraphs in section 2.5.2 and read the entire 2.6.5 section of Operating Systems by Andrew Tanenbaum and Albert Woodhull.  Haven't bought the book?  You won't be able to get through this web site without buying the book - so buy the book.  I won't be going over things that the book already discusses.

The first instruction of this code (the jmp instruction on line 1052) is loaded at an offset of 0x7C00 into memory.

The figure below shows the memory layout.  This code is initially loaded at memory address LOADOFF (0x7C00) but then copied to memory address BUFFER (0x0600).  The code jmp 's there to make room for the next block we'll load, which will either be another master boot block or a bootstrap (as found in bootblock.s).

Although you won't find it explicitly in this code or in bootblock.s, both the master boot blocks and boot blocks on disk have the magic number at an offset of 510.  How'd they get there?  The installboot utility is responsible for patching in the values.  Go to this link  for the master boot and this link  for the boot block.  These links show where SIGNATURE (0xAA55, the magic number) is patched into the master boot blocks and boot blocks at MAGIC (which is the same value as installboot's SIGPOS).  Don't spend too much time studying the installboot.c code.  It is only important that you begin to understand the role that the installboot utility plays.

If anyone sees a point to the extra .defines (begtext, begdata, etc.), please submit a comment to the site which will be displayed below.

(The bss section holds uninitialized global variables; the bss section is discussed later.)

Why does data immediately follow the first instruction?  Directly after the first instruction is a convenient place to stick the data.  You'll see this trick elsewhere also.  Look at line 06051 in the book.  This is the first instruction of the minix kernel.

mov ax, #0

is slower and takes up 3 bytes compared with xor's 2 bytes.

One thing that initially confuses people with assembler is the order of the operands.  The syntax of the mov instruction is:

mov destination, source

This seems a little strange to me (probably because this is not consistent with the syntax of the Unix cp command) but most assemblers use this syntax. 

The interrupts are disabled with the cli (clear interrupts) instruction and reenabled with the sti (set interrupts) instruction.

What's the pound sign (#) all about?  The pound sign indicates that the value of LOADOFF rather than the contents of the memory location LOADOFF is mov'ed into the register.

BUFFER+devhd is the string's beginning offset address in memory.

 cmp is a subtraction that only affects the flag register.  In this way, cmp is similar to test.  The following jae jumps if the first operand in cmp is above or equal to the second operand.

A partition table entry with the non-zero bootind field indicates a bootable partition.

If the partition is 0, 5, 10, or 15, then the master boot record of the appropriate hard drive is loaded and executed (line 1114).  If the partition is not 0, 5, 10, or 15, the partition table from the master boot record that has just been loaded is sorted (line 1121) and the first sector from the desired partition is loaded (line 1146).  This sector either has another master boot record (in which case there are subpartitions on the partition that was chosen) or a bootstrap that will load the boot monitor from that partition.

Here's the structure of the partition table again:

Suppose a hard drive has a partition table with (lowsec, sysind) pairs (1,1), (1000,1), (200,0), and (350,1).  (Remember that a sysind value of 0 indicates that the partition is unused.)  This is the order of the partition table entries in the master boot record on the hard drive.  After the partition entries are sorted in memory, the order is (1,1), (350,1), (1000,1), and (200,0).  All partitions in use are sorted by their lowsec values and all unused partitions are at the end.  If the second partition is specified (by hitting the ALT key), the partition with a lowsec of 350, the partition with the second lowest lowsec value currently in use, is booted.

Keep in mind that the partition table entries are sorted in memory but the partition table on the hard drive is not affected.

This is the first time that we've seen the OFFSET(register) notation.  It's also the first time that the lea instruction has been used.

OFFSET(register) is the value register + OFFSET.  In this case, register is si and OFFSET is PENTRYSIZE.

The lea (load effective address) instruction loads this value into di.  (mov di, PENTRYSIZE(si) would move the contents of memory address PENTRYSIZE+si into di.)

Notice that the result from sbb overwrites the result from sub (they both place their results in bx).  We don't care since we are only concerned whether the result is negative or positive.  If the result is negative, the carry flag will be set and the jnb instruction will jump to order.

The partition entries are searched for the active partition.  The active partition is the partition that is booted by default.  The 7th bit (0-indexed) in the bootind entry is set for the active partition (see line 1155).

testb sets the sign flag if the value in dl is negative.  When is the value negative?  In two's complement notation, if the rightmost bit is a 1 then the value is negative.  So for a one byte value, anything greater than 0x80 is negative.  Remember that 0x00 and 0x01 correspond to the first and second floppy drives and 0x80, 0x81, 0x82, and 0x83 correspond to hard drives 1-4.

The jge instruction jumps to nextdisk if the value in dl is positive.  In other words, the floppy drives are skipped.

There's a little bit of a trick here.  Since load loads the first sector for the drive specified by dl and the partition pointed to by si , the lowsec value of the entry that si currently points to is overwritten with a 0.  Is that a problem?  No, since in this code the partition table is never written back to disk.

Let's work through an example.  Assume that we want to load the 5232nd sector of a hard drive with 2000 cylinders, 16 heads, and 25 sectors/track.  512 bytes/sector * 25 sectors/track * 16 tracks/cylinder * 2000 cylinders  = 400MB hard drive.  The int 0x13 , ah =0x08 call returns 25 in cl and 15 in dh for this hard drive.

1 is added to dh at line 1210 to move to a 1-origin.

At this point, the absolute sector number 5232 has been broken up into a cylinder number (dx =13), a track number (al =1) and a sector number (ah =7, 0-origin).  Lines 1218 through 1229 move and shift the bits around to the positions that int 0x13 , ah =0x02 (line 1230) expects.  I'll leave it to you to finish the example.

The next few lines are tricky.  At this point, ax holds the value at the memory address that si initially pointed to (before the increment).  si initially pointed to the address after the print instruction.  Look at line 1081-1082 again.  The value at the address after the print instruction is another address, BUFFER+devhd .  So ax holds the value BUFFER+devhd.  On line 1259, this value is loaded into si so that the following lodsb instruction loads the first character of the devhd (line 1271) string.

.ascii    "go"
.data2    0x676F

(The ascii representation of 'g' is 0x67 and the ascii representation of 'o' is 0x6F.)

Since devhd doesn't have a terminating '\0 ', how does print (line 1256) know when to stop?  The answer is that it stops when it runs into the first '\0 ' from choice .  Note that the strings are in consecutive memory addresses.  The last character of the devhd string and the first character of the choice string are consecutive memory addresses.

Won't print return immediately after the first character when printing choice ?  The answer is no.  The value of the first character is modified (line 1085) before calling print (line 1094).

"\r\n " is a return.  '\r ' moves the cursor to the leftmost position and '\n ' advances the cursor to the next line.  '\b ' is the bell.