グリーンスレッドの自作に必要なものは何か

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 1..10 {
            // やあ！立ち上げたスレッドから数字{}だよ！
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        // メインスレッドから数字{}だよ！
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
}

static mut CONTEXTS: LinkedList<Box<Context>> = LinkedList::new();

struct Context {
    regs: Registers,      // レジスタ
    stack: *mut u8,       // スタック
    stack_layout: Layout, // スタックレイアウト
    entry: Entry,         // エントリポイント
    id: u64,              // スレッドID
}

pub fn spawn(func: Entry, stack_size: usize) -> u64 {
    // <1>
    unsafe {
        let id = get_id(); // <2>
        CONTEXTS.push_back(Box::new(Context::new(func, stack_size, id))); // <3>
        schedule(); // <4>
        id // <5>
    }
}

pub fn schedule() {
    unsafe {
        // 実行可能なプロセスが自身のみであるため即座にリターン <1>
        if CONTEXTS.len() == 1 {
            return;
        }

        // 自身のコンテキストを実行キューの最後に移動
        let mut ctx = CONTEXTS.pop_front().unwrap(); // <2>
                                                     // レジスタ保存領域へのポインタを取得 <3>
        let regs = ctx.get_regs_mut();
        CONTEXTS.push_back(ctx);

        // レジスタを保存 <4>
        if set_context(regs) == 0 {
            // 次のスレッドにコンテキストスイッチ
            let next = CONTEXTS.front().unwrap();
            switch_context((**next).get_regs());
        }

        // 不要なスタック領域を削除
        rm_unused_stack(); // <5>
    }
}

extern "C" {
    fn set_context(ctx: *mut Registers) -> u64;
    fn switch_context(ctx: *const Registers) -> !;
}

#define SET_CONTEXT set_context
#define SWITCH_CONTEXT switch_context

SET_CONTEXT:
        pop     %rbp
        xor     %eax, %eax      /* Direct invocation returns 0 */

        movq    %rbx, (%rdi)
        movq    %rbp, 8(%rdi)
        movq    %r12, 16(%rdi)
        movq    %r13, 24(%rdi)
        movq    %r14, 32(%rdi)
        movq    %r15, 40(%rdi)
        lea     8(%rsp), %rdx
        movq    %rdx, 48(%rdi)
        push    %rbp
        movq    (%rsp), %rdx
        movq    %rdx, 56(%rdi)
        ret

SWITCH_CONTEXT:
        xor     %eax, %eax
        inc     %eax            /* Return 1 instead */

        pop     %rsi
        movq    (%rdi), %rbx
        movq    8(%rdi), %rbp
        movq    16(%rdi), %r12
        movq    24(%rdi), %r13
        movq    32(%rdi), %r14
        movq    40(%rdi), %r15
        movq    48(%rdi), %rdx
        movq    %rdx, %rsp
        addq    $0x8, %rsp
        push    %rbp
        push    %rsi
        movq    56(%rdi), %rdx
        jmpq    *%rdx

CONTEXTS.push_back(Box::new(Context::new(func, stack_size, id)));

fn new(func: Entry, stack_size: usize, id: u64) -> Self {
        // <4>
        // スタック領域の確保 <5>
        let layout = Layout::from_size_align(stack_size, PAGE_SIZE).unwrap();
        let stack = unsafe { alloc(layout) };

        // ガードページの設定 <6>
        unsafe { mprotect(stack as *mut c_void, PAGE_SIZE, ProtFlags::PROT_NONE).unwrap() };

        // レジスタの初期化 <7>
        let regs = Registers::new(stack as u64 + stack_size as u64);

        // コンテキストの初期化
        Context {
            regs: regs,
            stack: stack,
            stack_layout: layout,
            entry: func,
            id: id,
        }
    }

#[repr(C)] // <1>
struct Registers {
    rbx: u64,
    rbp: u64,
    r12: u64,
    r13: u64,
    r14: u64,
    r15: u64,
    rsp: u64,
    rdx: u64,
}

impl Registers {
    // <3>
    fn new(rsp: u64) -> Self {
        Registers {
            rbx: 0,
            rbp: 0,
            r12: 0,
            r13: 0,
            r14: 0,
            r15: 0,
            rsp,
            rdx: entry_point as u64, // <4>
        }
    }
}

#[no_mangle]
pub extern "C" fn entry_point() {
    unsafe {
        // 指定されたエントリ関数を実行 <1>
        let ctx = CONTEXTS.front().unwrap();
        ((**ctx).entry)();

        // 以降がスレッド終了時の後処理

        // 自身のコンテキストを取り除く
        let ctx = CONTEXTS.pop_front().unwrap();

        // スレッドIDを削除
        (*ID).remove(&ctx.id);

        // 不要なスタック領域として保存
        // この段階で解放すると、以降のコードでスタックが使えなくなる
        UNUSED_STACK = ((*ctx).stack, (*ctx).stack_layout); // <2>

        match CONTEXTS.front() {
            // <3>
            Some(c) => {
                // 次のスレッドにコンテキストスイッチ
                switch_context((**c).get_regs());
            }
            None => {
                // すべてのスレッドが終了した場合、main関数のスレッドに戻る
                if let Some(c) = &CTX_MAIN {
                    switch_context(&**c as *const Registers);
                }
            }
        };
    }
    panic!("entry_point"); // <4>
}

#[no_mangle]
pub extern "C"

let ctx = CONTEXTS.front().unwrap();
((**ctx).entry)();

movq    %rdx, 56(%rdi)

movq    56(%rdi), %rdx
jmpq    *%rdx

fn switch_context(ctx: *const Registers) -> !;