From 95f8965986702c82ef627aca29315f86006d2d87 Mon Sep 17 00:00:00 2001 From: Sam Leffler Date: Fri, 16 Sep 2022 18:33:10 +0000 Subject: [PATCH] apps/rust: start of sdk runtime support for Rust apps Rust application runtime support + equivalents of hello & fibnoacci. Change-Id: Ica9b0d181387f159169cbe5f219d26c96540a56d GitOrigin-RevId: 0a14b67ddd9b166a8ba5c13bac37a30204deb3b0 --- apps/rust/Cargo.toml | 40 +++++++++ apps/rust/fibonacci/Cargo.toml | 39 +++++++++ apps/rust/fibonacci/Makefile | 18 ++++ apps/rust/fibonacci/build.rs | 34 ++++++++ apps/rust/fibonacci/fibonacci.rs | 114 +++++++++++++++++++++++++ apps/rust/hello/Cargo.toml | 2 + apps/rust/hello/Makefile | 38 ++++----- apps/rust/hello/hello.rs | 78 +++-------------- apps/rust/libkata/Cargo.toml | 25 ++++++ apps/rust/libkata/arch/riscv32/crt0.S | 78 +++++++++++++++++ apps/rust/libkata/lib.rs | 54 ++++++++++++ apps/rust/libkata/make/app.mk | 35 ++++++++ apps/rust/libkata/make/arch/riscv32.mk | 20 +++++ apps/rust/libkata/make/common.mk | 56 ++++++++++++ apps/rust/libkata/make/sel4.mk | 16 ++++ 15 files changed, 561 insertions(+), 86 deletions(-) create mode 100644 apps/rust/Cargo.toml create mode 100644 apps/rust/fibonacci/Cargo.toml create mode 100644 apps/rust/fibonacci/Makefile create mode 100644 apps/rust/fibonacci/build.rs create mode 100644 apps/rust/fibonacci/fibonacci.rs create mode 100644 apps/rust/libkata/Cargo.toml create mode 100644 apps/rust/libkata/arch/riscv32/crt0.S create mode 100644 apps/rust/libkata/lib.rs create mode 100644 apps/rust/libkata/make/app.mk create mode 100644 apps/rust/libkata/make/arch/riscv32.mk create mode 100644 apps/rust/libkata/make/common.mk create mode 100644 apps/rust/libkata/make/sel4.mk diff --git a/apps/rust/Cargo.toml b/apps/rust/Cargo.toml new file mode 100644 index 0000000..d11212b --- /dev/null +++ b/apps/rust/Cargo.toml @@ -0,0 +1,40 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +[workspace] + +members = [ + "libkata", + + "hello", + "fibonacci", +] +resolver = "2" + +[profile.dev] +opt-level = 0 +debug = true +# TODO(b/223253186): workaround gdb DIE errors +lto = false +codegen-units = 1 + +[profile.release] +opt-level = "z" +lto = "fat" +codegen-units = 1 +split-debuginfo = "unpacked" + +[profile.release.build-override] +opt-level = "z" +codegen-units = 1 diff --git a/apps/rust/fibonacci/Cargo.toml b/apps/rust/fibonacci/Cargo.toml new file mode 100644 index 0000000..ed0ac8e --- /dev/null +++ b/apps/rust/fibonacci/Cargo.toml @@ -0,0 +1,39 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +[package] +name = "fibonacci" +version = "0.1.0" +edition = "2021" +build = "build.rs" + +[build-dependencies] +# build.rs depends on SEL4_OUT_DIR = "${ROOTDIR}/out/kata/kernel" +sel4-config = { path = "../../system/components/kata-os-common/src/sel4-config" } + +[features] +default = [] +# Used by sel4-config to extract kernel config +CONFIG_PRINTING = [] + +[lib] +name = "fibonacci" +path = "fibonacci.rs" +crate-type = ["staticlib"] + +[dependencies] +kata-os-common = { path = "../../system/components/kata-os-common", default-features = false } +kata-sdk-interface = { path = "../../system/components/SDKRuntime/kata-sdk-interface" } +libkata = { path = "../libkata" } +log = "0.4" diff --git a/apps/rust/fibonacci/Makefile b/apps/rust/fibonacci/Makefile new file mode 100644 index 0000000..79d26ce --- /dev/null +++ b/apps/rust/fibonacci/Makefile @@ -0,0 +1,18 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +APPNAME := fibonacci + +LIBKATA ?= ../libkata +include ${LIBKATA}/make/app.mk diff --git a/apps/rust/fibonacci/build.rs b/apps/rust/fibonacci/build.rs new file mode 100644 index 0000000..69753b1 --- /dev/null +++ b/apps/rust/fibonacci/build.rs @@ -0,0 +1,34 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +extern crate sel4_config; +use std::env; + +fn main() { + // If SEL4_OUT_DIR is not set we expect the kernel build at a fixed + // location relative to the ROOTDIR env variable. + println!("SEL4_OUT_DIR {:?}", env::var("SEL4_OUT_DIR")); + let sel4_out_dir = env::var("SEL4_OUT_DIR") + .unwrap_or_else(|_| format!("{}/out/kata/kernel", env::var("ROOTDIR").unwrap())); + println!("sel4_out_dir {}", sel4_out_dir); + + // Dredge seL4 kernel config for settings we need as features to generate + // correct code: e.g. CONFIG_KERNEL_MCS enables MCS support which changes + // the system call numbering. + let features = sel4_config::get_sel4_features(&sel4_out_dir); + println!("features={:?}", features); + for feature in features { + println!("cargo:rustc-cfg=feature=\"{}\"", feature); + } +} diff --git a/apps/rust/fibonacci/fibonacci.rs b/apps/rust/fibonacci/fibonacci.rs new file mode 100644 index 0000000..3d077d1 --- /dev/null +++ b/apps/rust/fibonacci/fibonacci.rs @@ -0,0 +1,114 @@ +/* + * Copyright 2021, Google LLC + * + * Demo to show that concurrent applications can be running. + * + * This program prints the first LOG_FIBONACCI_LIMIT Fibonacci numbers + * to the console, waiting for INTERRUPTS_PER_WAIT interrupts between each + * number. + * + * SPDX-License-Identifier: Apache-2.0 + */ +#![no_std] +#![no_main] +#![feature(asm)] + +extern crate alloc; +extern crate libkata; +use alloc::format; +use kata_os_common::allocator; +use kata_sdk_interface::kata_sdk_log; + +// How many Fibonacci numbers to write to the log. +const LOG_FIBONACCI_LIMIT: u64 = 80; + +const CONFIG_TIMER_TICK_MS: usize = 5; +const INTERRUPTS_PER_VIRT_SEC: u64 = (1000 / CONFIG_TIMER_TICK_MS) as u64; +const INTERRUPTS_PER_WAIT: u64 = 1 * INTERRUPTS_PER_VIRT_SEC; + +type ICount = u64; + +struct Fibonacci { + f1: u64, + f2: u64, + n: u64, +} +impl Fibonacci { + pub fn new() -> Self { Self { f1: 0, f2: 1, n: 0 } } + pub fn increment(&mut self) { + let swap: u64 = self.f2; + self.f2 = self.f1 + self.f2; + self.f1 = swap; + self.n += 1; + } + pub fn reset(&mut self) { + self.f1 = 0; + self.f2 = 1; + self.n = 0; + } + + pub fn log(&self, interrupt_count: ICount) { + let _ = kata_sdk_log(&format!( + "n == {}; f == {:x}; interrupt_count == {}; rdtime == {}; virt_sec ~= {:2}", + self.n, + self.f1, + interrupt_count, + rdtime(), + virtual_seconds(interrupt_count), + )); + } +} + +fn wait(interrupt_count_to_wait: ICount, count: &mut ICount) { + for _ in 0..interrupt_count_to_wait { + unsafe { asm!("wfi") } + (*count) += 1; + } +} + +fn virtual_seconds(interrupt_count: ICount) -> f32 { + (interrupt_count as f32) / (INTERRUPTS_PER_VIRT_SEC as f32) +} + +#[allow(unused_assignments)] +fn rdtime() -> u64 { + let mut upper: u32 = 0; + let mut lower: u32 = 0; + let mut upper_reread: u32 = 0; + loop { + unsafe { + asm!( + "rdtimeh {upper} + rdtime {lower} + rdtimeh {upper_reread}", + upper = out (reg) upper, + lower = out (reg) lower, + upper_reread = out (reg) upper_reread, + ) + } + if upper_reread == upper { + break; + } + } + ((upper as u64) << 32) | (lower as u64) +} + +#[no_mangle] +pub fn main() { + static mut HEAP: [u8; 4096] = [0; 4096]; + unsafe { + allocator::ALLOCATOR.init(HEAP.as_mut_ptr() as _, HEAP.len()); + } + + let _ = kata_sdk_log("Fibonacci"); + let mut interrupt_count: ICount = 0; + let mut fib = Fibonacci::new(); + loop { + wait(INTERRUPTS_PER_WAIT, &mut interrupt_count); + if fib.n >= LOG_FIBONACCI_LIMIT { + fib.reset(); + } + fib.log(interrupt_count); + fib.increment(); + } +} diff --git a/apps/rust/hello/Cargo.toml b/apps/rust/hello/Cargo.toml index cfaa5ee..369c9c1 100644 --- a/apps/rust/hello/Cargo.toml +++ b/apps/rust/hello/Cargo.toml @@ -35,4 +35,6 @@ crate-type = ["staticlib"] [dependencies] cstr_core = { version = "0.2.3", default-features = false } kata-os-common = { path = "../../system/components/kata-os-common", default-features = false } +kata-sdk-interface = { path = "../../system/components/SDKRuntime/kata-sdk-interface" } +libkata = { path = "../libkata" } log = "0.4" diff --git a/apps/rust/hello/Makefile b/apps/rust/hello/Makefile index 8ce6e77..54f1609 100644 --- a/apps/rust/hello/Makefile +++ b/apps/rust/hello/Makefile @@ -1,24 +1,18 @@ -OUT_KATA ?= $(OUT)/kata/riscv32-unknown-elf/release -OUT_HELLO ?= $(OUT_KATA)/apps/hello -CARGO_OPTS ?= --release +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. -# hello app staticlib (location set w/ --out-dir below) -LIB_HELLO := ${OUT_HELLO}/libhello.a -# To satisfy Rust core deps with debug build -LIB_LIBC := ${OUT_KATA}/musllibc/build-temp/stage/lib/libc.a +APPNAME := hello -LD_FLAGS := -march=rv32imac -mabi=ilp32 -static -nostdlib -ftls-model=local-exec -#DBG:=-g - -# NB: let cargo handle incremental build steps -${OUT_HELLO}/hello.elf: hello.rs | tmp_check - SEL4_OUT_DIR=${OUT_KATA}/kernel kcargo build ${CARGO_OPTS} --target-dir ${OUT_HELLO} --out-dir ${OUT_HELLO} - riscv32-unknown-elf-gcc ${LD_FLAGS} $(DBG) ${LIB_HELLO} ${LIB_LIBC} -o ${OUT_HELLO}/hello.elf - -tmp_check: - mkdir -p $(OUT_HELLO) - -clean: - rm -rf ${OUT_HELLO} - -PHONY: tmp_check +LIBKATA ?= ../libkata +include ${LIBKATA}/make/app.mk diff --git a/apps/rust/hello/hello.rs b/apps/rust/hello/hello.rs index f168a26..2a91bd3 100644 --- a/apps/rust/hello/hello.rs +++ b/apps/rust/hello/hello.rs @@ -5,83 +5,33 @@ */ #![no_std] #![no_main] -#![feature(asm)] -#![feature(thread_local)] - -// TODO(sleffler): plumb logger to SDKRuntime to eliminate seL4_DebugPutChar -// (or provide a logger alternative) +extern crate libkata; use kata_os_common::logger::KataLogger; -use kata_os_common::sel4_sys; - -use sel4_sys::seL4_IPCBuffer; - -const PAGE_SIZE: usize = 4096; - -#[no_mangle] -#[thread_local] -static mut __sel4_ipc_buffer: *mut seL4_IPCBuffer = 0 as _; - -#[repr(align(4096))] -#[allow(dead_code)] -struct PageAlign { - data: [u8; PAGE_SIZE], -} -static mut STATIC_TLS: PageAlign = PageAlign { - data: [0u8; PAGE_SIZE], -}; - -#[no_mangle] -pub fn _start() { - unsafe { - asm!(" - .option push - .option norelax - la gp, __global_pointer$ - la tp, {tls} - lui t1,0 - add t1,t1,tp - sw a0,0(t1) # __sel4_ipc_buffer> - addi sp,sp,-16 - sw a0, 12(sp) - sw a1, 8(sp) - sw a2, 4(sp) - sw a3, 0(sp) - .option pop - j main", - tls = sym STATIC_TLS, - options(noreturn), - ) - }; -} +use kata_sdk_interface::*; +use log::info; // Message output is sent through the kata-os-logger which calls logger_log -// to deliver data to the console. We use seL4_DebugPutChar to write to the -// console which only works if DEBUG_PRINTING is enabled in the kernel. +// to deliver data to the console. Redict to the sdk. #[no_mangle] #[allow(unused_variables)] pub fn logger_log(_level: u8, msg: *const cstr_core::c_char) { - #[cfg(feature = "CONFIG_PRINTING")] - unsafe { - for c in cstr_core::CStr::from_ptr(msg).to_bytes() { - let _ = sel4_sys::seL4_DebugPutChar(*c); - } - let _ = sel4_sys::seL4_DebugPutChar(b'\n'); + if let Ok(str) = unsafe { cstr_core::CStr::from_ptr(msg) }.to_str() { + let _ = kata_sdk_log(str); } } #[no_mangle] -// XXX need SDK specification of main, use hack for now -pub fn main(a0: u32, a1: u32, a2: u32, a3: u32) { - // Setup logger; (XXX belongs in the SDKRuntime) +pub fn main() { + // Setup logger; (XXX maybe belongs in the SDKRuntime) static KATA_LOGGER: KataLogger = KataLogger; log::set_logger(&KATA_LOGGER).unwrap(); log::set_max_level(log::LevelFilter::Trace); - // XXX maybe setup a heap (XXX belongs in the SDKRuntime) - - log::info!("I am a Rust app, hear me roar!"); - log::info!("a0 {:x} a1 {:x} a2 {:x} a3 {:x}", a0, a1, a2, a3); - log::info!("__sel4_ipc_buffer {:p}", unsafe { __sel4_ipc_buffer }); - log::info!("Done, wimper ..."); + match kata_sdk_ping() { + Ok(_) => info!("ping!"), + Err(e) => info!("kata_sdk_ping failed: {:?}", e), + } + info!("I am a Rust app, hear me log!"); + info!("Done, wimper ..."); } diff --git a/apps/rust/libkata/Cargo.toml b/apps/rust/libkata/Cargo.toml new file mode 100644 index 0000000..0c47d25 --- /dev/null +++ b/apps/rust/libkata/Cargo.toml @@ -0,0 +1,25 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +[package] +name = "libkata" +version = "0.1.0" +edition = "2021" + +[lib] +path = "lib.rs" + +[dependencies] +sel4-sys = { path = "../../system/components/kata-os-common/src/sel4-sys", default-features = false } +static_assertions = "1.1" diff --git a/apps/rust/libkata/arch/riscv32/crt0.S b/apps/rust/libkata/arch/riscv32/crt0.S new file mode 100644 index 0000000..5dec66d --- /dev/null +++ b/apps/rust/libkata/arch/riscv32/crt0.S @@ -0,0 +1,78 @@ +/* + * Copyright 2022 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + .section .text._start + .align 2 + .globl _start + .type _start, @function +_start: + .option push + .option norelax + + la gp, __global_pointer$ + la x4, _tls + + /* Setup __sel4_ipc_buffer */ + lui t1, 0 + add t1, t1, tp + sw a0, 0(t1) + + /* Setup SDKRuntime RPC framework */ + + /* seL4_CPtr to SDKRuntime Endpoint */ + la t1, KATA_SDK_ENDPOINT + sw a1, 0(t1) + + /* seL4_CPtr to KATA_SDK_PARAMS Frame object */ + la t1, KATA_SDK_FRAME + sw a2, 0(t1) + + /* virtual address of KATA_SDK_PARAMS */ + la t1, KATA_SDK_PARAMS + sw a3, 0(t1) + + /* XXX included only for testing */ + addi sp, sp, -16 + sw a0, 12(sp) + sw a1, 8(sp) + sw a2, 4(sp) + sw a3, 0(sp) + + .option pop + + j main + + .section .bss + .align 12 + .globl _tls + .type _tls, tls_object +_tls: + .ds.b 4096 + + .align 2 + .global KATA_SDK_ENDPOINT +KATA_SDK_ENDPOINT: + .ds.b 4 + + .align 2 + .global KATA_SDK_FRAME +KATA_SDK_FRAME: + .ds.b 4 + + .align 2 + .global KATA_SDK_PARAMS +KATA_SDK_PARAMS: + .ds.b 4 diff --git a/apps/rust/libkata/lib.rs b/apps/rust/libkata/lib.rs new file mode 100644 index 0000000..c86aef1 --- /dev/null +++ b/apps/rust/libkata/lib.rs @@ -0,0 +1,54 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#![no_std] +#![allow(non_upper_case_globals)] +#![feature(global_asm)] +#![feature(thread_local)] + +use core::arch::global_asm; +use sel4_sys::seL4_IPCBuffer; +use static_assertions::*; + +// NB: this mimics the logic in build.rs +assert_cfg!(any( + all(target_arch = "arm", target_pointer_width = "32"), + all(target_arch = "aarch64"), + all(target_arch = "riscv32"), + all(target_arch = "riscv64"), + all(target_arch = "x86"), + all(target_arch = "x86_64"), +)); + +#[cfg(target_arch = "x86")] +global_asm!(include_str!("arch/x86/crt0.S")); + +#[cfg(target_arch = "x86_64")] +global_asm!(include_str!("arch/x86_64/crt0.S")); + +#[cfg(all(target_arch = "arm", target_pointer_width = "32"))] +global_asm!(include_str!("arch/aarch32/crt0.S")); + +#[cfg(target_arch = "aarch64")] +global_asm!(include_str!("arch/aarch64/crt0.S")); + +#[cfg(target_arch = "riscv32")] +global_asm!(include_str!("arch/riscv32/crt0.S")); + +#[cfg(target_arch = "riscv64")] +global_asm!(include_str!("arch/riscv64/crt0.S")); + +#[no_mangle] +#[thread_local] +static mut __sel4_ipc_buffer: *mut seL4_IPCBuffer = 0 as _; diff --git a/apps/rust/libkata/make/app.mk b/apps/rust/libkata/make/app.mk new file mode 100644 index 0000000..16b65e0 --- /dev/null +++ b/apps/rust/libkata/make/app.mk @@ -0,0 +1,35 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +MYDIR := $(dir $(realpath $(lastword $(MAKEFILE_LIST)))) + +include $(MYDIR)/common.mk + +BUILD_DIR := $(BUILD_ROOT)/$(APPNAME) +INTERMEDIATES := ${BUILD_DIR}/lib${APPNAME}.a + +$(BUILD_DIR)/$(APPNAME).elf: lib${APPNAME} ${LIB_LIBC} | $(BUILD_DIR) + $(LD) $(LDFLAGS) -o $(BUILD_DIR)/$(APPNAME).elf $(INTERMEDIATES) $(LIB_LIBC) + +lib${APPNAME}: + SEL4_OUT_DIR=${OUT_KATA}/kernel \ + ${CARGO} build ${CARGO_OPTS} --target-dir ${BUILD_DIR} --out-dir ${BUILD_DIR} + +$(BUILD_DIR): + mkdir -p $(BUILD_DIR) + +clean: + rm -rf $(BUILD_DIR) + +.PHONY: clean lib${APPNAME} diff --git a/apps/rust/libkata/make/arch/riscv32.mk b/apps/rust/libkata/make/arch/riscv32.mk new file mode 100644 index 0000000..64b3016 --- /dev/null +++ b/apps/rust/libkata/make/arch/riscv32.mk @@ -0,0 +1,20 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +BASE_ARCH_NAME := riscv +ARCH_BITS := 32 +FULL_ARCH_NAME := riscv32imac +ARCH_PREFIX := riscv32-unknown-elf +ARCH := rv32imac +ABI := ilp32 diff --git a/apps/rust/libkata/make/common.mk b/apps/rust/libkata/make/common.mk new file mode 100644 index 0000000..6eecd1c --- /dev/null +++ b/apps/rust/libkata/make/common.mk @@ -0,0 +1,56 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +MYDIR := $(dir $(realpath $(lastword $(MAKEFILE_LIST)))) + +BUILD_TYPE ?= debug +BUILD_ARCH ?= riscv32 + +include $(MYDIR)/arch/$(BUILD_ARCH).mk +include $(MYDIR)/sel4.mk + +ifeq ($(BUILD_TYPE),debug) + DEBUG := -g + OPT := -O0 + CARGO_OPTS := +else + DEBUG := + OPT := -O0 # TODO(jtgans): Actually optimize in a release build + CARGO_OPTS := --release +endif + +ROOTDIR ?= $(MYDIR) +BUILD_ROOT ?= $(ROOTDIR)/out/kata/$(ARCH_PREFIX)/$(BUILD_TYPE)/apps/rust + +CC := $(ARCH_PREFIX)-gcc +AS := $(ARCH_PREFIX)-as +AR := $(ARCH_PREFIX)-ar +LD := $(ARCH_PREFIX)-gcc + +KATA_RUST_VERSION ?= nightly-2021-11-05 +CARGO := cargo +${KATA_RUST_VERSION} + +CFLAGS := $(DEBUG) $(OPT) $(INCLUDES) +CFLAGS += -march=$(ARCH) -mabi=$(ABI) +CFLAGS += -std=gnu11 -nostdlib +CFLAGS += -ftls-model=${TLS_MODEL} + +ASFLAGS := -march=$(ARCH) -mabi=$(ABI) +LDFLAGS := $(DEBUG) -nostartfiles -static -nostdlib + +CARGO_OPTS += -Z unstable-options +CARGO_OPTS += -Z avoid-dev-deps +# XXX RUSTFLAGS is the only way to pass tls-model but seems to work w/o +#CARGO_OPTS += -Z tls-model=${TLS_MODEL} +CARGO_OPTS += --target ${FULL_ARCH_NAME}-unknown-none-elf diff --git a/apps/rust/libkata/make/sel4.mk b/apps/rust/libkata/make/sel4.mk new file mode 100644 index 0000000..c28e1e6 --- /dev/null +++ b/apps/rust/libkata/make/sel4.mk @@ -0,0 +1,16 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +OUT_KATA ?= $(OUT)/kata/$(ARCH_PREFIX)/$(BUILD_TYPE) +TLS_MODEL := local-exec