kernel/main.c

C · 45 lines · annotated 100% · kernel · upstream

About this file

main is where every hart arrives in supervisor mode, after start's mret. It brings up the kernel in a fixed order and then hands each CPU to the scheduler, which never returns.

The work is split. Hart 0 initializes everything that exists once for the whole machine: the console, the page allocator, the kernel’s page table, the process table, the disk, the first process. Every other hart waits until hart 0 says it is done, then configures only its own per-CPU hardware. A shared flag, started, carries the “done” signal safely from one hart to the others.

The list of calls on lines 14–31 doubles as a table of contents for the kernel: each call is the entry point of one subsystem, and following them one by one is a good way to tour xv6.

Read before: kernel/start.c. Read next: kernel/vm.c (the page tables set up here) or kernel/proc.c (userinit and scheduler).

Show notes inline

1#include "types.h"
2#include "param.h"
3#include "memlayout.h"
4#include "riscv.h"
5#include "defs.h"
6
7volatile static int started = 0;
8
9// start() jumps here in supervisor mode on all CPUs.
10void
11main()
12{
13  if (cpuid() == 0) {
14    consoleinit();
15    printkinit();
16    printk("\n");
17    printk("xv6 kernel is booting\n");
18    printk("\n");
19    kinit();            // physical page allocator
20    kvminit();          // create kernel page table
21    kvminithart();      // turn on paging
22    procinit();         // process table
23    trapinit();         // trap vectors
24    trapinithart();     // install kernel trap vector
25    plicinit();         // set up interrupt controller
26    plicinithart();     // ask PLIC for device interrupts
27    binit();            // buffer cache
28    iinit();            // inode table
29    fileinit();         // file table
30    virtio_disk_init(); // emulated hard disk
31    userinit();         // first user process
32
33    __atomic_store_n(&started, 1, __ATOMIC_RELEASE);
34  } else {
35    while (__atomic_load_n(&started, __ATOMIC_ACQUIRE) == 0)
36      ;
37
38    printk("hart %d starting\n", cpuid());
39    kvminithart();  // turn on paging
40    trapinithart(); // install kernel trap vector
41    plicinithart(); // ask PLIC for device interrupts
42  }
43
44  scheduler();
45}

Lines 1–5

Headers

The same xv6 headers as kernel/start.c. kernel/defs.h declares every function called below.

Line 7

The "initialization finished" flag

Hart 0 sets started to 1 when it has finished the machine-wide setup; the other harts wait for that. static keeps the name private to this file. volatile tells the compiler not to assume the value stays the same between reads. The real guarantee comes from the atomic built-ins on lines 33 and 35, which also make sure hart 0’s other writes are visible before the flag is.

Line 7

A file-private int that starts at 0; written once by hart 0, read in a loop by the others.

Lines 9–12

main(): supervisor mode, all CPUs

start set mepc to this function’s address, so mret lands here on every hart, in supervisor mode, with paging off and each hart still on its own slice of stack0. A kernel’s main takes no arguments and returns nothing (no one could receive a return value), which is why the Makefile passes -Wno-main; -ffreestanding (there is no hosted C library) also means main is not special.

Lines 13–18

Only hart 0 initializes the machine

cpuid reads the hart ID that start stored in tp. The hart whose ID is 0 does the one-time setup; this is decided by ID, not by which hart gets here first.

The console comes first so that the rest of the boot can print messages, including the error message if anything below calls panic. consoleinit sets up the UART and connects it to the console device; printkinit creates the lock that keeps lines printed by different harts from being mixed together. The three printk calls produce the banner you see when xv6 boots.

Line 13

Is this hart number 0? cpuid returns the value in tp.

Line 14

Set up the console: initialize the UART (uartinit) and route read and write on the console device to consoleread and consolewrite.

Line 15

Initialize the lock used by printk.

Line 16

Print an empty line. printk is the kernel’s own printf; the kernel cannot use the C library’s.

Line 17

The first message you see when xv6 boots.

Lines 19–21

Memory

These three calls take the kernel from raw physical memory to running with virtual memory on:

kinit makes every 4096-byte page between end (the end of the kernel image) and PHYSTOP available to kalloc.
kvminit builds the kernel’s page table (kvmmake). It maps the kernel’s code, data and RAM at addresses equal to their physical addresses, plus the device registers, the trampoline page, and a kernel stack for each process.
kvminithart writes that table’s address into satp, turning address translation on for this hart. The next instruction still works because the kernel’s code is mapped at the same address it already had.

Line 19

Hand all free physical memory to the page allocator.

Line 20

Build the kernel page table; its address goes in kernel_pagetable.

Line 21

Turn on paging on this hart.

Lines 22–26

Processes, traps and interrupts

procinit initializes the process table: a lock per entry, every entry marked UNUSED, and the virtual address of each process’s kernel stack.
trapinit initializes the lock protecting the tick counter.
trapinithart points stvec at kernelvec, the handler for traps that happen while the kernel itself is running.
plicinit gives the UART and disk interrupts a non-zero priority in the PLIC (zero would mean “never deliver”).
plicinithart asks the PLIC to deliver those two interrupts to this hart.

Calls ending in hart configure the current hart only, which is why the other harts repeat them on lines 39–41.

Line 22

Initialize the process table.

Line 23

Initialize the lock for the clock-tick counter.

Line 24

Route traps that occur in the kernel to kernelvec.

Line 25

Set PLIC priorities for the UART and disk interrupts.

Line 26

Enable those interrupts for this hart.

Lines 27–30

Files and the disk

binit sets up the buffer cache, the kernel’s in-memory copies of disk blocks.
iinit sets up the table of in-memory inodes (files currently in use).
fileinit sets up the table of open files.
virtio_disk_init initializes the virtio disk device, which holds fs.img.

Nothing is read from the disk yet. Reading the file system needs a process context (it may have to sleep while waiting for the disk), so it happens later, in forkret (kernel/proc.c:528).

Line 27

Initialize the buffer cache.

Line 28

Initialize the inode table.

Line 29

Initialize the open-file table.

Line 30

Initialize the virtio disk driver.

Line 31

The first process

userinit creates the first process and marks it runnable. It does not run yet. When a scheduler first picks it, it starts in forkret, which initializes the file system and loads the program /init (kernel/proc.c:532). /init (user/init.c) then starts the shell.

Line 31

Create the first process. It runs once a scheduler picks it.

Line 33

Tell the other harts

Set started to 1 with release ordering: every memory write hart 0 made above (the page table, the process table, the locks…) is guaranteed to be visible to any hart that sees started == 1 through an acquire load. Without this, another hart could see the flag before the page table it is about to use. See atomic operation and memory ordering.

Line 33

Publish started = 1 so the other harts can continue. __atomic_store_n is a GCC built-in; __ATOMIC_RELEASE gives the ordering explained in the block note.

Lines 34–42

Every other hart

Harts 1, 2, … arrive here immediately and wait in a loop until hart 0 sets the flag. Then each one announces itself (with the default 3 CPUs you see hart 1 starting and hart 2 starting, in either order) and does the per-hart part of the setup: turn on paging with the kernel page table hart 0 built, install the kernel trap handler, and enable device interrupts from the PLIC.

Line 35

Read started with acquire ordering, so that once this hart sees 1, it also sees everything hart 0 wrote before setting it.

Line 36

The empty loop body: keep re-reading until the flag is 1.

Line 38

Announce this hart. With make qemu CPUS=2 this prints hart 1 starting.

Line 39

Turn on paging on this hart, using the page table hart 0 built.

Line 40

Install the kernel trap handler on this hart.

Line 41

Enable UART and disk interrupts for this hart.

Lines 44–45

Become a scheduler

Every hart, including hart 0, ends here. scheduler loops forever, picking a runnable process and running it. At first the only process is the one userinit created, so one hart runs it while the others find nothing to do and wait. main never returns.

Line 44

Enter the scheduler. Never returns.

No stack switch happens here: scheduler runs on the same slice of stack0 that main has used all along, and because it never returns, that slice is from now on this hart’s scheduler stack. The frames of start and main stay at its top for good (The stacks of xv6).