HN 日本語サマリー

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

Fil-Cにおけるメモリ安全なコンテキスト切り替え(longjmp、setjmp)

Memory Safe Context Switching (longjmp, setjmp) in Fil-C (fil-c.org)

192 pointsby modeless29 コメント

要約

この記事では、Fil-Cがいかにしてlongjmp、setjmp、ucontext APIを完全にメモリ安全な方法でサポートしているかを説明しています。これらのAPIの誤用が、スタック破損やFil-Cの能力モデルのその他の違反を引き起こすことはありません。Fil-Cは、これらの危険なAPIがもたらす一般的な問題を解決し、信頼性の高い実行を保証します。

全文翻訳

メモリ安全なコンテキストスイッチ

この記事では、Fil-C が longjmp、setjmp、setcontext、getcontext、makecontext、および swapcontext を完全にメモリ安全な方法でどのようにサポートしているかを説明します。特に、Fil-C におけるこれらの API の誤用は、スタック破損や Fil-C の能力モデルのその他の違反につながることはありません。

これらの API は広く使用されています。

  • longjmp と setjmp は、C プログラムで例外処理を実装するために使用されます。特に、シグナルハンドラから「スロー」された例外を実装するためによく使用されます。
  • getcontext、setcontext、makecontext、および swapcontext(別名 ucontext API)は、コルーチンやファイバーを実装するために使用されます。たとえば、Boost はファイバー実装の一部として ucontext を使用しています。

ucontext API は longjmp/setjmp よりも使用頻度は低く、一部の OS(Darwin など)では非推奨となっています。しかし、glibc では引き続き十分にサポートされています。

これらの API をメモリ安全性を維持しながら実装するのは困難です。なぜなら、これらの API の誤用は、ダングリングスタックを復元する可能性があるからです。たとえば、ある関数内で setjmp または getcontext を呼び出し、その後、以下のいずれかの操作を行うことができます。

  • その関数からリターンする。この時点で、保存されたコンテキストは、もはや存在しないスタックフレームを復元しようとします。
  • スレッドから終了する。この時点で、保存されたコンテキストは、解放されたスタックで実行を復元しようとします。

さらに親切な API である makecontext や swapcontext でさえ、単純に誤用される可能性があります。

  • makecontext を使用してスタックを指すコンテキストを作成し、そのスタックを解放してから、そのコンテキストに swapcontext または setcontext を呼び出すことができます。Yolo-C では、これはダングリングスタック上での実行につながります。Fil-C では、これはエラーになりません。
  • swapcontext を呼び出す際に、2 番目の引数に現在実行中のコンテキストを指定することができます。これは、引数の順序を間違えた場合に発生する可能性があります。Yolo-C では、最良の場合、これは longjmp のように動作しますが、最悪の場合、ダングリングスタック上での実行につながります。Fil-C では、これは安全上のエラーであり、プログラムがパニックします。

Yolo-C では、ダングリングスタック上での実行は、デバッガでスタックトレースさえ表示できないため、最も混乱しやすい種類のクラッシュにつながります。さらに悪いことに、プログラムがコンテキストの処理に微妙なバグを抱えている場合、攻撃者はそれらのバグを悪用して、攻撃者が望むとおりにプログラムを実行させることができます。Fil-C では、ダングリングスタック上での実行は不可能です。そのようなケースはすべて、longjmp または ucontext API のいずれかを誤用した時点でのパニック、または Fil-C がスタックを管理する方法による確実に合法的な実行のいずれかです。

Fil-C は setjmp/longjmp と ucontext API をかなり異なる方法で実装しています。

setjmp/longjmp をメモリ安全にする

setjmp の堕落には驚くべき深さがあります。Fil-C が setjmp/longjmp をどのように実装するかを詳しく説明する前に、この関数がなぜこれほど驚くほど邪悪なのかを正確に議論する必要があります。

setjmp は、呼び出された瞬間のコンテキストを保存するため、後で longjmp が呼び出されたときに、setjmp は2度目のリターンをします。それがこれほど悪質な理由であり、その意味合いを正確に理解する必要があります。

例

この単純なプログラムを考えてみましょう。

#include <setjmp.h>
#include <stdio.h>

int main(int argc, char** argv)
{
    volatile int x = 42;
    jmp_buf jb;
    if (setjmp(jb)) {
        printf("x = %d\n", x);
        return 0;
    }
    x = 666;
    longjmp(jb, 1);
    printf("Should not get here.\n");
    return 1;
}

このプログラムは次のように出力します。

x = 666

そして終了します。フローは次のとおりです。

  1. setjmp が最初に呼び出されたとき、それは 0 を返し、呼び出し元のコンテキストを jb に保存します。
  2. 次に x を 666 に設定し、値 1 で jb に longjmp します。
  3. setjmp は 1 を返し、printf を実行して終了します。

プログラムが確実に 666 を出力するためには、x を volatile としてマークする必要があることに注意してください。そうしないと、コンパイラは x へのアクセスを最適化して 42 を返すことが許可されます。これは次のような方法で発生する可能性があります。

  • コンパイラは x を定数 42 に折りたたむことができます。これは、volatile を削除し、-O0 より高い最適化レベルを使用した場合に例で発生します。その場合、x = 42 が出力されます。
  • 定数折り返しが発生しないと仮定しましょう。たとえば、x の定義の直後に asm("" : "+r"(x)); を挿入した場合です。その場合、コンパイラは x を呼び出し元保存レジスタに割り当てることができ、そのレジスタは setjmp によって保存されます。これも x = 42 が出力される原因となります。
  • 何らかの理由でレジスタ圧力がかかり、x が呼び出し元保存レジスタに入らず、代わりにスピルされたと仮定しましょう。-O1 より高い最適化レベルでは、コンパイラは x を 2 つの変数に分割します。1 つは x = 42 用、もう 1 つは x = 666 用です。printf は最初の変数(x = 42 が printf を支配するため)を参照します。これらの 2 つの変数は、ほぼ常に別々のスピルスロットを取得します。したがって、setjmp から 2 回目にフォールバックしたときに x を読み取ると、42 が返されます。

3 つの考察事項があります。

  • x の値が printf で 666 と観測されるというプロパティを得るには、コンパイラが x を変数ではなくスタック割り当てとして扱うことを確認する必要があります。volatile を使用するとこれが達成されます。また、x へのポインタをどこかに渡すことも、これを達成する可能性が高いです。
  • スピルスロットはスタック割り当てとは異なります。変数がスタックに割り当てられている場合、1 つのスタック割り当てが行われます。変数がスピルされた場合、複数のスピル(多くの場合、代入ごとに 1 つのスピル)が発生する可能性があります。
  • コンパイラは、スピルスロットとスタック割り当てのライフタイムを分析することが許可されています。スピルスロットを再利用することが許可されています。コンパイラは、x = 42 のスピルスロットが longjmp が発生するまで有効であることをどのように知るのでしょうか? なぜ再利用されず、setjmp から 2 回目にフォールバックしたときに x が 666 またはランダムなゴミの値になることがないのでしょうか?

以下は、gcc、clang、および filcc で x が 2 つの異なるスピルスロット(42 用と 666 用)にスピルされる原因となる、より悪魔的なバージョンの例です。

#include <setjmp.h>
#include <stdio.h>

int main(int argc, char** argv)
{
    int x = 42;
    asm volatile("" : "+r"(x));
    jmp_buf jb;
    int a = 1, b = 2, c = 3, d = 4, e = 5, f = 6, g = 7, h = 9, i = 10;
    /* Force some spilling */
    asm volatile("" : "+r"(a), "+r"(b), "+r"(d), "+r"(e), "+r"(f), "+r"(g), "+r"(h), "+r"(i));
    if (setjmp(jb)) {
        asm volatile("" : "+r"(a), "+r"(b), "+r"(d), "+r"(e), "+r"(f), "+r"(g), "+r"(h), "+r"(i));
        printf("x = %d\n", x);
        return 0;
    }
    x = 666;
    void (*jump)(jmp_buf, int) = longjmp;
    asm volatile("" : "+r"(x));
    asm volatile("" : "+r"(jump), "+r"(a), "+r"(b), "+r"(d), "+r"(e), "+r"(f), "+r"(g), "+r"(h), "+r"(i));
    jump(jb, 1);
    asm volatile("" : "+r"(jump), "+r"(a), "+r"(b), "+r"(d), "+r"(e), "+r"(f), "+r"(g), "+r"(h), "+r"(i));
    asm volatile("" : "+r"(x));
    printf("Should not get here.\n");
    return 1;
}

このプログラムは、x が定数折り返しされたりレジスタ割り当てされたりしなくても、x = 42 と出力します。

注記:これまでのすべての例は Fil-C で動作します。私たちが変数の値を難読化するために使用しているインラインアセンブリでさえ、Fil-C で動作し、期待される効果があります。

何が起こっているのか

musl の x86_64 実装を見て、単純な setjmp がどのように見えるか見てみましょう。

__setjmp:
_setjmp:
setjmp:
    mov %rbx,(%rdi)         /* rdi は jmp_buf、レジスタをそれに移動 */
    mov %rbp,8(%rdi)
    mov %r12,16(%rdi)
    mov %r13,24(%rdi)
    mov %r14,32(%rdi)
    mov %r15,40(%rdi)
    lea 8(%rsp),%rdx        /* これは現在のリターンアドレスを含まない rsp */
    mov %rdx,48(%rdi)
    mov (%rsp),%rdx         /* 新しい rip のためのリターンアドレスポインタを保存 */
    mov %rdx,56(%rdi)
    xor %eax,%eax           /* 常に 0 を返す */
    ret

これは呼び出し元保存レジスタ、スタックポインタ、および命令ポインタを保存しているだけで、スタック自体は保存していません。

後で longjmp が呼び出されると、レジスタ状態は 1 つの違いを除いて復元されます。%eax(戻り値レジスタ)には longjmp に渡された引数が設定されます。

したがって、setjmp の最も基本的な安全上の問題は、setjmp を呼び出した後、その関数からリターンした場合、setjmp によって保存されたコンテキストは longjmp するのに有効ではないということです。 そのようなコンテキストにジャンプすると、壊れたマシン状態が発生します。

  • 呼び出し元保存レジスタ、スタックポインタ、および命令ポインタは、setjmp が呼び出されたときの状態とまったく同じになります。
  • スタックの内容 — 特に、スタックポインタが指しているフレーム — は、longjmp が呼び出されたときの状態になります。

longjmp は、setjmp によって保存されたコンテキストがスタックフレームと一致することが保証される場合にのみ安全です。これは、setjmp が呼び出された関数内、または setjmp を呼び出した関数によって(推移的に)呼び出された関数からのみ longjmp が呼び出されることを保証することによって達成されます。

しかし、それだけではありません!

コンパイラは、スピルスロットが不正に再利用されないように、setjmp が 2 回返ることを知っている必要があります。 実際、コンパイラは setjmp の呼び出しを検出し、それを呼び出す関数を特別扱いして、スピルスロットの再利用につながる可能性のある最適化を無効にします。これは、returns_twice 属性によってコンパイラユーザーにある程度公開されています。

setjmp の呼び出しが難読化された、より悪魔的な例を考えてみましょう。

#include <setjmp.h>
#include <stdio.h>

int main(int argc, char** argv)
{
    int x = 42;
    asm volatile("" : "+r"(x));
    jmp_buf jb;
    int a = 1, b = 2, c = 3, d = 4, e = 5, f = 6, g = 7, h = 9, i = 10;
    asm volatile("" : "+r"(a), "+r"(b), "+r"(d), "+r"(e), "+r"(f), "+r"(g), "+r"(h), "+r"(i));
    int (*setjump)(jmp_buf) = setjmp;
    asm volatile("" : "+r"(setjump));
    if (setjump(jb)) {
        asm volatile("" : "+r"(a), "+r"(b), "+r"(d), "+r"(e), "+r"(f), "+r"(g), "+r"(h), "+r"(i));
        printf("x = %d\n", x);
        return 0;
    }
    x = 666;
    void (*jump)(jmp_buf, int) = longjmp;
    asm volatile("" : "+r"(x));
    asm volatile("" : "+r"(jump), "+r"(a), "+r"(b), "+r"(d), "+r"(e), "+r"(f), "+r"(g), "+r"(h), "+r"(i));
    jump(jb, 1);
    asm volatile("" : "+r"(jump), "+r"(a), "+r"(b), "+r"(d), "+r"(e), "+r"(f), "+r"(g), "+r"(h), "+r"(i));
    asm volatile("" : "+r"(x));
    printf("Should not get here.\n");
    return 1;
}

現在、私が確認している結果は次のとおりです。

  • gcc version 11.4.0 では、プログラムは x = 666 と出力します。
  • clang version 14.0.0 では、プログラムは x = -291233296 のようなゴミを出力します。
  • filcc はプログラムのコンパイルを拒否します。実際、ICE(内部コンパイラエラー)が発生します。(Fil-C には、有用なものを出力する代わりに、コンパイル時診断で内部コンパイラエラーを発生させるという長年のバグがあります。)https://github.com/pizlonator/fil-c/issues/89

発生している安全でないことは(そして Fil-C がこのプログラムのコンパイルを拒否することで防いでいること)は、コンパイラが setjmp の呼び出しを、それが setjmp を呼び出していることを知らないでコンパイルした場合、x = 42 で使用されたスピルスロットが、if (setjmp) { ... } の後のコードの別の変数によって再利用される可能性があるということです。

まとめ

Fil-C は、次のことを保証することで longjmp/setjmp をメモリ安全にします。

  • jmp_buf は、不透明な zjmp_buf オブジェクトへのポインタのみを含みます。このオブジェクトの内容は Fil-C からアクセスできません。Fil-C ランタイムのみがそれを操作できます。これは、ほとんどのコードが jmp_buf の内部を検査しないため(そして検査するコードは Fil-C では動作しません)機能します。注記:jmp_buf を上書きした場合、longjmp を試みると Fil-C のパニックが発生する可能性が非常に高いです。これは、longjmp の内部実装が jmp_buf から zjmp_buf をロードできるかを確認するためです。Fil-C から zjmp_buf を偽装する方法はありません。
  • setjmp シンボルは、直接呼び出すことによってのみ言及できます。それ以外の場合はコンパイラが ICE します。(そして将来的には、コンパイラが適切な診断を出力するようになるかもしれません。)これにより、setjmp を認識し(スピルスロットの再利用を抑制する)コンパイラの仕組みが常に機能することが保証されます。
  • setjmp の呼び出しは、新しい zjmp_buf 不透明オブジェクトを割り当て、その zjmp_buf をスタックフレームに登録するようにコンパイルされます。各スタックフレームは、そのフレームで有効なジャンプターゲットである zjmp_buf の弱いセットを伝えることができます。(zjmp_buf がそれ以外では到達不能な場合にそのセットから削除されるため、これは弱いものです。)
  • longjmp は、zjmp_buf が有効であると見なすスタックフレームの子孫であるスタックフレームから呼び出されない限りパニックします。これは、スタックをウォークし、各スタックフレームに「私の zjmp_buf をあなたのセットに持っていますか?」と尋ねることによって達成されます。注記:同じ jmp_buf に対して繰り返される setjmp は新しい zjmp_buf を作成し、zjmp_buf は不変です。したがって、弱いセットへのメンバーシップは、longjmp 呼び出しが子孫フレームからのものであることを意味します。
  • longjmp および setjmp の Fil-C 実装は、GC ルートを追跡するために必要な状態を含む、多くの内部ランタイム状態を保存および復元します。特に、zjmp_buf は setjmp が呼び出された時点でのフレームの GC ルートのコピーを保持します。zjmp_buf が生きている限り、それらのルートをマークし続けます。

この実装の最も怪しい部分は、Fil-C ランタイムが、ポインタ変数が FilPizlonator が実行された時点での LLVM IR で SSA 値として具体化された場合、longjmp が setjmp 時点での状態にその値を復元すると強く仮定していることです。これまでのところ、これは確認されていますが、非常に混乱しやすいです — もし私の longjmp/setjmp にバグがあった場合、それはここになり、次のように現れるでしょう。longjmp の後、GC のスタックフレームのルートに対する見方は、ローカルポインタすべてが setjmp 前の値に復元されたかのようですが、あるポインタの値が復元されず、setjmp 呼び出し後だが longjmp 呼び出し前の新しい値を持っているというものです。ポインタを volatile にしてもバグをトリガーできないことに注意してください。それはポインタをスタック割り当てにし、SSA 値ではなくなるためです。その場合、私の変換は正しいことを行います(「ポインタ」は実際にはヒープ上のオブジェクトになり、SSA 値はそのポインタボックスへのポインタになります)。

この忌まわしい化合物の私の分析が正しいと仮定すると、これらのルールは、スタックを破損させたり、Fil-C 能力モデルの違反を引き起こしたりする可能性のあるあらゆる使用を禁止しながら、longjmp/setjmp の安全な使用のほとんどを許可するのに十分です。

ucontext をメモリ安全にする

Yolo-C でファイバーを実装するために setjmp/longjmp を使用することは、ほぼ可能です。しかし、これを試みると 2 つの問題が発生します。

  1. ファイバーは、ある状態(longjmp)を同時に復元し、別の状態(setjmp)を保存するコンテキストスイッチを必要とします。setjmp/longjmp の観点からこれを記述するのは非常に混乱します。
  2. 新しいファイバーを開始するときのブートストラップ方法が明確ではありません。スタックを割り当て、メイン関数を実行するために longjmp できる jmp_buf を生成したいと考えています。

これは sigaltstack ハックで実現できることが判明しました。しかし、このハックはどれほど優れていても、人々はより使いやすい ucontext API を好むことが多いです。

getcontext は現在の状態をコンテキストにスナップショットします。これは setjmp に似ていますが、そのように使用されることはめったにありません。主に makecontext を呼び出す前に ucontext_t を事前設定するために使用されます。

setcontext は、状態を保存せずに(状態を保存しない)一方通行のコンテキストスイッチです。これは主にファイバーの終了に使用されます。

makecontext は、メイン関数を呼び出すようにブートストラップされた新しいコンテキストを作成します。歴史の奇妙なねじれとして、この関数の契約は getcontext の事前呼び出しを必要としますが、getcontext によってスナップショットされた状態のほとんどを上書きします。getcontext のほとんどの最新の使用法は、このねじれによるものです。

swapcontext は、現在のコンテキストを 1 つの ucontext_t に同時に保存し、別の ucontext_t に切り替えるコンテキストスイッチです。

以下は、Linux の man ページ からこの API を使用する例です(サイズを減らすためにいくつかの小さな変更を加えました)。

#include <ucontext.h>
#include <stdio.h>
#include <stdlib.h>

static ucontext_t uctx_main, uctx_func1, uctx_func2;

static void func1(void)
{
    printf("func1: swapcontext(&uctx_func1, &uctx_func2)\n");
    swapcontext(&uctx_func1, &uctx_func2);
    printf("func1: returning\n");
}

static void func2(void)
{
    printf("func2: swapcontext(&uctx_func2, &uctx_func1)\n");
    swapcontext(&uctx_func2, &uctx_func1);
    printf("func2: returning\n");
}

int main()
{
    char func1_stack[16384];
    char func2_stack[16384];

    getcontext(&uctx_func1);
    uctx_func1.uc_stack.ss_sp = func1_stack;
    uctx_func1.uc_stack.ss_size = sizeof(func1_stack);
    uctx_func1.uc_link = &uctx_main;
    makecontext(&uctx_func1, func1, 0);

    getcontext(&uctx_func2);
    uctx_func2.uc_stack.ss_sp = func2_stack;
    uctx_func2.uc_stack.ss_size = sizeof(func2_stack);
    uctx_func2.uc_link = &uctx_func1;
    makecontext(&uctx_func2, func2, 0);

    printf("main: swapcontext(&uctx_main, &uctx_func2)\n");
    swapcontext(&uctx_main, &uctx_func2);

    printf("main: exiting\n");
    return 0;
}

このプログラムは次のように出力します。

main: swapcontext(&uctx_main, &uctx_func2)
func2: swapcontext(&uctx_func2, &uctx_func1)
func1: swapcontext(&uctx_func1, &uctx_func2)
func2: returning
func1: returning
main: exiting

いくつかの注記:

  • setcontext は使用していません。この API の多くのユーザーは setcontext を使用しません。setcontext は、getcontext/setcontext を longjmp/setjmp の代替として使用している場合(これは実際のコードでは見たことがありません)、またはコンテキストから最後のコンテキストスイッチを行っている場合のみ役立ちます。その場合、コンテキストを保存する必要はありません。
  • getcontext は 1 つの目的しか果たしません。それは makecontext が初期化しない ucontext_t の部分を初期化することです。ここの契約は奇妙です。getcontext を呼び出さない場合、公開 API の一部ではないフィールド(システムヘッダーで定義されている)をすべて初期化する方法を見つける必要があります。また、uc_sigmask を初期化することを忘れないようにする必要があります(getcontext は現在の sigmask でそれを初期化します)。Linux/X86_64 では、getcontext が初期化するその他のフィールドは、主に FPU 例外状態に関連しています。この契約がこれほど不透明であることは、この API をメモリ安全にするのに役立ちます。
  • func1_stack と func2_stack をコンテキストで使用し始めると、それらの内容に依存することはできなくなります。読み取ることはできますが、そこにあるものについて何も保証されません。そして、それに書き込むと、すべてが保証されなくなります。この例では、これらのスタックにガードページを提供していないため、これらのスタックはスレッドが得る通常のスタックよりも安全性が低いです。
  • swapcontext の最初の引数が、それを呼び出したときに実行していたコンテキストであることは、単なる慣例です。上書きしても安全な任意のコンテキストを渡すことができました。例の最初の swapcontext(&uctx_main, &uctx_func2) 呼び出しでこれを確認できます。ここでは、uctx_main はその呼び出し前に初期化されておらず、メインスレッドのコンテキストを保持するコンテキストとして選択されています。これは問題ありません。
  • uc_link の使用に注意してください。これは、コンテキストのメイン関数がリターンしたときに setcontext に渡されるコンテキストです。

この API をメモリ安全にするために、getcontext が ucontext を makecontext の呼び出し前に初期化するためだけに使用されるという上記のイディオムに焦点を当てます。

安全な ucontext のための法則

ucontext に適用する法則を列挙しましょう。これらの法則は、ucontext をメモリ安全にするために厳密に必要なものよりも制限的ですが、API の実際のユーザーに有用な、最も保守的な実装から始めたいと思いました。

不透明な状態。 jmp_buf を安全にしたときと同じトリックを繰り返します。ucontext_t の内部に、不透明な zfiber_context オブジェクトへのポインタを含めます。Fil-C コードは、 pizlonated_runtime.h の API を呼び出す以外では zfiber_context にアクセスできません。Fil-C コードは zfiber_context にアクセスできません。

ss_sp は重要ではありません。 実装は、ss_sp フィールドで提供されたスタックを完全に無視します。内部では、zfiber_context は表示できないスタックを割り当てます。ss_size はそのスタックのサイズとして使用されます(ただし、Fil-C のスタックオーバーフロー処理が機能するために必要なパディングが追加されます)。スタックは makecontext を呼び出したときに割り当てられます。

zfiber_context は制限された状態機械を持ちます。 状態は次のとおりです。

  • 未初期化 - これは zfiber_context が割り当てられた後の初期状態です。zfiber_context_getcontext を呼び出すか、コンテキストを zfiber_context_swapcontext の from 引数(最初の引数)として使用することのみが合法です。
  • getcontext 後 - これは getcontext が返された後の状態です。この状態では、zfiber_context_makecontext を呼び出すか、コンテキストを zfiber_context_swapcontext の from 引数として使用することのみが合法です。
  • 実行可能 - これらの状態は、makecontext を呼び出した結果、またはコンテキストを swapcontext の from 引数として渡した後に発生します。この状態では、setcontext を呼び出すか、コンテキストを swapcontext の to 引数として使用することのみが合法です。
  • 実行中 - この状態は、setcontext または swapcontext を使用してコンテキストの実行を開始した後に発生します。コンテキストを swapcontext の from 引数として渡すことが合法ですが、これは呼び出し元のスレッドで現在実行中のコンテキストである場合に限ります(各スレッドは現在実行中のコンテキストを追跡します)。一部のコンテキストは実行中である可能性がありますが、setcontext または swapcontext を使用して別の未初期化コンテキストに切り替えた場合、そのコンテキストは実行中状態のままになります。なぜなら、実行中コンテキストに対してできることは、それからスワップすることだけであり、それは呼び出し元のスレッドによって現在実行されているコンテキストである場合にのみ機能するからです。

この状態機械は、setjmp/longjmp の代替コンテキストスイッチパスとして ucontext を使用することを禁止します。なぜなら、未初期化コンテキストに切り替えることはできないからです。実行可能コンテキストにのみ切り替えることができ、それを実現する唯一の方法は、新しいコンテキストを makecontext するか、現在のコンテキストを swapcontext で保存することです。

スレッドアフィニティ。 Fil-C ABI は filc_thread* をすべての関数呼び出しに渡します。コンパイラは、どの関数呼び出しも実行中の filc_thread* を変更しないと期待できるためです。したがって、ucontext があるスレッドで実行されたスタックを別のスレッドで実行させることはできません。そのため、zfiber_context は作成された zthread を追跡し、他のスレッドからの zfiber_context API への呼び出しをすべて禁止します。

GC 統合

GC が zfiber_context オブジェクトにマークフェーズ中にアウトゴーイングポインタをマークするように求めた場合、コンテキストが実行可能であると、スレッドがスタックをスキャンするように要求されたときに(ソフトハンドシェイク中に)行うことと同等のことを行う必要があります。

しかし、次のようなことが単一の GC マークフェーズ中に発生した場合はどうでしょうか。

  1. GC は実行可能な zfiber_context をマークし、マークスタックに配置します。
  2. GC はマークスタックから zfiber_context をポップし、そのアウトゴーイングポインタをマークします。コンテキストはまだ実行可能であると仮定します。そのため、スタックをスキャンします。
  3. ミューテータは setcontext または swapcontext を使用してその zfiber_context に切り替えます。これで、コンテキストは実行中になり、スタックは GC から見えなくなります。これは問題ありません。スタックはスレッドによって所有されており、GC はグレー(grey)スタックを使用します。つまり、終了前に常にスタックを再スキャンします。
  4. ミューテータは swapcontext を使用してその zfiber_context から切り離し、zfiber_context を再び実行可能にします。

ここで問題が発生します!GC は、スタック上のものが終了前に再スキャンされるため、バリアによって積極的に追跡される必要がないと期待していました。しかし今、そのスタックはもはやどのスレッドにも所有されておらず、代わりに実行可能な zfiber_context によって所有されています。さらに悪いことに、その zfiber_context は黒(black)です。マークビットを設定しただけでなく、マークスタックからポップしてアウトゴーイングポインタをマークしたため、GC はそれを再度訪問しません!

これを解決するために、グレー(grey)な zfiber_context を追跡します。マーク中にコンテキストから swapcontext する場合、コンテキストがまだグレーでない場合、それを現在のスレッドの grey_fibers リストに追加し、そのグレービットを設定します。スレッドがスタックを再スキャンするように求められた場合、リスト内のすべてのグレーファイバーのスタックウォークを再度実行し、それらのファイバーのグレービットをクリアし、リストをクリアします。

ソフトハンドシェイクの使用により、終了時に楽しいほぼレース条件が発生する可能性があります。オンザフライ GC では、次のイベントシーケンスが発生する可能性があります。

  1. GC は作業を使い果たしたため、すべてのスタックをスキャンするためにソフトハンドシェイクをトリガーします。
  2. スレッド 1 はスタックスキャンを実行し、グレーファイバーのウォークとリセットを含め、新しいオブジェクトを見つけません。
  3. スレッド 1 は別のコンテキストに swapcontext します。これにより、グレーファイバーが空でなくなります。
  4. スレッド 2 はスタックスキャンを実行し、新しいオブジェクトを見つけません。
  5. 他のスレッドはありません。そして、どのスレッドも新しいオブジェクトを見つけなかったため、GC はスレッド 1 にグレーファイバーがあるにもかかわらず終了を宣言します。

現在、終了後にグレーファイバーリストをリセットするだけです。理由:ステップ 2 でスレッド 1 が新しいオブジェクトをマークするものを見つけなかった場合、スレッド 2 も新しいライブオブジェクトを見つけず、GC がステップ 1 で作業を使い果たした場合、コンテキストから切り離される前に、マークされていない他のオブジェクトが導入される可能性はありません。これは次の理由により真実です。

  • 新しく割り当てられたオブジェクトはマークされます。
  • ヒープに格納されたオブジェクトは、ストア時のバリアによってマークされます。
  • GC が作業を使い果たしたということは、マークされたすべてのオブジェクトがアウトゴーイングポインタをマークされたことを意味します。

このシナリオでは、スレッド 1 がヒープからマークされていないポインタをロードする可能性はまったくありません!

とはいえ、私の ucontext 実装にバグがあった場合、それはここになります。

まとめ

Glibc ビルドの Fil-C では ucontext API のみをサポートしています。したがって、/opt/fil https://fil-c.org/optfil.html および Pizlix https://fil-c.org/pizlix.html で利用できますが、pizfix https://fil-c.org/pizfix.html では利用できません。実装は次のとおりです。

getcontext は zfiber_context_new で新しい zfiber_context を割り当て、zfiber_context_bind_sigset(zfiber_context がユーザー表示可能な uc_sigmask と内部 sigmask を複製するようにする)を呼び出し、次に zfiber_context_getcontext を呼び出します。

setcontext は zfiber_context_setcontext を呼び出します。

makecontext は、ユーザー指定のメイン関数への引数渡しを管理する独自のトランポリンを作成します。また、ファイバーの終了(uc_link への切り替えまたは exit の呼び出し)も管理します。それ以外は、zfiber_context_makecontext を呼び出すだけです。

swapcontext は、ほとんどの場合 zfiber_context_swapcontext を実行します。from コンテキスト(別名 oucp)が初期化されていなかった場合、zfiber_context_new を使用してそれを割り当て、zfiber_context_bind_sigset を呼び出します。

注記:Fil-C は ucontext の代替コンテキストスイッチパスとして longjmp/setjmp の使用を許可していません。一部のソフトウェアは ucontext と longjmp/setjmp を混在させていますが、それらのすべてのケース(OpenSSL、あなたを見ています)には、混合を無効にするフラグがあります。なぜなら、Fil-C は、それを行うと壊れる唯一のセキュリティ技術ではないからです。

結論

Fil-C は、longjmp/setjmp スタイルと ucontext スタイルの両方を使用して、メモリ安全なコンテキストスイッチをサポートしています。ucontext スタイルはバージョン 0.681 で新しく追加されました。longjmp/setjmp 実装は古く、おそらくすでに非常に堅牢です。

このドキュメントが示すように、最も邪悪な機能でさえサポートするために努力した場合でも、メモリ安全な C を持つことは可能です!