📃 docs(创建自定义根文件系统和内核映像): 完成了文档

Author: CN059

docs/rootfs-and-kernel-setup.md

@@ -1,44 +1,38 @@
-# Creating Custom rootfs and kernel Images
+# 创建自定义根文件系统和内核映像
 
-## Creating a Linux kernel Image
+## 创建 Linux 内核映像
 
-### Manual compilation
+### 手动编译
 
-Currently, Firecracker supports uncompressed ELF kernel images on x86_64 while
-on aarch64 it supports PE formatted images.
+目前，Firecracker 在 x86_64 架构上支持未压缩的 ELF 内核映像，而在 aarch64 架构上则支持 PE 格式映像。
 
-Here's a quick step-by-step guide to building your own kernel that Firecracker
-can boot:
+以下是快速构建可供 Firecracker 启动的自定义内核的分步指南：
 
-1. Get the Linux source code:
+1. 获取 Linux 源代码：
 
    ```bash
    git clone https://github.com/torvalds/linux.git linux.git
    cd linux.git
    ```
 
-1. Check out the Linux version you want to build (e.g. we'll be using v4.20
-   here):
+1. 检出要构建的 Linux 版本（例如，我们这里将使用 v4.20）：
 
    ```bash
    git checkout v4.20
    ```
 
-1. You will need to configure your Linux build. You can start from our
-   recommended [guest kernel configurations](../resources/guest_configs/) by
-   copying the relevant one to `.config` (under the Linux sources dir). You can
-   make interactive config adjustments using:
+1. 您需要配置 Linux 构建环境。可从我们推荐的[客户机内核配置](../resources/guest_configs/) 开始，将相关配置文件复制到 `.config`（位于 Linux 源代码目录下）。您可通过以下命令进行交互式配置调整：
 
    ```bash
    make menuconfig
    ```
 
 > [!NOTE]
 >
-> There are many ways of building a kernel config file, other than `menuconfig`.
-> You are free to use whichever one you choose.
+> 构建内核配置文件的方式多种多样，不仅限于 `menuconfig`。
+> 您可自由选择任意一种方式。
 
-1. Build the kernel image:
+1. 构建内核映像：
 
    ```bash
    arch=$(uname -m)
@@ -49,182 +43,145 @@ can boot:
    fi
    ```
 
-1. Upon a successful build, you can find the kernel image under `./vmlinux` (for
-   x86) or `./arch/arm64/boot/Image` (for aarch64).
+1. 构建成功后，您可以在 `./vmlinux`（x86 架构）或 `./arch/arm64/boot/Image`（aarch64 架构）目录下找到内核映像文件。
 
-For a list of currently supported kernel versions, check out the
-[kernel support policy](kernel-policy.md).
+有关当前支持的内核版本列表，请查看[内核支持策略](kernel-policy.md)。
 
-### Use the provided recipe
+### 使用预设方案
 
-The kernel images used in our CI to test Firecracker's features are obtained by
-running the script `resources/rebuild.sh`.
+我们在持续集成中用于测试 Firecracker 功能的内核镜像是通过运行脚本`resources/rebuild.sh`获取的。
 
-Users can build those locally by running:
+用户可通过运行以下命令在本地构建这些内容：
 
 ```bash
 ./tools/devtool build_ci_artifacts kernels
 ```
 
-This will build all versions that we currently use in our CI. `kernels`
-subcommand allows passing a specific kernel version to build. For example:
+这将构建我们当前在 CI 中使用的所有内核版本。`kernels` 子命令允许传入一个特定的内核版本进行构建。例如：
 
 ```bash
 ./tools/devtool build_ci_artifacts kernels 6.1
 ```
 
-will build only the 6.1 kernel.
+将仅构建 6.1 内核。
 
-Currently supported kernel versions are: `5.10`, `5.10-no-acpi` (same as 5.10
-but without ACPI support) and `6.1`.
+当前支持的内核版本为：`5.10`、`5.10-no-acpi`（与 5.10 相同，但不支持 ACPI）以及 `6.1`。
 
-After the command finishes, the kernels along with the corresponding KConfig
-used will be stored under `resources/$(uname -m)`.
+命令执行完成后，构建好的内核及其对应的 KConfig 配置文件将被存储在 `resources/$(uname -m)` 目录下。
 
-## Creating a Linux rootfs Image
+## 创建 Linux 根文件系统映像
 
-A rootfs image is just a file system image, that hosts at least an init system.
-For instance, our getting started guide uses an ext4 filesystem image. Note
-that, whichever file system you choose to use, support for it will have to be
-compiled into the kernel, so it can be mounted at boot time.
+根文件系统映像本质上就是一个文件系统映像，至少包含一个初始化系统。
+例如，我们的入门指南使用的是 ext4 文件系统映像。请注意，无论选择哪种文件系统，都必须将其支持编译到内核中，以便在启动时挂载。
 
-In order to obtain an ext4 image that you can use with Firecracker, you have the
-following options:
+要获取可与 Firecracker 配合使用的 ext4 映像，您有以下几种选择：
 
-### Manual build
+### 手动构建
 
-1. Prepare a properly-sized file. We'll use 50MiB here, but this depends on how
-   much data you'll want to fit inside:
+1. 准备大小合适的文件。此处使用 50MiB，但具体取决于您希望放入多少数据：
 
    ```bash
    dd if=/dev/zero of=rootfs.ext4 bs=1M count=50
    ```
 
-1. Create an empty file system on the file you created:
+1. 在创建的文件上建立空文件系统：
 
    ```bash
    mkfs.ext4 rootfs.ext4
    ```
 
-You now have an empty EXT4 image in `rootfs.ext4`, so let's prepare to populate
-it. First, you'll need to mount this new file system, so you can easily access
-its contents:
+此时`rootfs.ext4`已生成空的 EXT4 映像，接下来准备填充内容。首先需挂载新文件系统以便访问其内容：
 
 ```bash
 mkdir /tmp/my-rootfs
 sudo mount rootfs.ext4 /tmp/my-rootfs
 ```
 
-The minimal init system would be just an ELF binary, placed at `/sbin/init`. The
-final step in the Linux boot process executes `/sbin/init` and expects it to
-never exit. More complex init systems build on top of this, providing service
-configuration files, startup / shutdown scripts for various services, and many
-other features.
+最简化的初始化系统仅是一个 ELF 二进制文件，位于`/sbin/init`路径下。Linux 启动过程的最后一步会执行`/sbin/init`，并期望该程序永不退出。更复杂的初始化系统在此基础上构建，提供服务配置文件、各类服务的启动/关闭脚本以及诸多其他功能。
 
-For the sake of simplicity, let's set up an Alpine-based rootfs, with OpenRC as
-an init system. To that end, we'll use the official Docker image for Alpine
-Linux:
+为简化操作，我们建立一个基于 Alpine 的根文件系统，并采用 OpenRC 作为初始化系统。为此，我们将使用官方的 Alpine Linux Docker 镜像：
 
-1. First, let's start the Alpine container, bind-mounting the EXT4 image created
-   earlier, to `/my-rootfs`:
+1. 首先启动 Alpine 容器，将先前创建的 EXT4 镜像挂载到 `/my-rootfs`：
 
    ```bash
    docker run -it --rm -v /tmp/my-rootfs:/my-rootfs alpine
    ```
 
-1. Then, inside the container, install the OpenRC init system, and some basic
-   tools:
+1. 然后，在容器内部安装 OpenRC 初始化系统以及一些基本工具：
 
    ```bash
    apk add openrc
    apk add util-linux
    ```
 
-1. And set up userspace init (still inside the container shell):
+1. 并设置用户空间初始化程序（仍处于容器 shell 中）：
 
    ```bash
-   # Set up a login terminal on the serial console (ttyS0):
+   # 在串行控制台（ttyS0）上设置登录终端：
    ln -s agetty /etc/init.d/agetty.ttyS0
    echo ttyS0 > /etc/securetty
    rc-update add agetty.ttyS0 default
 
-   # Make sure special file systems are mounted on boot:
+   # 确保特殊文件系统在启动时挂载：
    rc-update add devfs boot
    rc-update add procfs boot
    rc-update add sysfs boot
 
-   # Then, copy the newly configured system to the rootfs image:
+   # 然后，将新配置的系统复制到根文件系统映像中：
    for d in bin etc lib root sbin usr; do tar c "/$d" | tar x -C /my-rootfs; done
 
-   # The above command may trigger the following message:
+   # 上述命令可能会触发以下提示：
    # tar: Removing leading "/" from member names
-   # However, this is just a warning, so you should be able to
-   # proceed with the setup process.
+   # 但这仅为警告信息，您仍可继续执行设置流程。
 
    for dir in dev proc run sys var; do mkdir /my-rootfs/${dir}; done
 
-   # All done, exit docker shell.
+   # 完成，退出 Docker 终端。
    exit
    ```
 
-1. Finally, unmount your rootfs image:
+1. 最后，卸载您的根文件系统映像：
 
    ```bash
    sudo umount /tmp/my-rootfs
    ```
 
-### Use the provided recipe
+### 使用预设配置
 
-The disk images used in our CI to test Firecracker's features are obtained by
-using the recipe (in a Ubuntu 22.04 host):
+我们 CI 中用于测试 Firecracker 功能的磁盘镜像，是通过以下方法（在 Ubuntu 22.04 主机上）生成的：
 
 ```bash
 ./tools/devtool build_ci_artifacts rootfs
 ```
 
-The images resulting using this method are minimized Ubuntu 22.04. Feel free to
-adjust the script(s) to suit your use case.
+使用此方法生成的镜像为精简版 Ubuntu 22.04。请根据实际需求自由调整脚本。
 
-You should now have a rootfs image (`ubuntu-22.04.ext4`), that you can boot with
-Firecracker.
+您现在应获得一个根文件系统镜像（`ubuntu-22.04.ext4`），可通过 Firecracker 进行引导。
 
-## Creating FreeBSD rootfs and kernel Images
+## 创建 FreeBSD 根文件系统和内核映像
 
-Here's a quick step-by-step guide to building a FreeBSD rootfs and kernel that
-Firecracker can boot:
+以下是快速构建 FreeBSD 根文件系统和内核的分步指南，Firecracker 可由此启动：
 
-1. Boot a FreeBSD system. In EC2, the
-   [FreeBSD 13 Marketplace image](https://aws.amazon.com/marketplace/pp/prodview-ukzmy5dzc6nbq)
-   is a good option; you can also use weekly snapshot AMIs published by the
-   FreeBSD project. (Firecracker support is in FreeBSD 14 and later, so you'll
-   need FreeBSD 13 or later to build it.)
+1. 启动 FreeBSD 系统。在 EC2 中，[FreeBSD 13 市场映像](https://aws.amazon.com/marketplace/pp/prodview-ukzmy5dzc6nbq)是不错的选择；您也可以使用 FreeBSD 项目发布的每周快照 AMI。（Firecracker 支持需 FreeBSD 14 及以上版本，因此构建时需使用 FreeBSD 13 或更高版本。）
 
-   The build will require about 50 GB of disk space, so size the disk
-   appropriately.
+   构建过程约需 50 GB 磁盘空间，请预留足够容量。
 
-1. Log in to the FreeBSD system and become root. If using EC2, you'll want to
-   ssh in as `ec2-user` with your chosen SSH key and then `su` to become root.
+1. 登录 FreeBSD 系统并获取 root 权限。若使用 EC2，请通过 SSH 以`ec2-user`身份登录（需使用预先配置的 SSH 密钥），随后执行`su`切换至 root 用户。
 
-1. Install git and check out the FreeBSD src tree:
+1. 安装 git 并检出 FreeBSD 源代码树：
 
    ```sh
    pkg install -y git
    git clone https://git.freebsd.org/src.git /usr/src
    ```
 
-   Firecracker support is available since FreeBSD 14.0 (released November 2023).
+   自 FreeBSD 14.0 版本（2023 年 11 月发布）起支持 Firecracker。
 
-1. Build FreeBSD:
+1. 构建 FreeBSD：
 
    ```sh
    make -C /usr/src buildworld buildkernel KERNCONF=FIRECRACKER
    make -C /usr/src/release firecracker DESTDIR=`pwd`
    ```
 
-You should now have a rootfs `freebsd-rootfs.bin` and a kernel
-`freebsd-kern.bin` in the current directory (or elsewhere if you change the
-`DESTDIR` value) that you can boot with Firecracker. Note that the FreeBSD
-rootfs generated in this manner is somewhat minimized compared to "stock"
-FreeBSD; it omits utilities which are only relevant on physical systems (e.g.,
-utilities related to floppy disks, USB devices, and some network interfaces) and
-also debug files and the system compiler.
+你现在应该在当前目录（或者如果你修改了 DESTDIR 的值，则在指定目录）中得到了一个 rootfs 文件 freebsd-rootfs.bin 和一个内核文件 freebsd-kern.bin，它们可以直接用于 Firecracker 启动。需要注意的是，通过这种方式生成的 FreeBSD rootfs 相比“标准版” FreeBSD 已经过一定程度的精简；它移除了仅在物理系统上有用的工具（例如与软盘、USB 设备和某些网络接口相关的工具），同时也去除了调试文件和系统编译器。