src/threads/init.c

   1 #include "threads/init.h"
   2 #include <console.h>
   3 #include <debug.h>
   4 #include <limits.h>
   5 #include <random.h>
   6 #include <stddef.h>
   7 #include <stdint.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include "devices/kbd.h"
  12 #include "devices/input.h"
  13 #include "devices/serial.h"
  14 #include "devices/timer.h"
  15 #include "devices/vga.h"
  16 #include "threads/interrupt.h"
  17 #include "threads/io.h"
  18 #include "threads/loader.h"
  19 #include "threads/malloc.h"
  20 #include "threads/palloc.h"
  21 #include "threads/pte.h"
  22 #include "threads/thread.h"
  23 #ifdef USERPROG
  24 #include "userprog/process.h"
  25 #include "userprog/exception.h"
  26 #include "userprog/gdt.h"
  27 #include "userprog/syscall.h"
  28 #include "userprog/tss.h"
  29 #else
  30 #include "tests/threads/tests.h"
  31 #endif
  32 #ifdef FILESYS
  33 #include "devices/disk.h"
  34 #include "filesys/filesys.h"
  35 #include "filesys/fsutil.h"
  36 #endif
  37
  38 /* Amount of physical memory, in 4 kB pages. */
  39 size_t ram_pages;
  40
  41 /* Page directory with kernel mappings only. */
  42 uint32_t *base_page_dir;
  43
  44 #ifdef FILESYS
  45 /* -f: Format the file system? */
  46 static bool format_filesys;
  47 #endif
  48
  49 /* -q: Power off after kernel tasks complete? */
  50 bool power_off_when_done;
  51
  52 static void ram_init (void);
  53 static void paging_init (void);
  54
  55 static char **read_command_line (void);
  56 static char **parse_options (char **argv);
  57 static void run_actions (char **argv);
  58 static void usage (void);
  59
  60 static void print_stats (void);
  61
  62
  63 int main (void) NO_RETURN;
  64
  65 /* Pintos main program. */
  66 int
  67 main (void)
  68 {
  69   char **argv;
  70
  71   /* Clear BSS and get machine's RAM size. */
  72   ram_init ();
  73
  74   /* Break command line into arguments and parse options. */
  75   argv = read_command_line ();
  76   argv = parse_options (argv);
  77
  78   /* Initialize ourselves as a thread so we can use locks,
  79      then enable console locking. */
  80   thread_init ();
  81   console_init ();
  82
  83   /* Greet user. */
  84   printf ("Pintos booting with %'zu kB RAM...\n", ram_pages * PGSIZE / 1024);
  85
  86   /* Initialize memory system. */
  87   palloc_init ();
  88   malloc_init ();
  89   paging_init ();
  90
  91   /* Segmentation. */
  92 #ifdef USERPROG
  93   tss_init ();
  94   gdt_init ();
  95 #endif
  96
  97   /* Initialize interrupt handlers. */
  98   intr_init ();
  99   timer_init ();
 100   kbd_init ();
 101   input_init ();
 102 #ifdef USERPROG
 103   exception_init ();
 104   syscall_init ();
 105 #endif
 106   /* Start thread scheduler and enable interrupts. */
 107   thread_start ();
 108   serial_init_queue ();
 109   timer_calibrate ();
 110
 111 #ifdef FILESYS
 112   /* Initialize file system. */
 113   disk_init ();
 114   filesys_init (format_filesys);
 115 #endif
 116
 117   printf ("Boot complete.\n");
 118 //  timer_sleep(1000);
 119
 120   /* Run actions specified on kernel command line. */
 121   run_actions (argv);
 122
 123   /* Finish up. */
 124   if (power_off_when_done)
 125     power_off ();
 126   thread_exit ();
 127 }
 128 \f
 129 /* Clear BSS and obtain RAM size from loader. */
 130 static void
 131 ram_init (void)
 132 {
 133   /* The "BSS" is a segment that should be initialized to zeros.
 134      It isn't actually stored on disk or zeroed by the kernel
 135      loader, so we have to zero it ourselves.
 136
 137      The start and end of the BSS segment is recorded by the
 138      linker as _start_bss and _end_bss.  See kernel.lds. */
 139   extern char _start_bss, _end_bss;
 140   memset (&_start_bss, 0, &_end_bss - &_start_bss);
 141
 142   /* Get RAM size from loader.  See loader.S. */
 143   ram_pages = *(uint32_t *) ptov (LOADER_RAM_PGS);
 144 }
 145
 146 /* Populates the base page directory and page table with the
 147    kernel virtual mapping, and then sets up the CPU to use the
 148    new page directory.  Points base_page_dir to the page
 149    directory it creates.
 150
 151    At the time this function is called, the active page table
 152    (set up by loader.S) only maps the first 4 MB of RAM, so we
 153    should not try to use extravagant amounts of memory.
 154    Fortunately, there is no need to do so. */
 155 static void
 156 paging_init (void)
 157 {
 158   uint32_t *pd, *pt;
 159   size_t page;
 160   extern char _start, _end_kernel_text;
 161
 162   pd = base_page_dir = palloc_get_page (PAL_ASSERT | PAL_ZERO);
 163   pt = NULL;
 164   for (page = 0; page < ram_pages; page++)
 165     {
 166       uintptr_t paddr = page * PGSIZE;
 167       char *vaddr = ptov (paddr);
 168       size_t pde_idx = pd_no (vaddr);
 169       size_t pte_idx = pt_no (vaddr);
 170       bool in_kernel_text = &_start <= vaddr && vaddr < &_end_kernel_text;
 171
 172       if (pd[pde_idx] == 0)
 173         {
 174           pt = palloc_get_page (PAL_ASSERT | PAL_ZERO);
 175           pd[pde_idx] = pde_create (pt);
 176         }
 177
 178       pt[pte_idx] = pte_create_kernel (vaddr, !in_kernel_text);
 179     }
 180
 181   /* Store the physical address of the page directory into CR3
 182      aka PDBR (page directory base register).  This activates our
 183      new page tables immediately.  See [IA32-v2a] "MOV--Move
 184      to/from Control Registers" and [IA32-v3a] 3.7.5 "Base Address
 185      of the Page Directory". */
 186   asm volatile ("movl %0, %%cr3" : : "r" (vtop (base_page_dir)));
 187 }
 188
 189 /* Breaks the kernel command line into words and returns them as
 190    an argv-like array. */
 191 static char **
 192 read_command_line (void)
 193 {
 194   static char *argv[LOADER_ARGS_LEN / 2 + 1];
 195   char *p, *end;
 196   int argc;
 197   int i;
 198
 199   argc = *(uint32_t *) ptov (LOADER_ARG_CNT);
 200   p = ptov (LOADER_ARGS);
 201   end = p + LOADER_ARGS_LEN;
 202   for (i = 0; i < argc; i++)
 203     {
 204       if (p >= end)
 205         PANIC ("command line arguments overflow");
 206
 207       argv[i] = p;
 208       p += strnlen (p, end - p) + 1;
 209     }
 210   argv[argc] = NULL;
 211
 212   /* Print kernel command line. */
 213   printf ("Kernel command line:");
 214   for (i = 0; i < argc; i++)
 215     if (strchr (argv[i], ' ') == NULL)
 216       printf (" %s", argv[i]);
 217     else
 218       printf (" '%s'", argv[i]);
 219   printf ("\n");
 220
 221   return argv;
 222 }
 223
 224 /* Parses options in ARGV[]
 225    and returns the first non-option argument. */
 226 static char **
 227 parse_options (char **argv)
 228 {
 229   for (; *argv != NULL && **argv == '-'; argv++)
 230     {
 231       char *save_ptr;
 232       char *name = strtok_r (*argv, "=", &save_ptr);
 233       char *value = strtok_r (NULL, "", &save_ptr);
 234
 235       if (!strcmp (name, "-h"))
 236         usage ();
 237       else if (!strcmp (name, "-q"))
 238         power_off_when_done = true;
 239 #ifdef FILESYS
 240       else if (!strcmp (name, "-f"))
 241         format_filesys = true;
 242 #endif
 243       else if (!strcmp (name, "-rs"))
 244         random_init (atoi (value));
 245       else if (!strcmp (name, "-mlfqs"))
 246         thread_mlfqs = true;
 247 #ifdef USERPROG
 248       else if (!strcmp (name, "-ul"))
 249         user_page_limit = atoi (value);
 250 #endif
 251       else
 252         PANIC ("unknown option `%s' (use -h for help)", name);
 253     }
 254
 255   return argv;
 256 }
 257
 258 /* Runs the task specified in ARGV[1]. */
 259 static void
 260 run_task (char **argv)
 261 {
 262   const char *task = argv[1];
 263
 264   printf ("Executing '%s':\n", task);
 265 #ifdef USERPROG
 266   process_wait (process_execute (task));
 267 #else
 268   run_test (task);
 269 #endif
 270   printf ("Execution of '%s' complete.\n", task);
 271 }
 272
 273 /* Executes all of the actions specified in ARGV[]
 274    up to the null pointer sentinel. */
 275 static void
 276 run_actions (char **argv)
 277 {
 278   /* An action. */
 279   struct action
 280     {
 281       char *name;                       /* Action name. */
 282       int argc;                         /* # of args, including action name. */
 283       void (*function) (char **argv);   /* Function to execute action. */
 284     };
 285
 286   /* Table of supported actions. */
 287   static const struct action actions[] =
 288     {
 289       {"run", 2, run_task},
 290 #ifdef FILESYS
 291       {"ls", 1, fsutil_ls},
 292       {"cat", 2, fsutil_cat},
 293       {"rm", 2, fsutil_rm},
 294       {"put", 2, fsutil_put},
 295       {"get", 2, fsutil_get},
 296 #endif
 297       {NULL, 0, NULL},
 298     };
 299
 300   while (*argv != NULL)
 301     {
 302       const struct action *a;
 303       int i;
 304
 305       /* Find action name. */
 306       for (a = actions; ; a++)
 307         if (a->name == NULL)
 308           PANIC ("unknown action `%s' (use -h for help)", *argv);
 309         else if (!strcmp (*argv, a->name))
 310           break;
 311
 312       /* Check for required arguments. */
 313       for (i = 1; i < a->argc; i++)
 314         if (argv[i] == NULL)
 315           PANIC ("action `%s' requires %d argument(s)", *argv, a->argc - 1);
 316
 317       /* Invoke action and advance. */
 318       a->function (argv);
 319       argv += a->argc;
 320     }
 321
 322 }
 323
 324 /* Prints a kernel command line help message and powers off the
 325    machine. */
 326 static void
 327 usage (void)
 328 {
 329   printf ("\nCommand line syntax: [OPTION...] [ACTION...]\n"
 330           "Options must precede actions.\n"
 331           "Actions are executed in the order specified.\n"
 332           "\nAvailable actions:\n"
 333 #ifdef USERPROG
 334           "  run 'PROG [ARG...]' Run PROG and wait for it to complete.\n"
 335 #else
 336           "  run TEST           Run TEST.\n"
 337 #endif
 338 #ifdef FILESYS
 339           "  ls                 List files in the root directory.\n"
 340           "  cat FILE           Print FILE to the console.\n"
 341           "  rm FILE            Delete FILE.\n"
 342           "Use these actions indirectly via `pintos' -g and -p options:\n"
 343           "  put FILE           Put FILE into file system from scratch disk.\n"
 344           "  get FILE           Get FILE from file system into scratch disk.\n"
 345 #endif
 346           "\nOptions:\n"
 347           "  -h                 Print this help message and power off.\n"
 348           "  -q                 Power off VM after actions or on panic.\n"
 349           "  -f                 Format file system disk during startup.\n"
 350           "  -rs=SEED           Set random number seed to SEED.\n"
 351           "  -mlfqs             Use multi-level feedback queue scheduler.\n"
 352 #ifdef USERPROG
 353           "  -ul=COUNT          Limit user memory to COUNT pages.\n"
 354 #endif
 355           );
 356   power_off ();
 357 }
 358
 359
 360 /* Powers down the machine we're running on,
 361    as long as we're running on Bochs or QEMU. */
 362 void
 363 power_off (void)
 364 {
 365   const char s[] = "Shutdown";
 366   const char *p;
 367
 368 #ifdef FILESYS
 369   filesys_done ();
 370 #endif
 371
 372   print_stats ();
 373
 374   printf ("Powering off...\n");
 375   serial_flush ();
 376
 377   for (p = s; *p != '\0'; p++)
 378     outb (0x8900, *p);
 379   asm volatile ("cli; hlt" : : : "memory");
 380   printf ("still running...\n");
 381   for (;;);
 382 }
 383
 384 /* Print statistics about Pintos execution. */
 385 static void
 386 print_stats (void)
 387 {
 388   timer_print_stats ();
 389   thread_print_stats ();
 390 #ifdef FILESYS
 391   disk_print_stats ();
 392 #endif
 393   console_print_stats ();
 394   kbd_print_stats ();
 395 #ifdef USERPROG
 396   exception_print_stats ();
 397 #endif
 398 }