HN 日本語サマリー

← 一覧へ戻る
プログラミング

stinkarm をより少なく臭わせる、あるいはもっと臭わせるか?

Making stinkarm stink less, or more? (xnacly.me)

6 pointsby xnacly1 コメント

要約

この記事は、Rustで書かれたARMv7ユーザーモードエミュレータ「stinkarm」の改善点について論じています。以前のバージョンでは複雑だったメモリ変換処理を、4ギガバイトのスラブメモリを割り当ててゲストプロセス領域をマッピングし、その領域へのポインタをゲストに渡すという、よりシンプルで効率的な方法に置き換えました。また、不正なアドレスへのアクセスを防ぐための境界チェックを強化し、デコードルールをコンパイル時定数リストとして定義することで、命令デコードの柔軟性を向上させています。

全文翻訳

stinkarm の臭いを減らす、あるいは増やす?

[画像: acorn, armv7-a and stinkarm](https://xnacly.me/posts/2026/making-stinkarm-stink-less/#fn:1)

しばらくぶりですが、約半年前、ユーザー空間のARMv7エミュレータを一から実装するという記事を書きました。つまり、以下のものを実装しました。

ARMASM

 1    .section .rodata
 2msg:
 3    .asciz "Hello, world!\n"
 4
 5    .section .text
 6    .global _start
 7_start:
 8    ldr r0, =1
 9    ldr r1, =msg
10    mov r2, #14
11    mov r7, #4
12    svc #0
13
14    mov r0, #0
15    mov r7, #1
16    svc #0

リスト形式では以下のようになります。

  • ELF(32) のパース、検証、解釈
  • ARMv7 命令の非常に小さなサブセット(3つのみ)のデコード
  • 条件付き命令を含む、これらの命令の実行 🤓
  • ゲストからホストへのメモリアクセスの翻訳
  • システムコールフォワーディング(ARMv7 から x86 へ)
  • システムコールサンドボックス化(制限されたサブセットのみ)とシステムコール実行の拒否

前回の記事ほど詳細には踏み込まないため、「ゼロから最小限のARMv7エミュレータを構築する」 を読むことをお勧めします(3ヶ月ぶりの執筆で、書くモチベーションが湧いたのはこれが初めてです :O)。これは一部アップデートであり、ARMv7-A のデコードとエミュレーションに関する私の考え、そして少し開発ログでもあります。

過度に複雑なホストからゲストへのメモリ翻訳

最初のエントリに対して、lobste.rs の ~aengelke から次のようなコメントがありました。

[…]メモリの間接参照は非常に非効率に見えます。32ビットプラットフォームを64ビットシステムでエミュレートする場合、単に4GiBの領域をmmapすれば、翻訳は単一の加算になります。そうでなければ、最近翻訳されたアドレス領域の小さなハッシュテーブルを持つことで、より高価な検索を回避できます。メモリアクセスは非常に高い局所性を持っています。マッピングの数は通常少ないため、ソートされた配列に対するバイナリ検索はBツリーよりも簡単です。[…]

そこで、実装を少し改善することにしました。まず、複雑なアロケーション領域ベースの追跡を、ゲストのためにメモリに4ギガバイトのスラブを割り当て、そこにプロセス領域をマッピングし、その領域へのポインタをゲストに渡すという方法に置き換えます。

以前は、メモリ翻訳は次のように機能していました。

  1. ゲストの開始アドレスからホストセグメントへのバイナリツリーマップを取得します。

RUST

 1struct MappedSegment {
 2    host_ptr: *mut u8,
 3    len: u32,
 4}
 5
 6pub struct Mem {
 7    maps: BTreeMap<u32, MappedSegment>,
 8}
  1. 領域のハンドアウト(特にELFセグメントを開始アドレスでマッピングする際)を要求すると、map_region が呼び出されます。

RUST

  1// stinkarm::elf::pheader::Pheader::map 内:
  2
  3// CPUがゲストVaddrをホストポインタに変換できるように、ゲストメモリテーブルにマッピングを記録します
  4guest_mem.map_region(self.vaddr, len, segment_ptr);
  5
  6// stinkarm::mem::Mem 内:
  7
  8pub fn map_region(&mut self, guest_addr: u32, len: u32, host_ptr: *mut u8) {
  9    self.maps
 10        .insert(guest_addr, MappedSegment { host_ptr, len });
 11}
  1. CPUは命令を取得する必要があるため、read_u32 を呼び出し、それが translate を呼び出します。

RUST

  1/// ゲストアドレスを書き込みおよび読み取り可能なホストアドレスに翻訳します
  2pub fn translate(&self, guest_addr: u32) -> Option<*mut u8> {
  3    // guest_addr 以下の最大のキーを見つけます。
  4    let (&base, seg) = self.maps.range(..=guest_addr).next_back()?;
  5    if guest_addr < base.wrapping_add(seg.len) {
  6        let offset = guest_addr.wrapping_sub(base);
  7        Some(unsafe { seg.host_ptr.add(offset as usize) })
  8    } else {
  9        None
 10    }
 11}
 12
 13pub fn read_u32(&self, guest_addr: u32) -> Option<u32> {
 14    let ptr = self.translate(guest_addr)?;
 15    unsafe { Some(u32::from_le(*(ptr as *const u32))) }
 16}
 17
 18
 19// stinkarm::cpu::Cpu 内:
 20
 21pub fn step(&mut self) -> Result<bool, err::Err> {
 22    let Some(word) = self.mem.read_u32(self.pc()) else {
 23        return Ok(false);
 24    };
 25
 26    // [...] 
 27}

もちろん、これは完全に不要な作業です。範囲をウォークしてすべてのマッピング/アロケーション/領域を追跡する必要はありません。必要なのは、R/Wインタラクション要求が範囲内にあることを確認することだけです。したがって、新しい実装は次のようになります。

  1. ポインタとサイズを取得します。

RUST

 1pub struct Mem {
 2    ptr: NonNull<u8>,
 3    len: usize,
 4}
  1. ELFセグメントのマッピングを要求された場合、stinkarm::mem::Mem::map_region が呼び出されます。

RUST

  1// stinkarm::elf::pheader::Pheader::map 内:
  2guest_mem.map_region(self.vaddr, file_slice)?;
  3
  4// stinkarm::mem::Mem 内:
  5
  6pub fn map_region(&mut self, guest_addr: u32, data: &[u8]) -> Result<(), String> {
  7    let dst = self
  8        .get_slice_mut(guest_addr, data.len())
  9        .ok_or_else(|| format!("guest region out of bounds at {guest_addr:#010x}"))?;
 10    dst.copy_from_slice(data);
 11    Ok(())
 12}
  1. CPUがdwordをデコードのために要求する場合、以前と同様に stinkarm::mem::Mem::read32 を呼び出しますが、今回は境界チェックが行われます。

RUST

 1pub fn read_u32(&self, guest_addr: u32) -> Option<u32> {
 2    let bytes = self.get_slice(guest_addr, 4)?;
 3    Some(u32::from_le_bytes(bytes.try_into().unwrap()))
 4}
 5
 6fn get_slice(&self, guest_addr: u32, len: usize) -> Option<&[u8]> {
 7    if !self.in_bounds(guest_addr, len) {
 8        return None;
 9    }
10
11    Some(unsafe { std::slice::from_raw_parts(self.ptr.as_ptr().add(guest_addr as usize), len) })
12}

既存の実装の強化

また、write.2 と exit.2 のシステムコール、ldr、mov、svc の小さな表面積だけでも、信頼されていないゲストアドレスをホストメモリアクセスに翻訳することを可能にする多くのものがあることに気づきました。

write.2 に渡されたアドレスの有効性をチェックすることで、これを防ぎます。これは、stinkarm::mem::Mem で translate_range 呼び出し内の in_bounds 呼び出しを使用して、ゲストアドレスをホストメモリ空間に翻訳する際に行われます。

RUST

 1const NULL_PAGE_SIZE: u32 = 0x1000;
 2
 3impl Mem {
 4    fn in_bounds(&self, guest_addr: u32, len: usize) -> bool {
 5        if guest_addr < NULL_PAGE_SIZE {
 6            return false;
 7        }
 8
 9        let start = guest_addr as usize;
10        let Some(end) = start.checked_add(len) else {
11            return false;
12        };
13
14        end <= self.len
15    }
16
17    pub fn translate_range(&self, guest_addr: u32, len: usize) -> Option<*mut u8> {
18        if !self.in_bounds(guest_addr, len) {
19            return None;
20        }
21
22        Some(self.ptr.as_ptr().wrapping_add(guest_addr as usize))
23    }
24}

NULLポインタの書き込み、ゲストメモリ外への書き込み、0x0へのELFセグメントのロードを正しく捕捉するための複数のテストを追加しました。

ARMASM

 1    .section .rodata
 2msg:
 3    .ascii "ignored"
 4
 5    .section .text
 6    .global _start
 7_start:
 8    mov r0, #1
 9    mov r1, #0
10    mov r2, #7
11    mov r7, #4
12    svc #0
13
14    mov r0, #0
15    mov r7, #1
16    svc #0

ARMASM

 1    .section .rodata
 2msg:
 3    .ascii "ignored"
 4
 5    .section .text
 6    .global _start
 7_start:
 8    mov r0, #1
 9    ldr r1, =0x08000000
10    mov r2, #7
11    mov r7, #4
12    svc #0
13
14    mov r0, #0
15    mov r7, #1
16    svc #0

DSLにするか、しないか

以前は、デコードするためにすべてのオペコードとそのフィールドをハードコーディングしていましたが、現在はオペコードのみがデコードの対象です。これは、コンパイル時に定義されたパターンリストを使用して実現されます。

RUST

 1const DECODE_RULES: &[ArmRule] = &[
 2    arm_rule!(Svc {
 3        bits(27..24 = 0b1111),
 4    }),
 5    arm_rule!(Branch {
 6        bits(27..25 = 0b101),
 7    }),
 8    // LDR literal: `ldr Rt, [pc, #imm12]`.
 9    arm_rule!(LdrLiteral {
10        bits(27..26 = 0b01), // load/store class
11        bit(24 = 1),         // P: pre-indexed address
12        bit(23 = 1),         // U: add positive offset
13        bit(22 = 0),         // B: word transfer, not byte
14        bit(21 = 0),         // W: no writeback
15        bit(20 = 1),         // L: load, not store
16        bits(19..16 = 15),   // Rn: base register is pc/r15
17    }),
18    // MOV immediate: data-processing immediate with opcode 1101.
19    arm_rule!(MovImm {
20        bits(27..25 = 0b001),
21        bits(24..21 = Op::Mov as u32),
22    }),
23];

ARMv7命令エンコーディングに興味がある場合は、ARM® Architecture Reference Manual ARMv7-A and ARMv7-R edition をお勧めします。

このマクロ自体はビットパターンを構築し、単純なANDビット命令で使用して検出できます。

RUST

 1macro_rules! arm_rule {
 2    ($kind:ident { $($field:ident($($args:tt)*)),* $(,)? }) => {
 3        ArmRule {
 4            kind: InstructionKind::$kind,
 5            mask: 0 $(| arm_mask!($field($($args)*)))*,
 6            value: 0 $(| arm_value!($field($($args)*)))*,
 7        }
 8    };
 9}
10
11macro_rules! arm_mask {
12    (bit($bit:literal = $value:expr)) => {
13        1u32 << $bit
14    };
15    (bits($high:literal .. $low:literal = $value:expr)) => {
16        ((1u32 << ($high - $low + 1)) - 1) << $low
17    };
18}
19
20macro_rules! arm_value {
21    (bit($bit:literal = $value:expr)) => {
22        ($value as u32) << $bit
23    };
24    (bits($high:literal .. $low:literal = $value:expr)) => {
25        ($value as u32) << $low
26    };
27}

したがって、MovImm の定義は次のような結果になります(Op::mov は 0b1101 として定義されています)。

RUST

 1ArmRule {
 2    kind: InstructionKind::MovImm,
 3    mask: 0 
 4        | ((1u32 << (27 - 25 + 1)) - 1) << 25 
 5        | ((1u32 << (24 - 21 + 1)) - 1) << 21,
 6    value: 0 
 7        | (0b001 as u32) << 25 
 8        | ((Op::Mov as u32) as u32) << 21,
 9}
10
11
12impl ArmRule {
13    fn matches(&self, word: u32) -> bool {
14        (word & self.mask) == self.value
15    }
16}

すべてのルールは、32ビットワードごとに反復処理され、デコードされます。

RUST

 1pub fn decode_word(word: u32) -> Decoded {
 2    let cond = bits(word, 31, 28) as u8;
 3    let kind = DECODE_RULES
 4        .iter()
 5        .find(|rule| rule.matches(word))
 6        .map(|rule| rule.kind)
 7        .unwrap_or(InstructionKind::Unknown);
 8
 9    Decoded {
10        cond,
11        kind,
12        raw: word,
13    }
14}

トライ(trie)や他のデータ構造の方がおそらく高速ですが、これは読みやすく、理解しやすく、保守しやすいです。

必要に応じてフルデコード

命令DSL以前は、常にすべての命令に必要なすべての値をデコードしていました。つまり、短い命令は、命令を特定しようとした副作用として、たとえ一致しなくてもデコードされていました。DSLにより、オペコードのみをデコードし、CPUが decoder::{decode_word,bit,bits} および decoder::{sign_extend,rotated_imm} を介して必要とするものだけをデコードできるようになります。ここで、bitとbitsはワードへの部分的なアクセスを可能にし、decode_wordはオペコード、条件、および生のワードを返して、CPUエミュレーションでのさらなる処理を行います。

RUST

 1/// フェッチ-デコード-実行ステップ。終了svcでのみfalseを返します。
 2pub fn step(&mut self) -> Result<bool, err::Err> {
 3    // [...] フェッチワード
 4
 5    let Decoded { kind, cond, raw } = decoder::decode_word(word);
 6
 7    // [...] 
 8
 9    match kind {
10        InstructionKind::MovImm => {
11            let rd = decoder::bits(raw, 15, 12) as usize;
12            let imm12 = decoder::bits(raw, 11, 0);
13            // [...] 
14        }
15        // [...] 
16        InstructionKind::LdrLiteral => {
17            let rd = decoder::bits(raw, 15, 12) as usize;
18            let imm12 = decoder::bits(raw, 11, 0);
19
20            // [...] 
21        }
22    }
23}

ビットとビットへのアクセスは明白ですが、sign_extend と rotated_imm はそれほどではないかもしれません。

RUST

 1pub fn bits(word: u32, high: u8, low: u8) -> u32 {
 2    debug_assert!(high < 32);
 3    debug_assert!(low <= high);
 4    let width = high - low + 1;
 5    (word >> low) & ((1 << width) - 1)
 6}
 7
 8pub fn bit(word: u32, bit: u8) -> bool {
 9    bits(word, bit, bit) != 0
10}
11
12pub fn sign_extend(value: u32, bits: u32) -> i32 {
13    debug_assert!((1..=32).contains(&bits));
14
15    let shift = 32 - bits;
16    ((value << shift) as i32) >> shift
17}
18
19pub fn rotated_imm(imm12: u32) -> u32 {
20    let rotate = ((imm12 >> 8) & 0b1111) * 2;
21    (imm12 & 0xff).rotate_right(rotate)
22}

BとBLのサポート

BとBLはARMv7 ISAの無条件分岐命令です。

  • 無条件分岐:

ARMASM

 1.text
 2    .global _start
 3_start:
 4    mov	 r0, #0
 5    b	 1f
 6    mov	 r0, #1		@ 実行されるべきではない
 71:
 8    mov	 r7, #1
 9    svc	 #0
  • リンク付き無条件分岐:

ARMASM

  1.text
  2    .global _start
  3_start:
  4    mov	 r0, #0
  5    bl	 foo
  6    mov	 r7, #1
  7    svc	 #0
  8foo:
  9    mov	 r0, #42
 10    mov	 r7, #1
 11    svc	 #0

BとBLのエンコーディングは次のとおりです。

  1. 条件コード(ARMv7 条件コードサフィックス を参照)
  2. 命令グループ(101)
  3. リンク付き分岐かどうか(L)
  4. ターゲット(imm24)

ビット表現では次のようになります。

TEXT

 1 31 30 29 28 27 26 25 24 23 .. 0
 2|cond       |1  0  1 |L | imm24 |

これは実装が比較的容易であることを意味します。以下を参照してください。Lはエミュレータにリターンアドレスをリンクレジスタ(LR)に保存するように指示し、それ以外の場合はimm24をデコードし、2ビット左にシフトし、32ビットに符号拡張して、プログラムカウンタに追加するだけです。

RUST

 1InstructionKind::Branch => {
 2    let l = decoder::bit(raw, 24);
 3    // BL
 4    if l {
 5        // 次のアドレスへのリターンアドレスをLRに保存します
 6        self.r[14] = self.instr_addr().wrapping_add(4);
 7    }
 8
 9    let imm24 = decoder::bits(raw, 23, 0);
10    let imm26 = imm24 << 2;
11    let imm32 = decoder::sign_extend(imm26, 26);
12
13    self.r[15] = self.arm_pc().wrapping_add(imm32 as u32);
14}

テスト「フレームワーク」

すべてのハードニングとサポートする新しい命令をテストするために、srunというツールを追加しました。これは、アセンブリまたはCファイルをビルド、リンク、実行するための小さなstinkarmラッパーです。

TEXT

 1ARMアセンブリまたはCファイルをstinkarmでビルド、リンク、実行します
 2
 3使用法: srun [OPTIONS] <INPUT> [-- <EMULATOR_ARGS>...]
 4
 5引数:
 6  <INPUT>             実行するARMアセンブリまたはCファイル
 7  [EMULATOR_ARGS]...  生成されたELFパスの前にstinkarmに渡される追加引数
 8
 9オプション:
10      --text-addr <TEXT_ADDR>  リンカテキストアドレスとして使用されるゲストアドレス [デフォルト: 0x8000]
11      --out-dir <OUT_DIR>      生成されたオブジェクトファイルおよびELFファイルのディレクトリ [デフォルト: target/srun]
12      --dump-asm               エミュレータ実行前にリンクされたARM逆アセンブリを表示します
13  -h, --help                   ヘルプを表示します

例えば、以前はまず examples/branch.S ファイルをアセンブルしてからstinkarmを呼び出す必要がありましたが、今は次のようにできます。

SHELL

1cargo run --bin srun 
2    # srun の引数
3    \ -- examples/helloWorld.S 
4    # stink arm の引数、命令とシステムコールをログ出力
5    \ -- -linstructions -lsyscalls

TEXT

 1[     0.538ms] MovImm 1110 E3A00001
 2[     0.543ms] LdrLiteral 1110 E59F1014
 3[     0.545ms] MovImm 1110 E3A0200E
 4[     0.548ms] MovImm 1110 E3A07004
 5[     0.551ms] Svc 1110 EF000000
 665174 write(fd=1, buf=0x8024, len=14) [sandbox]
 7Hello, world!
 8=14
 9[     0.567ms] MovImm 1110 E3A00000
10[     0.570ms] MovImm 1110 E3A07001
11[     0.573ms] Svc 1110 EF000000
1265174 exit(code=0) [sandbox]
13=0

というわけで、これで終わりです。さあ、私がクラウデサーバーラックを叩き壊すのを楽しんでください。

[画像: claude]


  1. ピクセルアートの見出しとこの記事のくだらない内容はすべて brainslob によるもので、クランカーによって生成されたものはありません。↩︎