bootblock.o: file format elf32-i386 Disassembly of section .text: 00007c00 : # with %cs=0 %ip=7c00. .code16 # Assemble for 16-bit mode .globl start start: cli # BIOS enabled interrupts; disable 7c00: fa cli # Zero data segment registers DS, ES, and SS. xorw %ax,%ax # Set %ax to zero 7c01: 31 c0 xor %eax,%eax movw %ax,%ds # -> Data Segment 7c03: 8e d8 mov %eax,%ds movw %ax,%es # -> Extra Segment 7c05: 8e c0 mov %eax,%es movw %ax,%ss # -> Stack Segment 7c07: 8e d0 mov %eax,%ss 00007c09 : # Physical address line A20 is tied to zero so that the first PCs # with 2 MB would run software that assumed 1 MB. Undo that. seta20.1: inb $0x64,%al # Wait for not busy 7c09: e4 64 in $0x64,%al testb $0x2,%al 7c0b: a8 02 test $0x2,%al jnz seta20.1 7c0d: 75 fa jne 7c09 movb $0xd1,%al # 0xd1 -> port 0x64 7c0f: b0 d1 mov $0xd1,%al outb %al,$0x64 7c11: e6 64 out %al,$0x64 00007c13 : seta20.2: inb $0x64,%al # Wait for not busy 7c13: e4 64 in $0x64,%al testb $0x2,%al 7c15: a8 02 test $0x2,%al jnz seta20.2 7c17: 75 fa jne 7c13 movb $0xdf,%al # 0xdf -> port 0x60 7c19: b0 df mov $0xdf,%al outb %al,$0x60 7c1b: e6 60 out %al,$0x60 # Switch from real to protected mode. Use a bootstrap GDT that makes # virtual addresses map directly to physical addresses so that the # effective memory map doesn't change during the transition. lgdt gdtdesc 7c1d: 0f 01 16 lgdtl (%esi) 7c20: 68 7c 0f 20 c0 push $0xc0200f7c movl %cr0, %eax orl $CR0_PE, %eax 7c25: 66 83 c8 01 or $0x1,%ax movl %eax, %cr0 7c29: 0f 22 c0 mov %eax,%cr0 # Complete the transition to 32-bit protected mode by using a long jmp # to reload %cs and %eip. The segment descriptors are set up with no # translation, so that the mapping is still the identity mapping. ljmp $(SEG_KCODE<<3), $start32 7c2c: ea .byte 0xea 7c2d: 31 7c 08 00 xor %edi,0x0(%eax,%ecx,1) 00007c31 : .code32 # Tell assembler to generate 32-bit code now. start32: # Set up the protected-mode data segment registers movw $(SEG_KDATA<<3), %ax # Our data segment selector 7c31: 66 b8 10 00 mov $0x10,%ax movw %ax, %ds # -> DS: Data Segment 7c35: 8e d8 mov %eax,%ds movw %ax, %es # -> ES: Extra Segment 7c37: 8e c0 mov %eax,%es movw %ax, %ss # -> SS: Stack Segment 7c39: 8e d0 mov %eax,%ss movw $0, %ax # Zero segments not ready for use 7c3b: 66 b8 00 00 mov $0x0,%ax movw %ax, %fs # -> FS 7c3f: 8e e0 mov %eax,%fs movw %ax, %gs # -> GS 7c41: 8e e8 mov %eax,%gs # Set up the stack pointer and call into C. movl $start, %esp 7c43: bc 00 7c 00 00 mov $0x7c00,%esp call bootmain 7c48: e8 e0 00 00 00 call 7d2d 00007c4d : # If bootmain returns (it shouldn't), loop. spin: jmp spin 7c4d: eb fe jmp 7c4d 7c4f: 90 nop 00007c50 : ... 7c58: ff (bad) 7c59: ff 00 incl (%eax) 7c5b: 00 00 add %al,(%eax) 7c5d: 9a cf 00 ff ff 00 00 lcall $0x0,$0xffff00cf 7c64: 00 .byte 0x0 7c65: 92 xchg %eax,%edx 7c66: cf iret ... 00007c68 : 7c68: 17 pop %ss 7c69: 00 50 7c add %dl,0x7c(%eax) ... 00007c6e : // Routines to let C code use special x86 instructions. static inline uchar inb(ushort port) { uchar data; asm volatile ("in %1,%0" : "=a" (data) : "d" (port)); 7c6e: ba f7 01 00 00 mov $0x1f7,%edx 7c73: ec in (%dx),%al entry(); } void waitdisk(void) { // Wait for disk ready. while ((inb(0x1F7) & 0xC0) != 0x40) { 7c74: 83 e0 c0 and $0xffffffc0,%eax 7c77: 3c 40 cmp $0x40,%al 7c79: 75 f8 jne 7c73 ; } } 7c7b: c3 ret 00007c7c : // Read a single sector at offset into dst. void readsect(void *dst, uint offset) { 7c7c: 55 push %ebp 7c7d: 89 e5 mov %esp,%ebp 7c7f: 57 push %edi 7c80: 53 push %ebx 7c81: 8b 5d 0c mov 0xc(%ebp),%ebx // Issue command. waitdisk(); 7c84: e8 e5 ff ff ff call 7c6e "d" (port), "0" (addr), "1" (cnt) : "memory", "cc"); } static inline void outb(ushort port, uchar data) { asm volatile ("out %0,%1" : : "a" (data), "d" (port)); 7c89: b8 01 00 00 00 mov $0x1,%eax 7c8e: ba f2 01 00 00 mov $0x1f2,%edx 7c93: ee out %al,(%dx) 7c94: ba f3 01 00 00 mov $0x1f3,%edx 7c99: 89 d8 mov %ebx,%eax 7c9b: ee out %al,(%dx) outb(0x1F2, 1); // count = 1 outb(0x1F3, offset); outb(0x1F4, offset >> 8); 7c9c: 89 d8 mov %ebx,%eax 7c9e: c1 e8 08 shr $0x8,%eax 7ca1: ba f4 01 00 00 mov $0x1f4,%edx 7ca6: ee out %al,(%dx) outb(0x1F5, offset >> 16); 7ca7: 89 d8 mov %ebx,%eax 7ca9: c1 e8 10 shr $0x10,%eax 7cac: ba f5 01 00 00 mov $0x1f5,%edx 7cb1: ee out %al,(%dx) outb(0x1F6, (offset >> 24) | 0xE0); 7cb2: 89 d8 mov %ebx,%eax 7cb4: c1 e8 18 shr $0x18,%eax 7cb7: 83 c8 e0 or $0xffffffe0,%eax 7cba: ba f6 01 00 00 mov $0x1f6,%edx 7cbf: ee out %al,(%dx) 7cc0: b8 20 00 00 00 mov $0x20,%eax 7cc5: ba f7 01 00 00 mov $0x1f7,%edx 7cca: ee out %al,(%dx) outb(0x1F7, 0x20); // cmd 0x20 - read sectors // Read data. waitdisk(); 7ccb: e8 9e ff ff ff call 7c6e asm volatile ("cld; rep insl" : 7cd0: 8b 7d 08 mov 0x8(%ebp),%edi 7cd3: b9 80 00 00 00 mov $0x80,%ecx 7cd8: ba f0 01 00 00 mov $0x1f0,%edx 7cdd: fc cld 7cde: f3 6d rep insl (%dx),%es:(%edi) insl(0x1F0, dst, SECTSIZE / 4); } 7ce0: 5b pop %ebx 7ce1: 5f pop %edi 7ce2: 5d pop %ebp 7ce3: c3 ret 00007ce4 : // Read 'count' bytes at 'offset' from kernel into physical address 'pa'. // Might copy more than asked. void readseg(uchar* pa, uint count, uint offset) { 7ce4: 55 push %ebp 7ce5: 89 e5 mov %esp,%ebp 7ce7: 57 push %edi 7ce8: 56 push %esi 7ce9: 53 push %ebx 7cea: 83 ec 0c sub $0xc,%esp 7ced: 8b 5d 08 mov 0x8(%ebp),%ebx 7cf0: 8b 75 10 mov 0x10(%ebp),%esi uchar* epa; epa = pa + count; 7cf3: 89 df mov %ebx,%edi 7cf5: 03 7d 0c add 0xc(%ebp),%edi // Round down to sector boundary. pa -= offset % SECTSIZE; 7cf8: 89 f0 mov %esi,%eax 7cfa: 25 ff 01 00 00 and $0x1ff,%eax 7cff: 29 c3 sub %eax,%ebx // Translate from bytes to sectors; kernel starts at sector 1. offset = (offset / SECTSIZE) + 1; 7d01: c1 ee 09 shr $0x9,%esi 7d04: 83 c6 01 add $0x1,%esi // If this is too slow, we could read lots of sectors at a time. // We'd write more to memory than asked, but it doesn't matter -- // we load in increasing order. for (; pa < epa; pa += SECTSIZE, offset++) { 7d07: 39 df cmp %ebx,%edi 7d09: 76 1a jbe 7d25 readsect(pa, offset); 7d0b: 83 ec 08 sub $0x8,%esp 7d0e: 56 push %esi 7d0f: 53 push %ebx 7d10: e8 67 ff ff ff call 7c7c for (; pa < epa; pa += SECTSIZE, offset++) { 7d15: 81 c3 00 02 00 00 add $0x200,%ebx 7d1b: 83 c6 01 add $0x1,%esi 7d1e: 83 c4 10 add $0x10,%esp 7d21: 39 df cmp %ebx,%edi 7d23: 77 e6 ja 7d0b } } 7d25: 8d 65 f4 lea -0xc(%ebp),%esp 7d28: 5b pop %ebx 7d29: 5e pop %esi 7d2a: 5f pop %edi 7d2b: 5d pop %ebp 7d2c: c3 ret 00007d2d : void bootmain(void) { 7d2d: 55 push %ebp 7d2e: 89 e5 mov %esp,%ebp 7d30: 57 push %edi 7d31: 56 push %esi 7d32: 53 push %ebx 7d33: 83 ec 10 sub $0x10,%esp readseg((uchar*)elf, 4096, 0); 7d36: 6a 00 push $0x0 7d38: 68 00 10 00 00 push $0x1000 7d3d: 68 00 00 01 00 push $0x10000 7d42: e8 9d ff ff ff call 7ce4 if (elf->magic != ELF_MAGIC) { 7d47: 83 c4 10 add $0x10,%esp 7d4a: 81 3d 00 00 01 00 7f cmpl $0x464c457f,0x10000 7d51: 45 4c 46 7d54: 75 21 jne 7d77 ph = (struct proghdr*)((uchar*)elf + elf->phoff); 7d56: a1 1c 00 01 00 mov 0x1001c,%eax 7d5b: 8d 98 00 00 01 00 lea 0x10000(%eax),%ebx eph = ph + elf->phnum; 7d61: 0f b7 35 2c 00 01 00 movzwl 0x1002c,%esi 7d68: c1 e6 05 shl $0x5,%esi 7d6b: 01 de add %ebx,%esi for (; ph < eph; ph++) { 7d6d: 39 f3 cmp %esi,%ebx 7d6f: 72 15 jb 7d86 entry(); 7d71: ff 15 18 00 01 00 call *0x10018 } 7d77: 8d 65 f4 lea -0xc(%ebp),%esp 7d7a: 5b pop %ebx 7d7b: 5e pop %esi 7d7c: 5f pop %edi 7d7d: 5d pop %ebp 7d7e: c3 ret for (; ph < eph; ph++) { 7d7f: 83 c3 20 add $0x20,%ebx 7d82: 39 de cmp %ebx,%esi 7d84: 76 eb jbe 7d71 pa = (uchar*)ph->paddr; 7d86: 8b 7b 0c mov 0xc(%ebx),%edi readseg(pa, ph->filesz, ph->off); 7d89: 83 ec 04 sub $0x4,%esp 7d8c: ff 73 04 push 0x4(%ebx) 7d8f: ff 73 10 push 0x10(%ebx) 7d92: 57 push %edi 7d93: e8 4c ff ff ff call 7ce4 if (ph->memsz > ph->filesz) { 7d98: 8b 4b 14 mov 0x14(%ebx),%ecx 7d9b: 8b 43 10 mov 0x10(%ebx),%eax 7d9e: 83 c4 10 add $0x10,%esp 7da1: 39 c1 cmp %eax,%ecx 7da3: 76 da jbe 7d7f stosb(pa + ph->filesz, 0, ph->memsz - ph->filesz); 7da5: 01 c7 add %eax,%edi 7da7: 29 c1 sub %eax,%ecx "d" (port), "0" (addr), "1" (cnt) : "cc"); } static inline void stosb(void *addr, int data, int cnt) { asm volatile ("cld; rep stosb" : 7da9: b8 00 00 00 00 mov $0x0,%eax 7dae: fc cld 7daf: f3 aa rep stos %al,%es:(%edi) "=D" (addr), "=c" (cnt) : "0" (addr), "1" (cnt), "a" (data) : "memory", "cc"); } 7db1: eb cc jmp 7d7f