Added buffer to the console
Added hotkeys to switch between console buffers and to return to the home one Added clear screen command Added debug text outputs to the hello command and when loading sh
This commit is contained in:
iDunnoDev
341
bootblock.asm
341
bootblock.asm
@ -1,341 +0,0 @@
|
||||
|
||||
bootblock.o: file format elf32-i386
|
||||
|
||||
|
||||
Disassembly of section .text:
|
||||
|
||||
00007c00 <start>:
|
||||
# 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 <seta20.1>:
|
||||
|
||||
# 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 <seta20.1>
|
||||
|
||||
movb $0xd1,%al # 0xd1 -> port 0x64
|
||||
7c0f: b0 d1 mov $0xd1,%al
|
||||
outb %al,$0x64
|
||||
7c11: e6 64 out %al,$0x64
|
||||
|
||||
00007c13 <seta20.2>:
|
||||
|
||||
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 <seta20.2>
|
||||
|
||||
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 <start32>:
|
||||
|
||||
.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 <bootmain>
|
||||
|
||||
00007c4d <spin>:
|
||||
|
||||
# If bootmain returns (it shouldn't), loop.
|
||||
spin:
|
||||
jmp spin
|
||||
7c4d: eb fe jmp 7c4d <spin>
|
||||
7c4f: 90 nop
|
||||
|
||||
00007c50 <gdt>:
|
||||
...
|
||||
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 <gdtdesc>:
|
||||
7c68: 17 pop %ss
|
||||
7c69: 00 50 7c add %dl,0x7c(%eax)
|
||||
...
|
||||
|
||||
00007c6e <waitdisk>:
|
||||
// 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 <waitdisk+0x5>
|
||||
;
|
||||
}
|
||||
}
|
||||
7c7b: c3 ret
|
||||
|
||||
00007c7c <readsect>:
|
||||
|
||||
// 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 <waitdisk>
|
||||
"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 <waitdisk>
|
||||
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 <readseg>:
|
||||
|
||||
// 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 <readseg+0x41>
|
||||
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 <readsect>
|
||||
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 <readseg+0x27>
|
||||
}
|
||||
}
|
||||
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 <bootmain>:
|
||||
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 <readseg>
|
||||
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 <bootmain+0x4a>
|
||||
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 <bootmain+0x59>
|
||||
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 <bootmain+0x44>
|
||||
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 <readseg>
|
||||
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 <bootmain+0x52>
|
||||
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 <bootmain+0x52>
|
||||
Reference in New Issue
Block a user