If this code originated from a hard drive and the master boot code loaded this code, then the partition table entry that corresponds to the booted partition is passed in es:si.

While these 3 variables take up 8 bytes, only 6 bytes are pushed onto the stack.  lowsec (lines 2043 and 2044) and device (line 2046) are pushed, but what about secpcyl ?  When a value is finally stored in secpcyl (line 2110), the first 2 bytes of the bootblock code are overwritten - the first xor ax, ax instruction (line 2036) is overwritten.  This doesn't matter since the code never jumps back to the beginning.  This saves not only the 2 bytes needed for the variable but also the memory required for a push instruction.

mov ax, #0

is slower and is 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 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 (0x7C00 - see line 2019) is moved to the register rather than the contents of the memory location LOADOFF.

An instruction prepended by

The les instruction loads the register specified by the first operand (in this case ax) with an offset address and es with a segment register.  The value at es:LOWSEC(si) is loaded in ax and the value at es:LOWSEC+2(si) is loaded in es.  The eseg prefix is needed since es:LOWSEC(si), not ds:LOWSEC(si),  is the memory address that holds the lowest sector (see comment for line 2017). Note that the es and ax registers are overwritten by the eseg les ax, LOWSEC(si) instruction. For this reason, the es and ax registers were pushed onto the stack on lines 2049-2050.

Grinding through this code isn't fun.  Everything until line 2141 sets things up for the int 0x13 bios call.

cmp is a subtraction that only affects the flag register. jbe (line 2137) jumps if the first operand in cmp is below or equal to the second operand.

What's done here is somewhat tricky.  If 1 is added to bh, it is equivalent to adding 256 to bx.  If 2 is added to bh, it is equivalent to adding 512 to bx (remember that 1 sector = 512 bytes).

If the secondary boot has either a short header or a long header, the instruction at BOOTSEG:BOOTOFF jumps to the boot address.

These are the same parameters that were passed to the bootstrap (this code).

Keep three things in mind: 1) BOOTSEG (defined in this file) and LOADSEG (defined in boothead.s) are both defined as 0x1000. 2) Adding 2 to the segment register adds 32 to the address formed by the segment:offset registers and adding 3 to the segment adds 48 to the address formed by the segment:offset registers. 3) boot is the offset from the end of the header.

It helps to look at an ascii chart before trying to understand the following code.  The ascii string at errno (line 2196) is modified.  The *second* digit is first incremented to reflect (in ascii representation) the value in the left-most 4 bits of ah.  If the right-most 4 bits of ah are nonzero, the code loops back to prnum and increments the *first* digit to reflect (in ascii representation) the value in the right-most 4 bits of ah .

This code and the the secondary boot addresses have to fit into a single block (hence the name "boot block").  1 block = 2 sectors = 2 * 512 bytes = 1024 bytes.  If there is space for a 66K secondary boot when the secondary boot is fragmented (meaning that no 2 sectors are consecutive) then that means that there is space for (66K * 2 sectors/K=) 132 (count, sector address) entries.  Each entry takes up 4 bytes so the total space taken up by the entries is 528 bytes.  So the actual code (everything but the entries) takes up the remaining (1024-528=) 496 bytes.