Now, I have done a talk about eBPF before, but today I'm going to do something new in that I am writing my code, or at least my user space code, with Go today, it's the first time I've done the talk using Go, so that's the new twist that we're going to tackle today.

以前にもeBPFについての講演をしたことがあるのですが、今日はGoを使ってコードを書くという新しいことをします。

So, before I get into the point where I'm going to start using Go and start writing some code, I should probably start by talking a little bit about what eBPF is.

さて、これからGoを使ってコードを書き始める前に、eBPFとは何かということから少し話しておこう。

Key thing is, it lets you run custom programs of your choice in the kernel, so it's a Linux kernel feature technology that lets you, on the fly, add and change code programs that are going to run in response to events, and you can change them dynamically without having to reboot the machine, so much, much more powerful than writing a kernel module.

重要なのは、カーネル内で好きなカスタム・プログラムを実行できることだ。つまり、Linuxカーネルの機能技術で、イベントに応じて実行するコード・プログラムをその場で追加・変更でき、マシンをリブートすることなく動的に変更できるので、カーネル・モジュールを書くよりもずっとずっと強力なのだ。

We've seen eBPF becoming really a hot technology over the last few years, because it's so powerful and because you can hook it into so many different events, we're seeing it used in lots of observability tools, we're starting to see it used for security as well.

eBPFは非常に強力で、様々なイベントにフックすることができるため、ここ数年で本当にホットなテクノロジーになってきている。

Today, I'm going to talk more about how it works and hopefully give you enough grounding that you can go away and start writing your own eBPF code.

今日は、eBPFがどのように機能するのかについて詳しく説明し、あなたがeBPFのコードを書き始めるのに十分な基礎知識を与えたいと思う。

Now, if we're going to run some code in the kernel, but as developers, we're usually writing applications in user space, so how do we communicate between user space and kernel?

さて、カーネルでコードを実行するとしても、開発者としては通常、ユーザー空間でアプリケーションを書くわけで、ユーザー空間とカーネルの間でどのように通信するのだろうか？

The answer is system calls.

答えはシステムコールだ。

System calls provide the interface between user space and kernel.

システムコールは、ユーザー空間とカーネル間のインターフェースを提供する。

So, I can make a pretty good guess that there would be a system call related to eBPF, and there certainly is.

だから、eBPFに関連するシステムコールがあるだろうと、私はかなり推測できる。

If we look up the man page for BPF, we'll find lots of really helpful information about what BPF is and how we use it.

BPFのmanページを調べると、BPFとは何か、どのように使うのか、本当に役立つ情報がたくさんある。

So, first of all, BPF stands for Berkeley Packet Filters.

まず、BPFとはバークレー・パケット・フィルターの略だ。

I'm going to use the word eBPF and BBF pretty interchangeably.

私はeBPFとBBFを同じ意味で使うつもりだ。

Historically, it was about filtering network packets, running custom code when a network packet arrived.

歴史的には、ネットワーク・パケットをフィルタリングし、ネットワーク・パケットが到着したらカスタム・コードを実行するというものだった。

That's been extended.

それは延長された。

You can now run your BPF programs in response to lots and lots of different types of events, not just the arrival of a network packet.

ネットワーク・パケットの到着だけでなく、さまざまなタイプのイベントに反応してBPFプログラムを実行できるようになった。

So, whether it's classic BPF or eBPF doesn't really matter these days.

だから、クラシックなBPFであろうとeBPFであろうと、最近はあまり関係ない。

But in both cases, you're running code in the kernel, and you really, really don't want the kernel to crash or hang.

しかしどちらの場合も、あなたはカーネル内でコードを実行しているわけで、カーネルがクラッシュしたりハングアップしたりするのは避けたい。

So, when we want to run some eBPF code, it goes through a verification step to make sure that it's safe to run.

そのため、eBPFのコードを実行したい場合、実行しても安全であることを確認するための検証ステップを経る。

So, that's something we'll talk a little bit more about later.

それについては、後でもう少し詳しく話すことにしよう。

So, we have some eBPF code that's going to run in the kernel.

つまり、カーネル内で実行されるeBPFコードがある。

We have user space application code that, as developers, is normally where we're used to writing code.

ユーザースペースのアプリケーションコードは、開発者として通常コードを書くのに慣れている場所だ。

And there's a system call interface between the two.

そして、この2つの間にはシステムコールのインターフェイスがある。

And I think if we look at the system calls, that can actually be quite helpful for understanding really what's happening when we're talking about inserting code into the kernel.

システムコールを見れば、カーネルにコードを挿入するときに何が起きているのかを理解するのに役立つと思う。

So, I'm going to start by using an example.

では、まず例を挙げて説明しよう。

I'm going to use BPF trace.

BPFトレースを使うつもりだ。

This is quite a widely used tool for running BPF scripts on a system.

これは、システム上でBPFスクリプトを実行するために広く使われているツールだ。

And so, I'm going to show this partly as an example to show the kind of things you can do with BPF, and partly so that we can examine the system calls that happen when we run it.

それで、BPFでどんなことができるかを示すための一例として、またBPFを実行したときに起こるシステムコールを調べるための一例として、これをお見せします。

So, let's explore some BPF trace and the system calls it uses.

それでは、BPFのトレースとそれが使用するシステムコールを調べてみよう。

So, I have an example that I'm going to use.

だから、これから使う例があるんだ。

It doesn't really matter that much what my example is.

私の例がどうであるかは、それほど重要ではない。

But in this case, I'm setting up a script that's going to run on a trace point.

しかし今回は、トレースポイントで実行するスクリプトをセットアップしている。

It's running when we call the sysenter.

シセンターを呼び出すと動いている。

The sysenter function actually gets triggered for every single system call.

sysenter関数は、実際にはシステムコールのたびにトリガーされる。

So, I'm going to run a script every time any process on my virtual machine calls a system call.

そこで、仮想マシン上のプロセスがシステムコールを呼び出すたびに、スクリプトを実行することにする。

And it's going to run this script.

そしてこのスクリプトを実行する。

What that script actually does is it takes, it sets up a counter for the number of times each different command makes a system call.

このスクリプトが実際に行うのは、各コマンドがシステムコールを行う回数のカウンターを設定することだ。

So, if I try to run that, well, you have to be a privileged user to do it.

だから、それを実行しようとすると、特権ユーザーでないとできない。

That kind of makes sense.

それは理にかなっている。

You don't want every unprivileged user running code in your kernel.

あなたは、すべての非特権ユーザーにカーネル内のコードを実行させたくない。

So, I can use sudo.

だからsudoが使える。

I just run that for a few seconds, and then I'll interrupt it.

それを数秒間実行して、中断するんだ。

And it's going to show us for each different kind of command that's running on my machine, the number of system calls.

私のマシンで実行されているコマンドの種類ごとに、システムコールの回数が表示される。

I mean, that's quite interestingly powerful that we can get to such fine granularity as counting every single system call that's happening on my machine.

つまり、私のマシンで起こっているシステムコールをひとつひとつカウントするような細かい粒度までできるのは、非常に興味深い強力なことなのだ。

So, I'm going to run the same thing again.

だから、もう一度同じことをやってみる。

But this time, let's have a look at the BPF system calls that are being called.

しかし今回は、呼び出されているBPFシステムコールを見てみよう。

So, I do that with strace.

だから、ストレースを使うんだ。

I'm just going to look for BPF system calls and quit it after a few seconds.

BPFのシステムコールを探して、数秒後に終了するんだ。

And the thing that I want to show you is these BPF system calls that are being called.

ここでお見せしたいのは、呼び出されるBPFシステムコールである。

So, we see a few map create, we see map update element, and we see program load.

マップの作成、マップの更新、そしてプログラムのロード。

So, that tells us something or indicates something about a couple of concepts we need to know about.

このことは、私たちが知るべきいくつかの概念について、何かを教えてくれる、あるいは示してくれる。

Those are BPF programs and BPF maps.

それがBPFプログラムとBPFマップだ。

So, we use the same call, but with a different parameter to manipulate programs and maps.

そこで、同じ呼び出しを、別のパラメータを使ってプログラムとマップを操作する。

So, starting with the programs, what are those programs?

では、まずプログラムとは何か？

Well, I mean, they're programs.

まあ、プログラムだからね。

They run on the CPU.

CPU上で動作する。

They're essentially machine code instructions.

基本的にはマシンコードの命令だ。

But for BPF, we're restricted in what we can run because of that requirement for BPF code to be safe.

しかし、BPFの場合は、BPFのコードが安全でなければならないため、実行できるものに制限がある。

It mustn't crash, it mustn't loop.

クラッシュしてはいけないし、ループしてはいけない。

So, we typically write our BPF programs in C, a restricted set of C, which we don't use any loops.

そのため、BPFのプログラムは通常、ループを使わないC言語で書いている。

We always have to check that a pointer is not null before we dereference it.

ポインターを再参照する前に、そのポインターがNULLでないことを常にチェックしなければならない。

And then we use the Clang compiler to convert it into an eBPF object, a set of bytecode instructions that are going to get run inside a BPF virtual machine inside the kernel.

そしてClangコンパイラーを使ってeBPFオブジェクトに変換し、カーネル内のBPF仮想マシン内で実行されるバイトコード命令のセットにする。

So, we're going to write the kernel code in C.

そこで、カーネルのコードをCで書くことにする。

We get some helper functions that give us some useful contextual information.

便利なコンテクスト情報を与えてくれるヘルパー関数がいくつかある。

So, for example, we can print debugging messages with a helper function.

例えば、ヘルパー関数を使ってデバッグ・メッセージを表示することができる。

We can get information about the current running command.

現在実行中のコマンドに関する情報を得ることができる。

That's how BPF trace knows which command is running, as we saw in the previous example.

前の例で見たように、これがBPFトレースがどのコマンドが実行されているかを知る方法だ。

Lots of, I guess, a few dozen of these helper functions that can help us with contextual information.

このようなヘルパー関数は、文脈に沿った情報を提供してくれる。

The other thing I talked about was maps, or the other thing we saw in our system course was maps.

もうひとつ話したのは地図で、システムコースで見たのも地図だった。

And maps are really how we get information between our eBPF program running in the kernel and user space.

そしてマップは、カーネルで動作するeBPFプログラムとユーザー空間の間で情報を得る方法なのだ。

We'll come back to a bit more detail about maps shortly.

地図については、もう少し詳しく説明することにしよう。

And then the last kind of conceptual thing we really need to know about is the fact that these programs are triggered by an event happening.

そして、最後に概念的なこととして知っておかなければならないのは、これらのプログラムは、ある出来事によってトリガーされるという事実だ。

We saw an event, an example where we run a program in response to system calls, in response to triggering a hook at the entry to the function called sysenter.

システムコールに応答してプログラムを実行する例として、sysenterと呼ばれる関数のエントリーでフックをトリガーするイベントを見た。

There are tons of these hooks already predefined, essentially every function entry and exit, every system call, every trace point in the kernel, every time a network packet arrives.

このようなフックはすでに大量に定義されており、本質的には、すべての関数の入口と出口、すべてのシステムコール、カーネル内のすべてのトレースポイント、ネットワークパケットが到着するたびにある。

All of these are possible points where you can trigger an eBPF program.

これらはすべて、eBPFプログラムを発動できる可能性のあるポイントである。

And we also have the term k-probe and u-probe.

また、kプローブやuプローブという言葉もある。

The k-probe is the entry to a kernel function.

kプローブはカーネル関数のエントリである。

A k-rep probe is the exit from a kernel function, and correspondingly the same for user space.

k-repプローブとは、カーネル関数からの出口であり、ユーザー空間についても同様である。

Combination of all these different types of events means we can really run eBPF code in response to pretty much anything that's happening in your Linux machine.

これらすべての異なるタイプのイベントを組み合わせることで、Linuxマシンで起こっているほとんどすべてのことに反応してeBPFコードを実行することができる。

So how do we attach the program to an event?

では、どうやってプログラムをイベントに組み込めばいいのか？

And again, I think it's a little bit helpful to look at the system calls that are happening.

そしてまた、起こっているシステムコールを見ることは少し役に立つと思う。

We're going to not just use the BPF call, but also a couple more system calls per event open, which sets up a trace point.

BPFコールだけでなく、イベントオープンごとにさらに2、3のシステムコールを使い、トレースポイントを設定する。

So program load gives us a file descriptor that I've called x here.

プログラム・ロードは、ここでxと呼んでいるファイル・ディスクリプタを与えてくれる。

The trace point comes back as y, and then there's an IO control event that associates the trace point with the program that should be triggered.

トレース・ポイントはyとして戻ってくる。そして、トレース・ポイントとトリガーされるべきプログラムを関連付けるIOコントロール・イベントがある。

So again we can take a look at that in our BPF trace example.

BPFトレースの例を見てみよう。

Again, I just trace out those additional system calls to event, oops, event open, and let's see.

もう一度、event、ops、event openへの追加のシステムコールをトレースしてみよう。

Again, it doesn't really matter too much exactly what's happening.

繰り返すが、何が起こっているかはあまり重要ではない。

I just really want to show you this program load BPF call that comes back with the file descriptor of nine.

このプログラム・ロードBPFコールが、9のファイル・ディスクリプタとともに戻ってくるところをお見せしたい。

There should be perf event open.

イベントが開かれているはずだ。

Yeah, this perf event open here, which comes back with a file descriptor of eight.

そう、このperfイベント・オープンは、ファイル・ディスクリプタが8で戻ってくる。

And then here is the IO control that associates eight and nine and says, this is the BPF program that I want you to run when we hit that trace point.

そしてこれはIOコントロールで、8と9を関連付け、トレースポイントに到達したときに実行させたいBPFプログラムであることを示す。

So loading the program and associating the program with the trace point is something we're going to have to do from user space.

だから、プログラムをロードし、トレース・ポイントにプログラムを関連づけるのは、ユーザー・スペースからやらなければならないことなのだ。

Okay, so if we want to write hello world in eBPF, what do we need to do?

では、eBPFでhello worldを書きたい場合、どうすればいいのだろう？

What do we need to have in place?

何が必要なのか？

We know we're going to have to write some C code that's going to run in the kernel and that's going to get compiled by Clang.

カーネルで実行されるCコードを書かなければならないことは分かっているし、それはClangによってコンパイルされる。

And we're going to have to write some user space code that gets the tracing, the hello world message from the kernel and displays it.

そして、カーネルからトレースやhello worldメッセージを取得して表示するユーザー・スペース・コードを書かなければならない。

And we can write that, at least in theory, we can write it in any language of our choice.

そして、少なくとも理論上は、好きな言語で書くことができる。

For most of us, we don't typically interact with system calls very often when we're writing user space applications.

ユーザー・スペース・アプリケーションを書いているとき、システム・コールを使うことはあまりない。

There's usually some level of abstraction.

通常、ある程度の抽象度はある。

And in fact, many of us don't know that system calls exist.

そして実際、私たちの多くはシステムコールの存在を知らない。

We don't have to deal with them on a day-to-day basis.

日常的に彼らと付き合う必要はない。

For BPF, there is, we would want a library, a BPF library that gives us a higher level of abstraction over those BPF system calls and things like the perf event open that we just saw.

BPFについては、BPFのシステムコールや、先ほど見たperfのイベントオープンのようなものをより抽象化してくれるような、BPFライブラリが欲しいところです。

And the library that I'm going to use today is called libbpf-go.

今日使うライブラリーはlibbpf-goだ。

And we actually wrote this as part of a tool called Tracy that's an eBPF security event detection tool we're working on.

これは、私たちが取り組んでいるeBPFセキュリティ・イベント検出ツールのTracyというツールの一部として書いたものです。

And we've isolated the libbpf wrapper.

そしてlibbpfラッパーを分離した。

So there's a C library called libbpf, which is a wrapper for the system calls.

libbpfというCライブラリがあり、これはシステムコールのラッパーだ。

And libbpf-go is a pretty thin go wrapper, giving us go bindings around those libbpf interface.

そしてlibbpf-goはかなり薄いgoラッパーで、libbpfインターフェースの周りにgoバインディングを与えてくれる。

So we're going to write some go code that uses libbpf-go.

では、libbpf-goを使ったgoのコードを書いてみよう。

And we're also going to write some C code, which we're going to compile into eBPF objects using the Clang compiler.

Clangコンパイラーを使ってeBPFオブジェクトにコンパイルする。

And then the go code is going to read that object file, get the contents out, insert it into the kernel.

そしてゴー・コードがそのオブジェクト・ファイルを読み込み、中身を取り出し、カーネルに挿入する。

So we have an object file that has the eBPF code and the definition of any maps.

つまり、eBPFコードとあらゆるマップの定義を持つオブジェクト・ファイルがある。

Talk about maps a bit more later.

地図についてはもう少し後で話そう。

We have our user space code that's driving our system calls and has the kind of logic around what programs we want to run, what we want to attach them to.

ユーザースペースコードがあり、それがシステムコールを駆動し、どのプログラムを実行し、何にアタッチするかというロジックを持っている。

When the user space code calls that BPF program load, it sends the program to the kernel.

ユーザー空間のコードがBPFプログラムのロードを呼び出すと、そのプログラムがカーネルに送られる。

The kernel will verify it, make sure that it's safe to run.

カーネルはそれを検証し、実行しても安全であることを確認する。

And if it is, it will start running it inside this BPF virtual machine.

もしそうなら、このBPF仮想マシン内で実行を開始する。

So we're going to build two objects.

そこで、2つのオブジェクトを作ることにする。

We've got two different compilation steps.

我々は2つの異なるコンパイルのステップを持っている。

We've got to use the go compiler, go build, to create a go executable.

goコンパイラー、go buildを使ってgoの実行ファイルを作らなければならない。

And we're going to use Clang to build the BPF object file.

そしてClangを使ってBPFオブジェクト・ファイルをビルドする。

All right.

分かった。

I think we have enough to actually start writing some code.

実際にコードを書き始めるには十分だと思う。

So let's go to my editor.

では、編集長に話を聞こう。

And this is my make file.

そしてこれが私のメイクファイルだ。

It's pretty much exactly what I just showed you on the slide.

先ほどスライドでお見せしたこととほぼ同じです。

So we have a go build step and a Clang step for building the eBPF object.

そこで、eBPFオブジェクトをビルドするためのgoビルドステップとClangステップを用意した。

And let's start with the C code.

そしてCのコードから始めよう。

So I'm going to write a function called hello.

そこで、helloという関数を書こうと思う。

Exit context pointer, they all do.

コンテクストポインタを終了する。

I'm going to just do some hello world tracing.

ちょっとハローワールドをトレースしてみるよ。

So let's say hello, go topia.

だから、挨拶しよう。

And we'll return zero exit code.

そして、ゼロの終了コードを返す。

The other thing I have to do is define an object code section.

もうひとつやらなければならないのは、オブジェクトコードのセクションを定義することだ。

This tells the, essentially, the object loader what kind of BPF program this is going to be.

これは、本質的には、オブジェクト・ローダーに、これがどのようなBPFプログラムになるのかを伝えるものだ。

This is kind of a level of detail we don't need to worry about too much today.

これは今日、あまり気にする必要のないレベルの話だ。

But you can write, you can use different helper functions and do different things depending on the type of program you're running and the type of event you're attaching it to.

しかし、プログラムの種類やイベントの種類によって、さまざまなヘルパー関数を使い、さまざまなことができる。

So I'm going to attach to a K probe the entry point to a function in a kernel.

そこで、Kプローブにカーネル内の関数へのエントリー・ポイントをアタッチすることにする。

And I'm actually going to run this whenever the system call exec V gets triggered.

そして、システムコールのexec Vがトリガーされるたびに、これを実行するつもりだ。

So that's my C code.

これが私のCコードだ。

And let's compile that.

そして、それをまとめよう。

So I'm just going to run the make on my BPF object file target to start with.

そこで、まずはBPFオブジェクト・ファイルをターゲットにしてmakeを実行することにする。

And that should give me an object file that I can look at.

そうすれば、私が見ることのできるオブジェクトファイルができるはずだ。

And there are a couple of interesting things to look at in this object file.

そして、このオブジェクト・ファイルには興味深いことがいくつかある。

So, first of all, it's a little engine machine.

だから、まず第一に、これは小さなエンジンマシンなんだ。

I will need that in a moment.

すぐに必要なんだ。

And this object file is designed, it's compiled to run in a Linux BPF virtual machine.

このオブジェクト・ファイルは、Linux BPF仮想マシンで実行できるようにコンパイルされている。

We can see here's the section declaration for the fact that it's running as a K probe on sysex exec V.

このセクションの宣言は、SYSEX EXEC VのKプローブとして実行されていることを示している。

And here is the function name.

そしてこれが関数名である。

So I might say eBPF program.

だから、私はeBPFプログラムと言うかもしれない。

A program is really a function.

プログラムとはまさに関数である。

So that information from the L file is what is going to help the Go code know how to insert it into the kernel.

つまり、Lファイルからの情報は、Goコードがカーネルに挿入する方法を知るのに役立つものなのだ。

So let's write some Go code.

では、Goのコードを書いてみよう。

Right.

そうだね。

I already have a reference to libBPF Go here.

libBPFへのリファレンスはすでにここにある。

And I have a convenience function called must that I'm going to use to trap any errors and panic crash if we see any errors.

mustという便利な関数があるので、それを使ってエラーをトラップし、エラーが出たらパニック・クラッシュする。

Hopefully we won't hit that.

そうならないことを祈るよ。

Don't do that in production.

本番でそれをやってはいけない。

Really bad idea.

本当に悪い考えだ。

But it will be fine for demo purposes.

しかし、デモ用には問題ないだろう。

So the first thing I'm going to do is I'm going to open this file.

まず最初に、このファイルを開きます。

I'm going to do new module from file.

ファイルから新しいモジュールを作るつもりだ。

And reading from that object file that we just built.

そして、先ほど構築したオブジェクト・ファイルから読み込む。

We want to catch any errors.

どんなエラーもキャッチしたい。