HN 日本語サマリー

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

Swiftによる最小限のカーネルをQEMU上で実行する

A minimal kernel in Swift, running in QEMU (carette.xyz)

90 pointsby surprisetalk17 コメント

要約

この記事では、Swift言語を使って非常に基本的なカーネルを作成し、QEMUエミュレータ上で実行する実験について解説しています。Embedded Swiftの設定、ベアメタルターゲット向けのコンパイラとリンカの調整、アセンブリ言語との連携、そしてUARTへの直接書き込みやメモリ操作といった低レベル関数の実装方法が詳細に説明されています。

全文翻訳

Swiftで書かれた最小限のカーネルをQEMUで実行する


更新 (2026年9月28日)
Max Desiatov さんが、@_cdecl を使って関数を宣言する代わりに、@c Swift属性が機能するはずだと教えてくれました。@c 属性は、Swiftで実装されたC関数としてグローバル関数をマークし、@_cdecl 属性を正式なものにします。提案へのリンクはこちらで確認できます。このコメントを受けて、ブログ記事とコードを更新しました。Maxさん、ありがとう!


私は小さな実験を始めました。それは、非常に基本的なカーネルをSwiftで書き、QEMU上で実行することです。

目標はもちろんLinuxや他の一般的なカーネルを置き換えることではなく、単に楽しむことと、オペレーティングシステムなしでプログラムを実行するために何が必要かを理解することです。実際、私は10年前にarOSで同様の実験を行いました。

今のところ、カーネルは1つのことしかできません。QEMU経由でメッセージを表示し、その後永遠に待機します。これは最初の深い探求としては十分です。

Embedded Swift #

このプロジェクトでは、オペレーティングシステムも標準ライブラリも(通常の意味では)利用できない環境向けに設計されたSwiftのサブセットであるEmbedded Swiftを使用します。

最初の Package.swift は非常に小さかったです。

// swift-tools-version: 6.4

import PackageDescription

let package = Package(
    name: "swift-kernel",
    platforms: [.macOS(.v14)],
    targets: [
        .executableTarget(
            name: "swift_kernel",
            swiftSettings: [
                .enableExperimentalFeature("Embedded"),
                .strictMemorySafety(),
                .treatAllWarnings(as: .error),
            ],
        )
    ]
)

そして最初のSwiftファイルは、そのシンプルさにおいてほぼ侮辱的でした。

// Sources/swift_kernel/test.swift
print("Hello... world?")

実行してみました。

> swift run
<unknown>:0: error: unable to load standard library for target 'arm64-apple-macosx27.0.0'

しまった。どうやら私の現在のSwiftコンパイラには、まだEmbedded Swift標準ライブラリが同梱されていないようです。

ドキュメントで見落としていた点があります。

Embedded Swiftはまだ実験的であり、公開されているSwiftリリースではまだサポートされていません。そのため、開発ツールチェーンを使用する必要があります。

そこで、開発ツールチェーンをインストールして再度テストしてみましょう。

> swiftly install main-snapshot && swiftly use main-snapshot
> swift run
[...] 
Hello... world?

成功です!
この時点で、Embedded Swiftが小さなプログラムをコンパイルして実行できることを確認できました。

次のステップは、オペレーティングシステムが全くないマシン用にコンパイルすることでした。

QEMUセットアップ #

このプロジェクトでは、QEMUというマシンエミュレータを使用します。これはハッカーの間で最も有名なマシンエミュレータの1つです。

私はApple Siliconマシン上でQEMUの virt マシンを使用しています。ターゲットはしたがって aarch64-none-none-elf です。
このターゲットは、トリプルとして設計されており、オペレーティングシステムがなく、Cランタイムによって提供される環境もない64ビットARMマシンを表します。

QEMUが起動すると、CPUは生の状態で始まります。安全にSwiftコードを実行できるようになる前に、スタックを設定し、プログラムの開始場所を決定する必要があります。

以下の最小限のアセンブリファイルが必要になります。

  1. _start シンボルを定義する。
  2. 最初のコアのスタックを設定する。
  3. Swiftのエントリ関数 kernel_main にジャンプする。
  4. メインを継続させるために永遠に待機する。

コンパイラセットアップ #

コンパイラに、これが通常の実行可能ファイルではないことを伝える必要があります。コンパイラは通常の標準ライブラリのリンクを避け、リンカはプラットフォーム固有のスクリプトの代わりに私たちのリンカスクリプトを使用する必要があります。

このプロジェクトでは、以下の toolset.json を使用し、これをSwift Package Manager (SPM) に渡します。

{
    "schemaVersion": "1.0",
    "swiftCompiler": {
        "extraCLIOptions": [
            "-enable-experimental-feature", "Embedded",
            "-enable-experimental-feature", "Volatile",
            "-Xfrontend", "-no-allocations",
            "-Xfrontend", "-function-sections",
            "-Xfrontend", "-disable-stack-protector",
            "-Xlinker-driver", "-nostdlib",
            "-Xlinker-driver", "-fuse-ld=lld"
        ]
    },
    "linker": {
        "extraCLIOptions": [
            "-nostdlib",
            "-static",
            "--gc-sections",
            "--orphan-handling=error",
            "-T", "linker.ld",
            "-Map", ".build/kernel.map"
        ]
    }
}

次に、新しいターゲット、ツールセット、およびSwiftネイティブビルドシステムを使用してプロジェクトをビルドします。

> swift build --triple aarch64-none-none-elf --toolset toolset.json --build-system native

残念ながら、最初のリンカ試行は失敗します。

ld.lld: error: section type mismatch for .strtab
>>> <internal>:(.strtab): SHT_STRTAB
>>> output section .nonalloc: SHT_SYMTAB

ld.lld: error: section type mismatch for .shstrtab
>>> <internal>:(.shstrtab): SHT_STRTAB
>>> output section .nonalloc: SHT_PROGBITS

ld.lld: error: undefined symbol: putchar
ld.lld: error: undefined symbol: memmove

うーん。何が起こっているのでしょうか?

ベアメタルターゲット(リマインダー: none-none-elf)用にコンパイルしているため、基盤となるオペレーティングシステムもC標準ライブラリも存在しません。したがって、putchar も memmove もありません…

セクションのエラーは別の原因です。オーファンハンドリングが有効になっているため、リンカはELFメタデータがどこに行くべきかを推測したくありません。したがって、リンカスクリプトは、保持するセクションを明示的に配置する必要があります。

Swiftとアセンブリのブリッジング #

main 関数を持つ通常のSwiftファイルは使用できません。代わりに、@c を使用して指定されたカーネルエントリ関数を公開し、アセンブリファイルがC互換名で呼び出せるようにします。

@c
func kernel_main() {
    print("Hello, Embedded Swift 😊")

    while true {} // プログラムを実行し続ける
}

アセンブリのエントリポイントは Sources/boot/boot.S にあります。

.section .text.boot
.global _start

_start:
    /* CPU ID を読み取る。Core 0 のみが Swift コードを実行するようにする。*/
    mrs x1, mpidr_el1
    and x1, x1, #3
    cbz x1, 2f

    /* セカンダリコアを無限待機ループに駐車する。*/
1:  wfe
    b 1b

    /* Core 0 のスタックを設定する。*/
2:  ldr x0, =__stack_top
    mov sp, x0

    /* Swift エントリポイントにジャンプする。*/
    bl kernel_main

    /* 復帰したら停止する。*/
    b 1b

QEMUは複数の仮想コアを開始できますが、今のところ最初のコアだけがカーネルを実行すべきです。他のコアは(wfe を使用して)待機し、まだ送信されないイベントを待ちます。

不足している関数の提供 #

Embedded Swiftが使用する print の実装は、少なくとも1文字を書き込む方法を必要とします。QEMUの virt マシンでは、ARMのPL011 UARTが 0x09000000 にマッピングされています。

したがって、putchar はそのメモリマップドレジスタに直接書き込むことができます。

// QEMUのPL011 UARTレジスタ
let QEMU_UART_REGISTER: UInt = 0x0900_0000

@c
@unsafe func putchar(_ c: CInt) -> CInt {
    let uart = unsafe UnsafeMutablePointer<UInt8>(bitPattern: QEMU_UART_REGISTER)!
    unsafe uart.pointee = UInt8(c)
    return c
}

これはスクリーン・ドライバーではなく、シリアル出力ドライバーです。QEMUは、エミュレートされたUARTが受け取ったバイトをターミナルに表示します(-nographic オプション付きで実行するため)。

もう1つの不足している関数は memmove です。Swiftの低レベルコードは、通常の標準ライブラリを使用していない場合でも、基本的なメモリ操作を必要とします。この最初の実験では、ソースとデスティネーションが重複するかどうかによって、前方または後方にコピーする小さな実装を提供します。

@c
@unsafe func memmove(
    _ dest: UnsafeMutableRawPointer,
    _ src: UnsafeRawPointer,
    _ n: Int
) -> UnsafeMutableRawPointer {
    let d = unsafe dest.assumingMemoryBound(to: UInt8.self)
    let s = unsafe src.assumingMemoryBound(to: UInt8.self)

    if unsafe d < s {
        for i in 0..<n { unsafe d[i] = s[i] }
    } else if unsafe d > s {
        for i in (0..<n).reversed() { unsafe d[i] = s[i] }
    }
    return unsafe dest
}

これは、プロジェクトが通常のアプリケーションプログラミングでなくなる最初のポイントです。ここでは、文字列を印刷するためにオペレーティングシステムAPIを呼び出すのではなく、言語ランタイムが存在するために必要な低レベル関数を実装しています。

メモリレイアウトの説明 #

Swiftコードを実装したので、リンカはカーネルがどこにロードされ、実行可能ファイルの各部分がどこに配置されるかを知る必要があります。これが linker.ld の役割です。

QEMUの virt マシンは、このセットアップではAArch64カーネルを 0x40080000 にロードします。

ENTRY(_start)

. = 0x40080000;

リンカスクリプトは、ブートコードを最初に配置し、その後に読み取り専用データ、初期化済みデータ、未初期化データ、およびスタックを配置します。

.text : {
    KEEP(*(.text.boot))
    *(.text*)
}

.rodata : ALIGN(8) {
    *(.rodata*)
}

.data : ALIGN(8) {
    *(.data*)
}

.bss (NOLOAD) : ALIGN(16) {
    __bss_start = .;
    *(.bss*)
    *(COMMON)
    __bss_end = .;
}

.stack (NOLOAD) : ALIGN(16) {
    . += 0x20000;
    __stack_top = .;
}

アセンブリコードは、スタックポインタを初期化するために __stack_top シンボルを使用します。スタックは現在128 kBですが、これは1つの文しか印刷しないカーネルにとっては不当に多い量です。しかし、このプロジェクトがまだ実験的である間、Swiftに関数呼び出しのための余地を与えます。

最後に、スクリプトはELFメタデータセクションを明示的に配置します。これにより、最初のリンカ試行でのオーファンセクションエラーが回避されます。

/DISCARD/ : {
    *(.comment)
    *(.debug*)
    *(.eh_frame*)
    *(.swift_*)
}

.symtab : { *(.symtab) }
.strtab : { *(.strtab) }
.shstrtab : { *(.shstrtab) }

Hello, Embedded Swift #

これでビルドしてみましょう。

> swift build --triple aarch64-none-none-elf --toolset toolset.json --build-system native

そして、QEMUで起動します。

> qemu-system-aarch64 -machine virt -cpu cortex-a57 -nographic -kernel .build/aarch64-none-none-elf/debug/kernel

そして…

Hello, Embedded Swift 😊

その後、カーネルは無限ループにトラップされているため、永遠に実行し続けます。

これは実用的なカーネルには程遠いですが、実際のAArch64 ELF実行可能ファイルです。アセンブリのエントリポイントで開始され、標準ライブラリなしでリンクされ、手動で設定されたスタックの上にSwiftコードを呼び出します。

最初のハローワールドとしては、これで十分です。

次に来るものは? #

プロジェクトは意図的に未完成です。次のステップはまだ実装されていませんが、残りの方向性を示しています。

  1. ブート中に .bss セクションをクリアする。
  2. UARTレジスタを小さなSwift抽象化の背後に隠す(簡潔さのためにQEMUのものをハードコードしました)。
  3. Embedded Swiftがどの割り当て機能をサポートできるかを理解する。
  4. 割り込みとタイマーを調査する。
  5. そして最終的に、この無限ループを実際の作業をスケジュールできるものに置き換える。

場合によっては、フレームバッファ、実際のキーボードドライバー、および最小限の対話型環境を実験することも検討するかもしれません。しかし、ユーザーインターフェースを構築する前に、その下のマシンを理解する必要があります。

人間への応答 #

今のところ、マシンは挨拶をします。メッセージを表示するのは良いことですが、まだ一方的な会話です。

PL011 UARTには受信レジスタもあります。そこから読み取る前に、フラグレジスタをチェックする必要があります。ビット4(RXFE と呼ばれる)は、受信FIFOが空かどうかを示します。空の場合は待機します。

let QEMU_UART_FLAG_REGISTER: UInt = 0x0900_0018

@unsafe func readChar() -> UInt8 {
    let uart = unsafe UnsafeMutablePointer<UInt8>(bitPattern: QEMU_UART_REGISTER)!
    let flags = unsafe UnsafeMutablePointer<UInt8>(bitPattern: QEMU_UART_FLAG_REGISTER)!

    // RXFEビットは、受信FIFOが空の間セットされます。
    while unsafe (flags.pointee & 0x10) != 0 {}
    return unsafe uart.pointee
}

これはポーリングです。CPUは、文字が到着して処理されるまでUARTを繰り返しチェックします。これは非常に非効率的な方法です。実際のカーネルは最終的に割り込みを使用しますが、最初の実装としては十分単純です。

カーネルは文字をターミナルにエコーできるようになりました。

@c
func kernel_main() {
    print("Swift kernel ready.")
    let _ = unsafe putchar(62)
    let _ = unsafe putchar(32)

    var ignoreLineFeed = false

    while true {
        let character = unsafe readChar()

        if character == 13 {
            let _ = unsafe putchar(10)
            let _ = unsafe putchar(62)
            let _ = unsafe putchar(32)
            ignoreLineFeed = true
        } else if character == 10 {
            if !ignoreLineFeed {
                let _ = unsafe putchar(10)
                let _ = unsafe putchar(62)
                let _ = unsafe putchar(32)
            }
            ignoreLineFeed = false
        } else {
            let _ = unsafe putchar(CInt(character))
            ignoreLineFeed = false
        }
    }
}

数値 62 と 32 は、単にASCIIコードの > とスペースです。小さな文字列書き込み抽象化を作成することもできますが、今のところメカニズムを可視のままにしておくことを好みます。

同じQEMUコマンドを実行すると、プロンプトが表示されます。

Swift kernel ready.
> hello kernel
hello kernel
> 

これは依然として非常に小さな機能です。ラインエディタ、バックスペース処理、コマンドパーサーはありません…そしてCPUは、割り込みではなくポーリングを使用しているため、各文字を待機するためにビジー状態です。

print("Hello... world?") で始まったプログラムとしては、ここで停止して、それらを改善するためのTODOリストを書き始めるのに良い場所だと感じます。

完全なコードは私のプライベートGitスペースで入手できます: https://git.carette.xyz/k0pernicus/swift-kernel。
楽しんでください!