rCore-os1-应用程序与基本执行环境

1

cargo new os

1
2
3

fn main() {
    println!("Hello, world!");
}

1

cargo run

1
2
3
4

1. 预处理: 源代码(source code) -> 预处理器(preprocessor) -> 宏展开的源代码
2. 编译: 宏展开的源代码 -> 编译器(compiler) -> 汇编程序
3. 汇编: 汇编程序 -> 汇编器(assembler) -> 目标代码(object code)
4. 链接: 目标代码 -> 链接器(linker) -> 可执行文件(executables)

1
2
3
4
5
6
7
8

$ rustc --version --verbose
rustc 1.63.0 (4b91a6ea7 2022-08-08)
binary: rustc
commit-hash: 4b91a6ea7258a947e59c6522cd5898e7c0a6a88f
commit-date: 2022-08-08
host: aarch64-apple-darwin
release: 1.63.0
LLVM version: 14.0.5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

$ rustc --print target-list | grep riscv
riscv32gc-unknown-linux-gnu
riscv32gc-unknown-linux-musl
riscv32i-unknown-none-elf
riscv32im-unknown-none-elf
riscv32imac-unknown-none-elf
riscv32imac-unknown-xous-elf
riscv32imc-esp-espidf
riscv32imc-unknown-none-elf
riscv64gc-unknown-freebsd
riscv64gc-unknown-linux-gnu
riscv64gc-unknown-linux-musl
riscv64gc-unknown-none-elf
riscv64imac-unknown-none-elf

1

cargo run --target riscv64gc-unknown-none-elf

1

$ rustup target add riscv64gc-unknown-none-elf

1
2
3

# os/.cargo/config
[build]
target = "riscv64gc-unknown-none-elf"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

$ cargo build         
   Compiling os v0.1.0 (/Users/ther/WorkSpace/rCore/os)
error[E0463]: can't find crate for `std`
  |
  = note: the `riscv64gc-unknown-none-elf` target may not support the standard library
  = note: `std` is required by `os` because it does not declare `#![no_std]`

error: cannot find macro `println` in this scope
 --> src/main.rs:2:5
  |
2 |     println!("Hello, world!");
  |     ^^^^^^^

error: `#[panic_handler]` function required, but not found

For more information about this error, try `rustc --explain E0463`.
error: could not compile `os` due to 3 previous errors

1
2
3
4
5

// os/src/main.rs
#![no_std]
mod lang_items;

fn main() {}

1
2
3
4
5
6
7

// os/src/lang_items.rs
use core::panic::PanicInfo;

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    loop {}
}

1
2
3
4
5

$ cargo build
   Compiling os v0.1.0 (/Users/ther/WorkSpace/rCore/os)
error: requires `start` lang_item

error: could not compile `rCore` due to previous error

1
2
3
4
5

// os/src/main.rs
#![no_std]
#![no_main]
mod lang_items;
//在开头加入设置#![no_main]告诉编译器我们没有一般意义上的main函数，并删除原来的main函数。

1
2
3

$ cargo build 
   Compiling os v0.1.0 (/Users/ther/WorkSpace/rCore/os)
    Finished dev [unoptimized + debuginfo] target(s) in 0.05s

1
2

$ cargo install cargo-binutils
$ rustup component add llvm-tools-preview

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# 文件格式
$ file target/riscv64gc-unknown-none-elf/debug/os
target/riscv64gc-unknown-none-elf/debug/os: ELF 64-bit LSB executable, UCB RISC-V, RVC, double-float ABI, version 1 (SYSV), statically linked, with debug_info, not stripped
# 对二进制程序os的分析可以看出它好像是一个合法的RISC-V可执行程序

# 文件头信息
$ rust-readobj -h target/riscv64gc-unknown-none-elf/debug/os

File: target/riscv64gc-unknown-none-elf/debug/os
Format: elf64-littleriscv
Arch: riscv64
AddressSize: 64bit
LoadName: <Not found>
ElfHeader {
  Ident {
    Magic: (7F 45 4C 46)
    Class: 64-bit (0x2)
    DataEncoding: LittleEndian (0x1)
    FileVersion: 1
    OS/ABI: SystemV (0x0)
    ABIVersion: 0
    Unused: (00 00 00 00 00 00 00)
  }
  Type: Executable (0x2)
  Machine: EM_RISCV (0xF3)
  Version: 1
  Entry: 0x0
  ProgramHeaderOffset: 0x40
  SectionHeaderOffset: 0x1B40
  Flags [ (0x5)
    EF_RISCV_FLOAT_ABI_DOUBLE (0x4)
    EF_RISCV_RVC (0x1)
  ]
  HeaderSize: 64
  ProgramHeaderEntrySize: 56
  ProgramHeaderCount: 3
  SectionHeaderEntrySize: 64
  SectionHeaderCount: 14
  StringTableSectionIndex: 12
}
# 通过rust-readobj工具进一步分析，发现入口地址Entry是0x0

# 反汇编导出汇编程序
$ rust-objdump -S target/riscv64gc-unknown-none-elf/debug/os

target/riscv64gc-unknown-none-elf/debug/os:	file format elf64-littleriscv
# 经过反汇编，并没有生成汇编代码，所以基本可以断定，这个二进制程序虽然合法，但它是一个空程序。

1
2
3
4
5
6

# 此命令用于启动Qemu并运行我们的内核
$	qemu-system-riscv64 \ # 模拟64位RISC-V架构的计算机
    -machine virt \ # 将模拟的64位RISC-V计算机设置为名为virt的虚拟计算机
    -nographic \ # 表示不需要提供图形界面
    -bios ../bootloader/rustsbi.bin \ # Qemu开机时用来初始化的引导加载程序bootloader
    -device loader,file=target/riscv64gc-unknown-none-elf/release/os.bin,addr=0x80200000 # loader属性可以在Qemu开机前将宿主机的文件载入到指定物理内存地址。

1
2
3
4
5

# os/src/entry.asm
	.section .text.entry # 表示将后面的内容放到名为.text.entry 的段中
	.global _start # 告知编译器，这是一个全局符号，可以被其他目标文件使用
_start:
	li x1, 100 # 向寄存器x1中加载一个立即数100

1
2
3
4
5
6
7

// os/src/main.rs
#![no_std]
#![no_main]
mod lang_items;

use core::arch::global_asm;
global_asm!(include_str!("entry.asm"));

1
2
3
4
5
6
7
8
9

# os/.cargo/config

[build]
target = "riscv64gc-unknown-none-elf"

[taaarget.riscv64gc-unknown-none-elf]
rustflags = [
	"-Clink-arg=-Tsrc/linker.ld", "-Cforce-frame-pointers=yes",
]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

# os/src/linker.ld

OUTPUT_ARCH(riscv) # 设置目标平台
ENTRY(_start) # 设置整个程序的入口点，_start为entry.asm中定义的全局符号
BASE_ADDRESS = 0x80200000; # 定义常量

SECTIONS
{
    . = BASE_ADDRESS;
    skernel = .;

    stext = .;
    .text : {
        *(.text.entry) # *
        *(.text .text.*)
    }

    . = ALIGN(4K);
    etext = .;
    srodata = .;
    .rodata : {
        *(.rodata .rodata.*)
        *(.srodata .srodata.*)
    }

    . = ALIGN(4K);
    erodata = .;
    sdata = .;
    .data : {
        *(.data .data.*)
        *(.sdata .sdata.*)
    }

    . = ALIGN(4K);
    edata = .;
    .bss : {
        *(.bss.stack)
        sbss = .;
        *(.bss .bss.*)
        *(.sbss .sbss.*)
    }

    . = ALIGN(4K);
    ebss = .;
    ekernel = .;

    /DISCARD/ : {
        *(.eh_frame)
    }
}

1
2
3

$ cargo build --release
   Compiling os v0.1.0 (/Users/ther/WorkSpace/rCore/os)
    Finished release [optimized] target(s) in 0.40s

1

$ rust-objcopy --strip-all target/riscv64gc-unknown-none-elf/debug/os -O binary target/riscv64gc-unknown-none-elf/os.bin

1
2
3
4
5
6

$ qemu-system-riscv64 \
    -machine virt \
    -nographic \
    -bios ../bootloader/rustsbi.bin \
    -device loader,file=target/riscv64gc-unknown-none-elf/release/os.bin,addr=0x80200000 \
	-s -S

1
2
3
4

$ riscv64-unknown-elf-gdb \
    -ex 'file target/riscv64gc-unknown-none-elf/release/os' \
    -ex 'set arch riscv:rv64' \
    -ex 'target remote localhost:1234'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

(gdb) b *0x80200000 # 在0x80200000处打个断点
Breakpoint 1 at 0x80200000
(gdb) c
Continuing.

Breakpoint 1, 0x0000000080200000 in ?? ()
(gdb) x/5i $pc
=> 0x80200000:	li	ra,100 # 可以看到我们entry.asm中的 li x1, 100，ra是寄存器x1的别名
   0x80200004:	unimp
   0x80200006:	unimp
   0x80200008:	unimp
   0x8020000a:	unimp
(gdb) si # 继续执行下一条指令
0x0000000080200004 in ?? ()
(gdb) p/d $x1 # 以十进制打印寄存器x1的值
$1 = 100
(gdb) p/x $sp # 检查此时栈指针sp的值
$2 = 0x0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# os/src/entry.asm
	.section .text.entry
	.global _start
_start:
	la sp, boot_stack_top # 将指针sp设置为之前分配的启动栈栈顶地址
	call rust_main # 调用Rust编写的内核入口点rust_main,将控制权交给Rust代码

	.section .bss.stack # 将这块空间放置在一个名为.bss.stack的段中
	.global boot_stack
boot_stack:
	.space 4096*16 # 预留4096*16字节64KiB的空间用作程序的栈空间
	.global boot_stack_top
boot_stack_top:

1
2
3
4
5
6
7

# os/src/linker.ld
	.bss : {
        *(.bss.stack) # .bss.stack段被汇集到.bss段中
        sbss = .;
        *(.bss .bss.*)
        *(.sbss .sbss.*)
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// os/src/main.rs
#![no_std]
#![no_main]
mod lang_items;

use core::arch::global_asm;
global_asm!(include_str!("entry.asm"));

#[no_mangle] 
pub fn rust_main() -> ! {
    loop {}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// os/src/main.rs
#![no_std]
#![no_main]
mod lang_items;

use core::arch::global_asm;
global_asm!(include_str!("entry.asm"));

#[no_mangle]
pub fn rust_main() -> ! {
    clear_bss();
    loop {}
}

fn clear_bss() {
    extern "C" {
        fn sbss();
        fn ebss();
    }

    (sbss as usize..ebss as usize).for_each(|p| unsafe { (p as *mut u8).write_volatile(0) })
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// os/src/sbi
use core::arch::asm;
#[inline(always)]
fn sbi_call(which: usize, arg0: usize, arg1: usize, arg2: usize) -> usize {
    let mut ret;
    unsafe {
        asm! {
            "ecall",
            inlateout("x10") arg0=>ret,
            in("x11") arg1,
            in("x12") arg2,
            in("x17") which,
        }
    }
    ret
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// os/src/sbi.rs
#![allow(unused)]
const SBI_SET_TIMER: usize = 0;
const SBI_CONSOLE_PUTCHAR: usize = 1;
const SBI_CONSOLE_GETCHAR: usize = 2;
const SBI_CLEAR_IPI: usize = 3;
const SBI_SEND_IPI: usize = 4;
const SBI_REMOTE_FENCE_I: usize = 5;
const SBI_REMOTE_SFENCE_VMA: usize = 6;
const SBI_REMOTE_SFENCE_VMA_ASID: usize = 7;
const SBI_SHUTDOWN: usize = 8;

use core::arch::asm;
#[inline(always)]
fn sbi_call(which: usize, arg0: usize, arg1: usize, arg2: usize) -> usize {
    let mut ret;
    unsafe {
        asm! {
            "ecall",
            inlateout("x10") arg0 => ret,
            in("x11") arg1,
            in("x12") arg2,
            in("x17") which,
        }
    }
    ret
}

1
2
3

pub fn console_putchar(c: usize) {
    sbi_call(SBI_CONSOLE_PUTCHAR, c, 0, 0);
}

1
2
3
4

pub fn shutdown() -> ! {
    sbi_call(SBI_SHUTDOWN, 0, 0, 0);
    panic!("It should shutdown!")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// os/src/console.rs
#![allow(unused)]
use crate::sbi::console_putchar;
use core::fmt::{self, Result, Write};

struct Stdout;

impl Write for Stdout {
    fn write_str(&mut self, s: &str) -> Result {
        for c in s.chars() {
            console_putchar(c as usize);
        }
        Ok(())
    }
}

pub fn print(args: fmt::Arguments) {
    Stdout.write_fmt(args).unwrap();
}

#[macro_export]
macro_rules! print {
    ($fmt: literal $(, $($arg: tt)+)?) => {
        $crate::console::print(format_args!($fmt $(, $($arg)+)?));
    }
}

#[macro_export]
macro_rules! println {
    ($fmt: literal $(, $($arg: tt)+)?) => {
        $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// os/src/lang_items.rss
use crate::println;
use crate::sbi::shutdown;
use core::panic::PanicInfo;

#[panic_handler]
fn panic(info: &PanicInfo) -> ! {
    if let Some(location) = info.location() {
        println!(
            "Panicked at {}:{} {}",
            location.file(),
            location.line(),
            info.message().unwrap()
        );
    } else {
        println!("Panicked: {}", info.message().unwrap());
    }
    shutdown()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// os/src/main.rs
#![no_std]
#![no_main]
#![feature(panic_info_message)]

mod lang_items;
mod sbi;

#[macro_use]
mod console;

use core::arch::global_asm;
global_asm!(include_str!("entry.asm"));

#[no_mangle]
pub fn rust_main() -> ! {
    clear_bss();
    println!("Hello, world");
    panic!("Shutdown machine!");
}

fn clear_bss() {
    extern "C" {
        fn sbss();
        fn ebss();
    }

    (sbss as usize..ebss as usize).for_each(|p| unsafe { (p as *mut u8).write_volatile(0) });
}

1
2

Hello, world
Panicked at src/main.rs:18 Shutdown machine!

1

echo -e "\x1b[31mhello world\x1b[0m"

1
2
3
4
5
6
7
8
9

# Cargo.toml

[package]
name = "os"
version = "0.1.0"
edition = "2021"

[dependencies]
log = "0.4" 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// os/src/logger.rs
use log::{self, Level, LevelFilter, Log};

use crate::println;

struct Logger;

impl Log for Logger {
    fn enabled(&self, _metadata: &log::Metadata) -> bool {
        true
    }

    fn log(&self, record: &log::Record) {
        if !self.enabled(record.metadata()) {
            return;
        }

        let color = match record.level() {
            Level::Error => 31,
            Level::Debug => 32,
            Level::Info => 34,
            Level::Trace => 90,
            Level::Warn => 93,
        };

        println!(
            "\u{1B}[{}m[{:>5}] {}\u{1B}[0m",
            color,
            record.level(),
            record.args(),
        );
    }

    fn flush(&self) {}
}

pub fn init() {
    static LOGGER: Logger = Logger;
    log::set_logger(&LOGGER).unwrap();
    log::set_max_level(match option_env!("LOG") {
        Some("ERROR") => LevelFilter::Error,
        Some("WARN") => LevelFilter::Warn,
        Some("INFO") => LevelFilter::Info,
        Some("DEBUG") => LevelFilter::Debug,
        Some("TRACE") => LevelFilter::Trace,
        _ => LevelFilter::Trace,
    });
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

// os/src/main.rs
#![no_main]
#![no_std]
#![feature(panic_info_message)]

mod lang_items;
mod sbi;

mod logger;
use log::*;

#[macro_use]
mod console;

core::arch::global_asm!(include_str!("entry.asm"));

#[no_mangle]
pub fn rust_main() -> ! {
    extern "C" {
        fn stext();
        fn etext();
        fn srodata();
        fn erodata();
        fn sdata();
        fn edata();
        fn sbss();
        fn ebss();
        fn boot_stack();
        fn boot_stack_top();
    }

    clear_bss();

    logger::init();
    error!("Hello, rCore!");

    info!(".text [{:#x}, {:#x}]", stext as usize, etext as usize);
    debug!(".rodata [{:#x}, {:#x}]", srodata as usize, erodata as usize);
    trace!(".data [{:#x}, {:#x}]", sdata as usize, edata as usize);
    warn!(".bss [{:#x}, {:#x}]", sbss as usize, ebss as usize);
    error!(
        ".stack [{:#x}, {:#x}]",
        boot_stack as usize, boot_stack_top as usize
    );
    panic!("Shutdown machine!");
}

fn clear_bss() {
    extern "C" {
        fn sbss();
        fn ebss();
    }
    (sbss as usize..ebss as usize).for_each(|p| unsafe { (p as *mut u8).write_volatile(0) });
}