Migrate to mkdocs

Signed-off-by: Dave Tucker <[email protected]>

Author: dave-tucker

.github/workflows/ci.yml

@@ -35,25 +35,23 @@ jobs:
 
       - uses: Swatinem/rust-cache@v1
 
-      - name: Install Dependencies
-        run: cargo install mdbook
+      - name: Set up Python
+        uses: actions/setup-python@v3
 
-      - name: Run tests
-        run: mdbook build && mdbook test
+      - name: Install python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+
+      - name: Build docs
+        run: mkdocs build
 
       - name: Check Examples
         run: |
-          for example in "aya-gen" "myapp-01" "myapp-02" "myapp-03"; do
+          for example in "aya-gen" "myapp-01" "myapp-02" "myapp-03" "lsm-nice"; do
             pushd "examples/${example}"
             echo "Example: ${example}."
             cargo xtask build-ebpf
             cargo build
             popd
           done
-
-      - name: Deploy 🚀
-        uses: JamesIves/[email protected]
-        if: github.ref == 'refs/heads/main'
-        with:
-          branch: gh-pages
-          folder: book

.gitignore

@@ -1 +1,2 @@
-book
+.venv
+site

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+  "yaml.schemas": {
+    "https://squidfunk.github.io/mkdocs-material/schema.json": "mkdocs.yml"
+  }
+}

book.toml

@@ -1,5 +1,9 @@
 # Using aya-gen
 
+!!! example "Source Code"
+
+    Full code for the example in this chapter is availble [here](https://github.com/aya-rs/book/tree/main/examples/aya-gen)
+
 Very often you will need to use type definitions that your running Linux kernel
 uses in its source code. For example, you might need a definition of
 [task_struct](https://elixir.bootlin.com/linux/v5.15.3/source/include/linux/sched.h#L723),
@@ -13,16 +17,16 @@ bindings for specific kernel structures.
 
 It can be installed with the following command:
 
-```bash
-cargo install --git https://github.com/aya-rs/aya -- aya-gen
+```console
+$ cargo install --git https://github.com/aya-rs/aya -- aya-gen
 ```
 
 Ensure that you have `bpftool` installed in your system, `aya-gen` is not going
 to work without it.
 
 The syntax of the command is:
 
-```bash
+```console
 $ aya-gen
 aya-gen 0.1.0
 
@@ -44,28 +48,26 @@ Let's also assume that your project is called `myapp`. Your userspace part is
 in `myapp` subdirectory, your eBPF part is in `myapp-ebpf`. We need to generate
 the bindings for the eBPF part, which can be done with:
 
-```bash
-aya-gen generate task_struct > myapp-ebpf/src/vmlinux.rs
+```console
+$ aya-gen generate task_struct > myapp-ebpf/src/vmlinux.rs
 ```
 
-> 💡 **HINT: Generating for multiple types**
->
-> You can also specify multiple types to generate, for example:
->
-> ```bash
-> aya-gen generate task_struct dentry > vmlinux.rs
-> ```
->
-> But in the following example, we will focus only on `task_struct`.
+!!! tip "Generating for multiple types"
+
+    You can also specify multiple types to generate, for example:
+    ```console
+    $ aya-gen generate task_struct dentry > vmlinux.rs
+    ```
+    But in the following example, we will focus only on `task_struct`.
 
 Then we can use `vmlinux` as a module with `mod vmlinux` in our eBPF program,
 like here:
 
-```rust,ignore
-{{#rustdoc_include ../../examples/aya-gen/myapp-ebpf/src/main.rs }}
+```rust linenums="1" title="myapp-ebpf/src/main.rs"
+--8<-- "examples/aya-gen/myapp-ebpf/src/main.rs"
 ```
 
-## Potability and different kernel versions
+## Portability and different kernel versions
 
 Structures generated by aya-gen are portable across different Linux kernel
 versions thanks to mechanism called

src/aya/aya-gen.md docs/book/aya/aya-gen.mdsrc/aya/aya-gen.md renamed to docs/book/aya/aya-gen.md

@@ -1,3 +1,3 @@
 # Using aya-log
 
-This page is a work in progress, please feel free to open a Pull Request!
+This page is a work in progress, please feel free to open a Pull Request!

src/aya/aya-log.md docs/book/aya/aya-log.mdsrc/aya/aya-log.md renamed to docs/book/aya/aya-log.md

@@ -1,3 +1,3 @@
 # Reading Values From A Context
 
-This page is a work in progress, please feel free to open a Pull Request!
+This page is a work in progress, please feel free to open a Pull Request!

src/aya/context.md docs/book/aya/context.mdsrc/aya/context.md renamed to docs/book/aya/context.md

@@ -1,3 +1,3 @@
 # Working With Aya
 
-This page is a work in progress, please feel free to open a Pull Request!
+This page is a work in progress, please feel free to open a Pull Request!

src/aya/index.md docs/book/aya/index.mdsrc/aya/index.md renamed to docs/book/aya/index.md

@@ -1,6 +1,6 @@
-# Introduction
+# Getting Started
 
-Welcome to Building eBPF Programs with Aya: An introductory book about using the Rust
+This getting started guide will help you use the Rust
 Programming Language and Aya library to build extended Berkley Packet Filter (eBPF)
 programs.
 
@@ -9,34 +9,34 @@ programs.
 Rust is proving to be a popular systems programming language because of its
 safety features and excellent C interoperability. The safety features are less
 important in the context of eBPF as programs often need to read kernel memory, which
-is considered unsafe. However, what Rust combined with Aya does offer is a fast and 
+is considered unsafe. However, what Rust combined with Aya does offer is a fast and
 efficient development experience:
 
 - Cargo for project scaffolding, build, test and debugging
 - Generation of Rust bindings to Kernel Headers with Compile-Once, Run-Everywhere (CO-RE) support
 - Easy code sharing between user-space and eBPF programs
 - Fast compile times
-- No runtime dependency on LLVM or BCC
+- No runtime dependency on LLVM, BCC or libbpf
 
 ## Scope
 
-The goals of this book are:
+The goals of this guide are:
 
 * Get developers up to speed with eBPF Rust development. i.e. How to set
   up a development environment.
 
 * Share *current* best practices about using Rust for eBPF
 
 
-## Who This Book is For
+## Who This Guide is For
 
-This book caters towards people with either some eBPF or some Rust background. For those without any prior knowledge we suggest you read the "Assumptions and Prerequisites" section first. You can check out the "Other Resources" section to find resources on topics you might want to read up on.
+This guide caters towards people with either some eBPF or some Rust background. For those without any prior knowledge we suggest you read the "Assumptions and Prerequisites" section first. You can check out the "Other Resources" section to find resources on topics you might want to read up on.
 
 ### Assumptions and Prerequisites
 
 * You are comfortable using the Rust Programming Language, and have written,
   run, and debugged Rust applications on a desktop environment. You should also
-  be familiar with the idioms of the [2021 edition] as this book targets
+  be familiar with the idioms of the [2021 edition] as this guide targets
   Rust 2021.
 
 [2021 edition]: https://doc.rust-lang.org/edition-guide/
@@ -45,21 +45,33 @@ This book caters towards people with either some eBPF or some Rust background. F
 
 ### Other Resources
 
-If you are unfamiliar with anything mentioned above or if you want more information about a specific topic mentioned in this book you might find some of these resources helpful.
+If you are unfamiliar with anything mentioned above or if you want more information about a specific topic mentioned in this guide you might find some of these resources helpful.
 
 | Topic        | Resource | Description |
 |--------------|----------|-------------|
 | Rust         | [Rust Book](https://doc.rust-lang.org/book/) | If you are not yet comfortable with Rust, we highly suggest reading this book. |
 | eBPF         | [Cilium BPF and XDP Reference Guide](https://docs.cilium.io/en/stable/bpf/) | If you are not yet comfortable with eBPF, this guide is excellent. |
 
-## How to Use This Book
+## How to Use This Guide
 
-This book generally assumes that you’re reading it front-to-back. Later
+This guide generally assumes that you’re reading it front-to-back. Later
 chapters build on concepts in earlier chapters, and earlier chapters may
 not dig into details on a topic, revisiting the topic in a later chapter.
 
-## Source Code
+## eBPF Program Constraints
 
-The source files from which this book is generated can be found on [GitHub][github].
+The eBPF Virtual Machine, where our eBPF programs will be run, is a constrained runtime environment:
 
-[github]: https://github.com/aya-rs/book
+- There is only 512 bytes of stack (or 256 bytes if we are using tail calls).
+- There is no access to heap space and data must instead be written to maps.
+
+Even applications written in C are restricted to a subset of language features, and we have similar
+constraints in Rust:
+
+- We may not use the standard library. We use `core` instead.
+- `core::fmt` may not be used and neither can traits that rely on it, for example `Display` and `Debug`
+- As there is no heap, we cannot use `alloc` or `collections`.
+- We must not `panic` as the eBPF VM does not support stack unwinding, or the `abort` instruction.
+- There is no `main` function
+
+Alongside this, a lot of the code that we write is `unsafe`, as we are reading directly from kernel memory.

src/intro/index.md docs/book/index.mdsrc/intro/index.md renamed to docs/book/index.md

@@ -1,3 +1,3 @@
 # Cgroups
 
-This page is a work in progress, please feel free to open a Pull Request!
+This page is a work in progress, please feel free to open a Pull Request!