Administrivia

• “Lab 2: Shell and Bootloader” is due in 2 weeks (DUE: Feb 10)!

Q&A

// Q. what's wrong?
impl RdRand { fn gen_range(..) }

// Q. what's wrong?
impl RngCore for RdRand {
  fn next_u32() { impls::next_u32_via_fill(self); }
}

// Q. what's wrong?
impl RngCore for RdRand {
  fn next_u64(&mut self) -> u64 {
    self.next_u32() as u64
  }
}

Q&A. Error patterns

1. Not using the lib: e.g., own gen_range() for RdRand
2. Circular dependency: e.g., using impls::next_u32_via_fill() in next_u32()
3. Lack of entropy: e.g., RNG_DATA.read_volatile() as u64 in next_u64()

Agenda

• Learn about minimal C/Rust
• Learn about no_std

Minimal C/Rust

1. What’s their size (see, size)?
2. What’s in there (see, objdump)?
3. What’s the code other than what we wrote (i.e., nothing)?
4. What are these template code for?

// gcc test.c
int main() {}

// rustc test.rs
fn main() {}

Freestanding binary

• Taking control over exactly what we want/need
  • Dropping standard library
  • Accessing underlying hardware/machine code (i.e., assembly)
  • Often, targeted to run on a baremetal machine (i.e., no OS)

Freestanding C

• About C runtime/startup (/lib/crt*.so)
• About linker/entry point (ld)
• About inline assembly (asm)

// gcc -nostdlib freestanding.c
void _start() {
  asm volatile ("mov $1, %%rdi\n"
                "mov $0x3c, %%rax\n"
                "syscall"
                :
                :
                :"rax", "rdi");
}

Freestanding Rust

• A bit heavy lifting required for Rust, but certainly doable (see later)
  • About no_std / no_main
  • About panic_handler / lang_items

#[no_mangle]
fn _start() {
    unsafe {
        asm!("mov rdi, $$1
              mov rax, $$0x3c
              syscall"
             :
             :
             :"rax"
             :"volatile", "intel");
    }

About libcore, liballoc, libstd

• libcore: dependency-free foundation (i.e., no libc, no heap)
  • Requires panic and eh_personality
• liballoc: smart pointers and heap-managed collections (i.e., Box)
  • Requires global_allocator and alloc_error_handler
• libstd: a set of shared abstractions for Rust software (e.g., I/O, networking, thread)
  • Depending on libcore and liballoc

About libcore, liballoc, libstd in OS development

• libcore: our OS code, in particular early code, only relies on core (from lab1)
• liballoc: once we have a managed heap on physical pages (from lab3)
• libstd: not allowed! but partly import what we’d like (e.g., Path from lab3)

no_std

• No default prelude and std libraries used/linked

// extern crate std;
// use std::prelude::v1::*;

#![no_std]

fn plus_one(x: i32) -> i32 {
    x + 1
}

Ref. No stdlib, Rustbook

no_main

• No fn main() defined (i.e., explicitly defining an entry point)
• Linker’s default entry point is _start()

#![no_main]

#[no_mangle]
pub extern fn _start() -> ! {
  // your program
}

panic_handler

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
  // you will be asked to fill this in lab3
  loop {}
}

Ref. 12. Beneath std, Nomicon

eh_personality

• Bridging the semantic gap b/w system’s and language’s exception handling

#[lang = "eh_personality"]
fn eh_personality() {
  // ignored for now!
}

Ref. http://llvm.org/docs/ExceptionHandling.html

Note on 1-blinky/phase3 (C)

• About Makefile
• About layout.ld
• About init.S
• About blinky.elf / blinky.bin

Note on 1-blinky/phase4 (Rust)

• About .cargo/layout.ld
• About src/init/init.s
• About src/init/panic.rs
• About src/init.rs

Cargo config and xbuild

[build]
target = "aarch64-unknown-none"

[target.aarch64-unknown-none]
runner = "./qemu.sh"
rustflags = [
    "-C", "target-cpu=cortex-a53",
    "-C", "link-arg=--script=.cargo/layout.ld",
    "-C", "link-arg=--no-dynamic-linker",
]

Running on qemu

$ ./qemu.sh build/blinky.elf -d in_asm
IN:
0x0000000004000000:  d53800a1      mrs x1, (unknown)
0x0000000004000004:  92400421      and x1, x1, #0x3
0x0000000004000008:  b4000061      cbz x1, #+0xc (addr 0x4000014)

IN:
0x0000000004000014:  10ffff61      adr x1, #-0x14 (addr 0x4000000)
0x0000000004000018:  9100003f      mov sp, x1
0x000000000400001c:  94000003      bl #+0xc (addr 0x4000028)

IN: kinit
0x0000000004000028:  90000008      adrp x8, #+0x0 (addr 0x4000000)
0x000000000400002c:  91030108      add x8, x8, #0xc0 (192)
0x0000000004000030:  90000009      adrp x9, #+0x0 (addr 0x4000000)
...

Next lecture

• Next: Rust 5: Generics and Traits
• “Lab 2: Shell and Bootloader” is due in 1.5 weeks (DUE: Feb 10)!

References

• Embedded Rust
• A Freestanding Rust Binary