KMC 京都マイクロコンピュータ株式会社

> rustup target add aarch64-unknown-none

> cargo new --bin hello
     Created binary (application) `hello` package
> cd hello
> cargo run
   Compiling hello v0.1.0 (...\hello)
    Finished dev [unoptimized + debuginfo] target(s) in 0.33s
     Running `target\debug\hello.exe`
Hello, world!

> cd ..
> del -recurse hello
> cargo new --lib hello
     Created library `hello` package
> cd hello

[package]
name = "hello"
version = "0.1.0"
edition = "2018"

# 以下を追加
[lib]
crate-type = ["staticlib"]

// 標準ライブラリはcore, alloc, stdという部分に分かれている。
// デフォルトではすべてにリンクするが、フリースタンディングターゲットでは
// stdが存在しないので、stdへの依存を明示的に取り除く。
#![no_std]

// `hello` というシンボル名でそのまま出す (名前をマングリングしない)
#[no_mangle] 
// Cと互換な呼出し規約を使用する
extern "C" fn hello(x: usize) -> usize {
    // 最後の式の値が返り値として返される
    x + 42
}

// 配列の境界外アクセスなどの深刻な実行時エラーが検出されると呼び出されます。
#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
    loop {}
}

> cargo build --release --target aarch64-unknown-none
   Compiling hello v0.1.0 (...\hello)
    Finished release [optimized] target(s) in 0.11s
> dir .\target\aarch64-unknown-none\release\libhello.a

    Directory: ...\hello\target\aarch64-unknown-none\release

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a---           6/10/2021  5:15 PM        6101052 libhello.a

> aarch64-kmc-elf-objdump -d target\aarch64-unknown-none\release\libhello.a
In archive .\target\aarch64-unknown-none\release\libhello.a:

hello-d3e497bdb33a28f9.hello.9l5nt8y9-cgu.0.rcgu.o:     file format elf64-littleaarch64


Disassembly of section .text.hello:

0000000000000000 <hello>:
   0:   9100a800        add     x0, x0, #0x2a
   4:   d65f03c0        ret

   ⋮

use core::mem::MaybeUninit;

// データ型
type int_t = i32;
type uint_t = u32;
type ATR = uint_t;
type TASK = Option<unsafe extern "C" fn(EXINF)>;
type EXINF = MaybeUninit<isize>;
type PRI = int_t;
type ER_ID = int_t;

#[derive(Debug, Clone, Copy)]
#[repr(C)]
struct T_CTSK {
    /// タスク属性
    tskatr: ATR,
    /// タスクの拡張情報
    exinf: EXINF,
    /// タスクのメインルーチンの先頭番地
    task: TASK,
    /// タスクの起動時優先度
    itskpri: PRI,
    /// タスクのスタック領域のサイズ
    stksz: usize,
    /// タスクのスタック領域の先頭番地
    stk: *mut u8,
}

/// タスクを起動された状態で生成
const TA_ACT: ATR = 0x01;

extern "C" {
    fn acre_tsk(pk_ctsk: *const T_CTSK) -> ER_ID;
}

extern "C" fn hello(x: usize) -> usize {
    // 関数の中で関数を定義できる
    // (効果はトップレベルで定義するのと同じだが、外からはこの関数は
    // アクセスできない)
    extern "C" fn task_body(_: EXINF) {}

    let er = unsafe {
        acre_tsk(&T_CTSK {
            tskatr: TA_ACT,
            exinf: MaybeUninit::uninit(),
            task: Some(task_body),
            itskpri: 4,
            stksz: 2048,
            stk: core::ptr::null_mut(),
        })
    };

    er as usize
}

> cargo install bindgen

> cd asp3
> bindgen include\kernel.h -- -Iinclude -Itarget\gr_peach_gcc -Iarch\arm_gcc\common\ -Iarch\arm_gcc\rza1 -Iarch\gcc

   ⋮
pub type va_list = *mut ::std::os::raw::c_char;
extern "C" {
    pub fn __va_start(arg1: *mut *mut ::std::os::raw::c_char, ...);
}
   ⋮
pub type T_EXCINF = t_excinf;
pub type FLGPTN = uint_t;
pub type INTNO = uint_t;
pub type INHNO = uint_t;
pub type EXCNO = uint_t;
pub type TASK = ::std::option::Option<unsafe extern "C" fn(exinf: EXINF)>;
pub type TMEHDR = ::std::option::Option<unsafe extern "C" fn(exinf: EXINF)>;
pub type ISR = ::std::option::Option<unsafe extern "C" fn(exinf: EXINF)>;
   ⋮

/// タスクを起動された状態で生成
pub const TA_ACT: ATR = 0x01;

extern "C" {
    /// タスクの生成 (ID自動割当て)
    pub fn acre_tsk(pk_ctsk: *const T_CTSK) -> ER_ID;
}

[dependencies]
itron = { version = "0.1.0", features = ["asp3", "dcre"] }

use core::mem::MaybeUninit;
use itron::abi::{acre_tsk, TA_ACT, T_CTSK, EXINF};

extern "C" fn hello(x: usize) -> usize {
    extern "C" fn task_body(_: EXINF) {}

    let er = unsafe {
        acre_tsk(&T_CTSK {
            tskatr: TA_ACT,
            exinf: MaybeUninit::uninit(),
            task: Some(task_body),
            itskpri: 4,
            stksz: 2048,
            stk: core::ptr::null_mut(),
        })
    };

    er as usize
}

enum Stack {
    Auto { size: usize },
    // タスクは `new_task` が返った後も生き残り、またいつ削除されるか分からないので、
    // 渡されるスタック領域は `&'static ...` でなければならない。`& ...` としてしまうと、
    // `new_task` が返った後に、作成したタスクのスタック領域を呼出し元が破壊できてしまう。
    Manual(&'static mut [MaybeUninit<u8>]),
}

#[inline]
fn new_task(
    // `TASK` とは異なり、ここには `unsafe` は付けない。
    // もしも `unsafe` を付けてしまうと、呼び出し側は `unsafe fn` を
    // 渡すことができ、`unsafe { ... }` ブロックを使わずにそうした関数を
    // 実行させることができてしまう。
    body: extern "C" fn(EXINF),
    exinf: EXINF,
    itskpri: PRI,
    stk: Stack,
) -> ER_ID {
    let (stk, stksz) = match stk {
        Stack::Auto { size } => (core::ptr::null_mut(), size),
        Stack::Manual(slice) => (slice.as_mut_ptr() as _, slice.len()),
    };

    // `unsafe` ブロックの前でなぜメモリ安全性が保証されるかを説明するのが慣習です。

    // Safety: ここで渡す `*const T_CTSK` の参照先は呼出しの期間中は有効。
    //         `stk` が non-null である場合、`stk[0..stksz]` の所有権は
    //         呼出し側が持っていたもので、これをカーネルに渡す。呼出し後に所有
    //         権は返ってこないが、`stk` は `&'static mut _` なのでこれでOK。
    //         `body` は `unsafe fn` ではないので、`body` の呼出しに関して
    //         メモリ安全性のために満たされるべき前提条件はない。
    // Assumptions: `acre_tsk` はTOPPERSカーネル仕様にしたがって実装されており、
    //              カーネル動作状態であり、カーネル管理外割り込みハンドラから
    //              呼び出されていないと仮定する。また、`body` は実行中にタスクの
    //              スタックをオーバフローしないと仮定する。
    unsafe {
        acre_tsk(&T_CTSK {
            tskatr: TA_ACT,
            exinf,
            task: Some(body),
            itskpri,
            stksz,
            stk,
        })
    }
}

extern "C" fn hello(x: usize) -> usize {
    extern "C" fn task_body(_: EXINF) {}

    let er = new_task(
        task_body,
        MaybeUninit::uninit(),
        4,
        Stack::Auto { size: 2048 },
    );

    er as usize
}

new_task(unreachable, MaybeUninit::uninit(), 4, Stack::Auto { size: 2048 });

/// Safety: This function is never safe to call.
unsafe extern "C" fn unreachable(_: EXINF) {
    core::hint::unreachable_unchecked()
}

error[E0308]: mismatched types
  --> <source>:40:9
   |
40 |         unreachable, 
   |         ^^^^^^^^^^^ expected normal fn, found unsafe fn
   |
   = note: expected fn pointer `extern "C" fn(MaybeUninit<_>)`
                 found fn item `unsafe extern "C" fn(MaybeUninit<_>) {unreachable}`

fn create_tasks_with_stack(stack: &'static mut [MaybeUninit<u8>]) {
    new_task(hoge, MaybeUninit::uninit(), 4, Stack::Manual(stack));
    new_task(hoge, MaybeUninit::uninit(), 4, Stack::Manual(stack));
}

error[E0499]: cannot borrow `*stack` as mutable more than once at a time
  --> <source>:40:60
   |
39 |     new_task(hoge, MaybeUninit::uninit(), 4, Stack::Manual(stack));
   |                                                            -----
   |                                                            |
   |                                                            first mutable borrow occurs here
   |                                                            requires that `*stack` is borrowed for `'static`
40 |     new_task(hoge, MaybeUninit::uninit(), 4, Stack::Manual(stack));
   |                                                            ^^^^^ second mutable borrow occurs here

let mut stack = [MaybeUninit::uninit(); 512];
new_task(hoge, MaybeUninit::uninit(), 4, Stack::Manual(&mut stack));
// `stack` はスタック上に確保されているので、ここで寿命が尽きてしまう

error[E0597]: `stack` does not live long enough
  --> <source>:40:60
   |
40 |     new_task(hoge, MaybeUninit::uninit(), 4, Stack::Manual(&mut stack));
   |                                                            ^^^^^^^^^^
   |                                                            |
   |                                                            borrowed value does not live long enough
   |                                                            cast requires that `stack` is borrowed for `'static`
41 | }
   | - `stack` dropped here while still borrowed

match stk {
    Stack::Manual(slice) => {
        // "core::mem::maybe_uninit::MaybeUninit<u8>"
        dbg!(slice[0]);     

        // 初期化されていれば値を出力、初期化されていなければ未定義動作
        dbg!(unsafe { slice[0].assume_init() });  
    }
    _ => {}
}