1 #include <inc/mmu.h>
 2
 3 # Start the CPU: switch to 32-bit protected mode, jump into C.
 4 # The BIOS loads this code from the first sector of the hard disk into
 5 # memory at physical address 0x7c00 and starts executing in real mode
 6 # with %cs=0 %ip=7c00.
 7
 8 .set PROT_MODE_CSEG, 0x8         # kernel code segment selector
 9 .set PROT_MODE_DSEG, 0x10        # kernel data segment selector
10 .set CR0_PE_ON,      0x1         # protected mode enable flag
11
12 .globl start
13 start:
14   .code16                     # Assemble for 16-bit mode
15   cli                         # Disable interrupts
16   cld                         # String operations increment
17
18   # Set up the important data segment registers (DS, ES, SS).
19   xorw    %ax,%ax             # Segment number zero
20   movw    %ax,%ds             # -> Data Segment
21   movw    %ax,%es             # -> Extra Segment
22   movw    %ax,%ss             # -> Stack Segment
23
24   # Enable A20:
25   #   For backwards compatibility with the earliest PCs, physical
26   #   address line 20 is tied low, so that addresses higher than
27   #   1MB wrap around to zero by default.  This code undoes this.
28 seta20.1:
29   inb     $0x64,%al               # Wait for not busy
30   testb   $0x2,%al
31   jnz     seta20.1
32
33   movb    $0xd1,%al               # 0xd1 -> port 0x64
34   outb    %al,$0x64
35
36 seta20.2:
37   inb     $0x64,%al               # Wait for not busy
38   testb   $0x2,%al
39   jnz     seta20.2
40
41   movb    $0xdf,%al               # 0xdf -> port 0x60
42   outb    %al,$0x60
43
44   # Switch from real to protected mode, using a bootstrap GDT
45   # and segment translation that makes virtual addresses
46   # identical to their physical addresses, so that the
47   # effective memory map does not change during the switch.
48   lgdt    gdtdesc
49   movl    %cr0, %eax
50   orl     $CR0_PE_ON, %eax
51   movl    %eax, %cr0
52
53   # Jump to next instruction, but in 32-bit code segment.
54   # Switches processor into 32-bit mode.
55   ljmp    $PROT_MODE_CSEG, $protcseg
56
57   .code32                     # Assemble for 32-bit mode
58 protcseg:
59   # Set up the protected-mode data segment registers
60   movw    $PROT_MODE_DSEG, %ax    # Our data segment selector
61   movw    %ax, %ds                # -> DS: Data Segment
62   movw    %ax, %es                # -> ES: Extra Segment
63   movw    %ax, %fs                # -> FS
64   movw    %ax, %gs                # -> GS
65   movw    %ax, %ss                # -> SS: Stack Segment
66
67   # Set up the stack pointer and call into C.
68   movl    $start, %esp
69   call bootmain
70
71   # If bootmain returns (it shouldn't), loop.
72 spin:
73   jmp spin
74
75 # Bootstrap GDT
76 .p2align 2                                # force 4 byte alignment
77 gdt:
78   SEG_NULL                # null seg
79   SEG(STA_X|STA_R, 0x0, 0xffffffff)    # code seg
80   SEG(STA_W, 0x0, 0xffffffff)            # data seg
81
82 gdtdesc:
83   .word   0x17                            # sizeof(gdt) - 1
84   .long   gdt                             # address gdt

  1 #include <inc/x86.h>
  2 #include <inc/elf.h>
  3
  4 /**********************************************************************
  5  * This a dirt simple boot loader, whose sole job is to boot
  6  * an ELF kernel image from the first IDE hard disk.
  7  *
  8  * DISK LAYOUT
  9  *  * This program(boot.S and main.c) is the bootloader.  It should
 10  *    be stored in the first sector of the disk.
 11  *
 12  *  * The 2nd sector onward holds the kernel image.
 13  *
 14  *  * The kernel image must be in ELF format.
 15  *
 16  * BOOT UP STEPS
 17  *  * when the CPU boots it loads the BIOS into memory and executes it
 18  *
 19  *  * the BIOS intializes devices, sets of the interrupt routines, and
 20  *    reads the first sector of the boot device(e.g., hard-drive)
 21  *    into memory and jumps to it.
 22  *
 23  *  * Assuming this boot loader is stored in the first sector of the
 24  *    hard-drive, this code takes over...
 25  *
 26  *  * control starts in boot.S -- which sets up protected mode,
 27  *    and a stack so C code then run, then calls bootmain()
 28  *
 29  *  * bootmain() in this file takes over, reads in the kernel and jumps to it.
 30  **********************************************************************/
 31
 32 #define SECTSIZE    512
 33 #define ELFHDR        ((struct Elf *) 0x10000) // scratch space
 34
 35 void readsect(void*, uint32_t);
 36 void readseg(uint32_t, uint32_t, uint32_t);
 37
 38 void
 39 bootmain(void)
 40 {
 41     struct Proghdr *ph, *eph;
 42
 43     // read 1st page off disk
 44     readseg((uint32_t) ELFHDR, SECTSIZE*8, 0);
 45
 46     // is this a valid ELF?
 47     if (ELFHDR->e_magic != ELF_MAGIC)
 48         goto bad;
 49
 50     // load each program segment (ignores ph flags)
 51     ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff);
 52     eph = ph + ELFHDR->e_phnum;
 53     for (; ph < eph; ph++)
 54         // p_pa is the load address of this segment (as well
 55         // as the physical address)
 56         readseg(ph->p_pa, ph->p_memsz, ph->p_offset);
 57
 58     // call the entry point from the ELF header
 59     // note: does not return!
 60     ((void (*)(void)) (ELFHDR->e_entry))();
 61
 62 bad:
 63     outw(0x8A00, 0x8A00);
 64     outw(0x8A00, 0x8E00);
 65     while (1)
 66         /* do nothing */;
 67 }
 68
 69 // Read 'count' bytes at 'offset' from kernel into physical address 'pa'.
 70 // Might copy more than asked
 71 void
 72 readseg(uint32_t pa, uint32_t count, uint32_t offset)
 73 {
 74     uint32_t end_pa;
 75
 76     end_pa = pa + count;
 77
 78     // round down to sector boundary
 79     pa &= ~(SECTSIZE - 1);
 80
 81     // translate from bytes to sectors, and kernel starts at sector 1
 82     offset = (offset / SECTSIZE) + 1;
 83
 84     // If this is too slow, we could read lots of sectors at a time.
 85     // We'd write more to memory than asked, but it doesn't matter --
 86     // we load in increasing order.
 87     while (pa < end_pa) {
 88         // Since we haven't enabled paging yet and we're using
 89         // an identity segment mapping (see boot.S), we can
 90         // use physical addresses directly.  This won't be the
 91         // case once JOS enables the MMU.
 92         readsect((uint8_t*) pa, offset);
 93         pa += SECTSIZE;
 94         offset++;
 95     }
 96 }
 97
 98 void
 99 waitdisk(void)
100 {
101     // wait for disk reaady
102     while ((inb(0x1F7) & 0xC0) != 0x40)
103         /* do nothing */;
104 }
105
106 void
107 readsect(void *dst, uint32_t offset)
108 {
109     // wait for disk to be ready
110     waitdisk();
111
112     outb(0x1F2, 1);        // count = 1
113     outb(0x1F3, offset);
114     outb(0x1F4, offset >> 8);
115     outb(0x1F5, offset >> 16);
116     outb(0x1F6, (offset >> 24) | 0xE0);
117     outb(0x1F7, 0x20);    // cmd 0x20 - read sectors
118
119     // wait for disk to be ready
120     waitdisk();
121
122     // read a sector
123     insl(0x1F0, dst, SECTSIZE/4);
124 }