init.c File Reference

#include "threads/init.h"
#include <console.h>
#include <debug.h>
#include <limits.h>
#include <random.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "devices/kbd.h"
#include "devices/input.h"
#include "devices/serial.h"
#include "devices/timer.h"
#include "devices/vga.h"
#include "threads/interrupt.h"
#include "threads/io.h"
#include "threads/loader.h"
#include "threads/malloc.h"
#include "threads/mmu.h"
#include "threads/palloc.h"
#include "threads/pte.h"
#include "threads/thread.h"
#include "tests/threads/tests.h"

Include dependency graph for init.c:

Functions
static void	bss_init (void)
static void	paging_init (uint64_t mem_end)
static char **	read_command_line (void)
static char **	parse_options (char **argv)
static void	run_actions (char **argv)
static void	usage (void)
static void	print_stats (void)
int	main (void)
static void	run_task (char **argv)
void	power_off (void)

Variables
uint64_t *	base_pml4
bool	power_off_when_done
bool	thread_tests

Function Documentation

bss_init()

static void bss_init ( void  )

static

                {
    /* The "BSS" is a segment that should be initialized to zeros.
       It isn't actually stored on disk or zeroed by the kernel
       loader, so we have to zero it ourselves.
 
       The start and end of the BSS segment is recorded by the
       linker as _start_bss and _end_bss.  See kernel.lds. */
    extern char _start_bss, _end_bss;
    memset (&_start_bss, 0, &_end_bss - &_start_bss);
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main

(

void

)

            {
    uint64_t mem_end;
    char **argv;
 
    /* Clear BSS and get machine's RAM size. */
    bss_init ();
 
    /* Break command line into arguments and parse options. */
    argv = read_command_line ();
    argv = parse_options (argv);
 
    /* Initialize ourselves as a thread so we can use locks,
       then enable console locking. */
    thread_init ();
    console_init ();
 
    /* Initialize memory system. */
    mem_end = palloc_init ();
    malloc_init ();
    paging_init (mem_end);
 
#ifdef USERPROG
    tss_init ();
    gdt_init ();
#endif
 
    /* Initialize interrupt handlers. */
    intr_init ();
    timer_init ();
    kbd_init ();
    input_init ();
#ifdef USERPROG
    exception_init ();
    syscall_init ();
#endif
    /* Start thread scheduler and enable interrupts. */
    thread_start ();
    serial_init_queue ();
    timer_calibrate ();
 
#ifdef FILESYS
    /* Initialize file system. */
    disk_init ();
    filesys_init (format_filesys);
#endif
 
#ifdef VM
    vm_init ();
#endif
 
    printf ("Boot complete.\n");
 
    /* Run actions specified on kernel command line. */
    run_actions (argv);
 
    /* Finish up. */
    if (power_off_when_done)
        power_off ();
    thread_exit ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

paging_init()

static void paging_init ( uint64_t  mem_end )

static

                               {
    uint64_t *pml4, *pte;
    int perm;
    pml4 = base_pml4 = palloc_get_page (PAL_ASSERT | PAL_ZERO);
 
    extern char start, _end_kernel_text;
    // Maps physical address [0 ~ mem_end] to
    //   [LOADER_KERN_BASE ~ LOADER_KERN_BASE + mem_end].
    for (uint64_t pa = 0; pa < mem_end; pa += PGSIZE) {
        uint64_t va = (uint64_t) ptov(pa);
 
        perm = PTE_P | PTE_W;
        if ((uint64_t) &start <= va && va < (uint64_t) &_end_kernel_text)
            perm &= ~PTE_W;
 
        if ((pte = pml4e_walk (pml4, va, 1)) != NULL)
            *pte = pa | perm;
    }
 
    // reload cr3
    pml4_activate(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_options()

static char ** parse_options ( char **  argv )

static

                            {
    for (; *argv != NULL && **argv == '-'; argv++) {
        char *save_ptr;
        char *name = strtok_r (*argv, "=", &save_ptr);
        char *value = strtok_r (NULL, "", &save_ptr);
 
        if (!strcmp (name, "-h"))
            usage ();
        else if (!strcmp (name, "-q"))
            power_off_when_done = true;
#ifdef FILESYS
        else if (!strcmp (name, "-f"))
            format_filesys = true;
#endif
        else if (!strcmp (name, "-rs"))
            random_init (atoi (value));
        else if (!strcmp (name, "-mlfqs"))
            thread_mlfqs = true;
#ifdef USERPROG
        else if (!strcmp (name, "-ul"))
            user_page_limit = atoi (value);
        else if (!strcmp (name, "-threads-tests"))
            thread_tests = true;
#endif
        else
            PANIC ("unknown option `%s' (use -h for help)", name);
    }
 
    return argv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

power_off()

void power_off

(

void

)

                 {
#ifdef FILESYS
    filesys_done ();
#endif
 
    print_stats ();
 
    printf ("Powering off...\n");
    outw (0x604, 0x2000);               /* Poweroff command for qemu */
    for (;;);
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_stats()

static void print_stats ( void  )

static

                   {
    timer_print_stats ();
    thread_print_stats ();
#ifdef FILESYS
    disk_print_stats ();
#endif
    console_print_stats ();
    kbd_print_stats ();
#ifdef USERPROG
    exception_print_stats ();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_command_line()

static char ** read_command_line ( void  )

static

                         {
    static char *argv[LOADER_ARGS_LEN / 2 + 1];
    char *p, *end;
    int argc;
    int i;
 
    argc = *(uint32_t *) ptov (LOADER_ARG_CNT);
    p = ptov (LOADER_ARGS);
    end = p + LOADER_ARGS_LEN;
    for (i = 0; i < argc; i++) {
        if (p >= end)
            PANIC ("command line arguments overflow");
 
        argv[i] = p;
        p += strnlen (p, end - p) + 1;
    }
    argv[argc] = NULL;
 
    /* Print kernel command line. */
    printf ("Kernel command line:");
    for (i = 0; i < argc; i++)
        if (strchr (argv[i], ' ') == NULL)
            printf (" %s", argv[i]);
        else
            printf (" '%s'", argv[i]);
    printf ("\n");
 
    return argv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

run_actions()

static void run_actions ( char **  argv )

static

                          {
    /* An action. */
    struct action {
        char *name;                       /* Action name. */
        int argc;                         /* # of args, including action name. */
        void (*function) (char **argv);   /* Function to execute action. */
    };
 
    /* Table of supported actions. */
    static const struct action actions[] = {
        {"run", 2, run_task},
#ifdef FILESYS
        {"ls", 1, fsutil_ls},
        {"cat", 2, fsutil_cat},
        {"rm", 2, fsutil_rm},
        {"put", 2, fsutil_put},
        {"get", 2, fsutil_get},
#endif
        {NULL, 0, NULL},
    };
 
    while (*argv != NULL) {
        const struct action *a;
        int i;
 
        /* Find action name. */
        for (a = actions; ; a++)
            if (a->name == NULL)
                PANIC ("unknown action `%s' (use -h for help)", *argv);
            else if (!strcmp (*argv, a->name))
                break;
 
        /* Check for required arguments. */
        for (i = 1; i < a->argc; i++)
            if (argv[i] == NULL)
                PANIC ("action `%s' requires %d argument(s)", *argv, a->argc - 1);
 
        /* Invoke action and advance. */
        a->function (argv);
        argv += a->argc;
    }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

run_task()

static void run_task ( char **  argv )

static

                       {
    const char *task = argv[1];
 
    printf ("Executing '%s':\n", task);
#ifdef USERPROG
    if (thread_tests){
        run_test (task);
    } else {
        process_wait (process_create_initd (task));
    }
#else
    run_test (task);
#endif
    printf ("Execution of '%s' complete.\n", task);
}

Here is the call graph for this function:

Here is the caller graph for this function:

usage()

static void usage ( void  )

static

             {
    printf ("\nCommand line syntax: [OPTION...] [ACTION...]\n"
            "Options must precede actions.\n"
            "Actions are executed in the order specified.\n"
            "\nAvailable actions:\n"
#ifdef USERPROG
            "  run 'PROG [ARG...]' Run PROG and wait for it to complete.\n"
#else
            "  run TEST           Run TEST.\n"
#endif
#ifdef FILESYS
            "  ls                 List files in the root directory.\n"
            "  cat FILE           Print FILE to the console.\n"
            "  rm FILE            Delete FILE.\n"
            "Use these actions indirectly via `pintos' -g and -p options:\n"
            "  put FILE           Put FILE into file system from scratch disk.\n"
            "  get FILE           Get FILE from file system into scratch disk.\n"
#endif
            "\nOptions:\n"
            "  -h                 Print this help message and power off.\n"
            "  -q                 Power off VM after actions or on panic.\n"
            "  -f                 Format file system disk during startup.\n"
            "  -rs=SEED           Set random number seed to SEED.\n"
            "  -mlfqs             Use multi-level feedback queue scheduler.\n"
#ifdef USERPROG
            "  -ul=COUNT          Limit user memory to COUNT pages.\n"
#endif
            );
    power_off ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

base_pml4

uint64_t* base_pml4

power_off_when_done

bool power_off_when_done

thread_tests

bool thread_tests