pintos-os.org Git - pintos-anon/blob - src/threads/init.c

   1 #include "init.h"
   2 #include <stdint.h>
   3 #include <stddef.h>
   4 #include <limits.h>
   5 #include "debug.h"
   6 #include "interrupt.h"
   7 #include "io.h"
   8 #include "kbd.h"
   9 #include "lib.h"
  10 #include "malloc.h"
  11 #include "mmu.h"
  12 #include "paging.h"
  13 #include "palloc.h"
  14 #include "random.h"
  15 #include "serial.h"
  16 #include "thread.h"
  17 #include "timer.h"
  18 #include "vga.h"
  19 #ifdef FILESYS
  20 #include "filesys.h"
  21 #include "disk.h"
  22 #endif
  23
  24 /* Size of kernel static code and data, in 4 kB pages. */
  25 size_t kernel_pages;
  26
  27 /* Amount of physical memory, in 4 kB pages. */
  28 size_t ram_pages;
  29
  30 static void gdt_init (void);
  31 void power_off (void);
  32
  33 static void
  34 main_thread (void *aux UNUSED)
  35 {
  36   struct disk *hda;
  37   disk_init ();
  38   hda = disk_get (0);
  39   if (hda != NULL)
  40     {
  41       char buf[DISK_SECTOR_SIZE];
  42       disk_read (hda, 0, buf);
  43       hex_dump (buf, sizeof buf);
  44     }
  45   else
  46     printk ("no hda\n");
  47   thread_execute ("a.out");
  48 }
  49
  50 int
  51 main (void)
  52 {
  53   extern char _text, _end, __bss_start;
  54   struct thread *t;
  55
  56   /* Clear out the BSS segment. */
  57   memset (&__bss_start, 0, &_end - &__bss_start);
  58
  59   /* Initialize components needed by printk() very early. */
  60   vga_init ();
  61   serial_init ();
  62   printk ("Booting cnachos86...\n");
  63
  64   /* Calculate how much RAM the kernel uses, and find out from
  65      the bootloader how much RAM this machine has. */
  66   kernel_pages = (&_end - &_text + 4095) / 4096;
  67   ram_pages = *(uint32_t *) (0x7e00 - 6);
  68   printk ("ram: detected %'d kB.\n", ram_pages * 4);
  69
  70   /* Memory from the end of the kernel through the end of memory
  71      is free.  Give it to the page allocator. */
  72   palloc_init ((void *) (KERN_BASE + kernel_pages * PGSIZE),
  73                (void *) (PHYS_BASE + ram_pages * PGSIZE));
  74   paging_init ();
  75   gdt_init ();
  76
  77   malloc_init ();
  78   random_init ();
  79
  80   intr_init ();
  81   timer_init ();
  82   kbd_init ();
  83
  84 #ifdef FILESYS
  85   filesys_init (false);
  86 #endif
  87
  88   thread_init ();
  89
  90   t = thread_create ("main", main_thread, NULL);
  91   thread_start (t);
  92
  93   printk ("Done!\n");
  94   return 0;
  95 }
  96
  97 static uint64_t
  98 make_seg_desc (uint32_t base,
  99                uint32_t limit,
 100                enum seg_system system,
 101                enum seg_type type,
 102                int dpl,
 103                enum seg_granularity granularity)
 104 {
 105   uint32_t e0 = ((limit & 0xffff)             /* Limit 15:0. */
 106                  | (base << 16));             /* Base 15:0. */
 107   uint32_t e1 = (((base >> 16) & 0xff)        /* Base 23:16. */
 108                  | (system << 12)             /* 0=system, 1=code/data. */
 109                  | (type << 8)                /* Segment type. */
 110                  | (dpl << 13)                /* Descriptor privilege. */
 111                  | (1 << 15)                  /* Present. */
 112                  | (limit & 0xf0000)          /* Limit 16:19. */
 113                  | (1 << 22)                  /* 32-bit segment. */
 114                  | (granularity << 23)        /* Byte/page granularity. */
 115                  | (base & 0xff000000));      /* Base 31:24. */
 116   return e0 | ((uint64_t) e1 << 32);
 117 }
 118
 119 static uint64_t
 120 make_code_desc (int dpl)
 121 {
 122   return make_seg_desc (0, 0xfffff, SYS_CODE_DATA, TYPE_CODE | TYPE_READABLE,
 123                         dpl, GRAN_PAGE);
 124 }
 125
 126 static uint64_t
 127 make_data_desc (int dpl)
 128 {
 129   return make_seg_desc (0, 0xfffff, SYS_CODE_DATA, TYPE_WRITABLE,
 130                         dpl, GRAN_PAGE);
 131 }
 132
 133 static uint64_t
 134 make_tss_desc (void *vaddr)
 135 {
 136   return make_seg_desc ((uint32_t) vaddr,
 137                         0x67, SYS_SYSTEM, TYPE_TSS_32_A, 0, GRAN_BYTE);
 138 }
 139
 140 uint64_t gdt[SEL_CNT];
 141
 142 struct tss *tss;
 143
 144 /* Sets up a proper GDT.  The bootstrap loader's GDT didn't
 145    include user-mode selectors or a TSS. */
 146 static void
 147 gdt_init (void)
 148 {
 149   uint64_t gdtr_operand;
 150
 151   /* Our TSS is never used in a call gate or task gate, so only a
 152      few fields of it are ever referenced, and those are the only
 153      ones we initialize. */
 154   tss = palloc_get (PAL_ASSERT | PAL_ZERO);
 155   tss->esp0 = (uint32_t) ptov(0x20000);
 156   tss->ss0 = SEL_KDSEG;
 157   tss->bitmap = 0xdfff;
 158
 159   /* Initialize GDT. */
 160   gdt[SEL_NULL / sizeof *gdt] = 0;
 161   gdt[SEL_KCSEG / sizeof *gdt] = make_code_desc (0);
 162   gdt[SEL_KDSEG / sizeof *gdt] = make_data_desc (0);
 163   gdt[SEL_UCSEG / sizeof *gdt] = make_code_desc (3);
 164   gdt[SEL_UDSEG / sizeof *gdt] = make_data_desc (3);
 165   gdt[SEL_TSS / sizeof *gdt] = make_tss_desc (tss);
 166
 167   /* Load GDTR, TR. */
 168   gdtr_operand = make_dtr_operand (sizeof gdt - 1, gdt);
 169   asm volatile ("lgdt %0" :: "m" (gdtr_operand));
 170   asm volatile ("ltr %w0" :: "r" (SEL_TSS));
 171 }
 172 \f
 173 void
 174 power_off (void)
 175 {
 176   const char s[] = "Shutdown";
 177   const char *p;
 178
 179   printk ("Powering off...\n");
 180   for (p = s; *p != '\0'; p++)
 181     outb (0x8900, *p);
 182   for (;;);
 183 }