图片无法显示，请右键点击新窗口打开图片

目录

1.1 BiscuitOS 介绍

BiscuitOS 社区基于 BiscuitOS 项目构建，BiscuitOS 项目初衷是将所有的 Linux 知识都可以进行实践，项目经历 8 年的发展已经涵盖了众多 Linux 场景和文档，并不断引入更新更有趣的实践内容, 让抽象复杂的 Linux 技术在 BiscuitOS 实践面前无处遁形. BiscuitOS 由五层构成，分别如下:

  • 模拟器层(Emulator Layer): 最底层由 QEMU、Broiler 和 Gem5 等模拟器构成，模拟器可以在不需要额外准备硬件的前提下，可以虚拟成不同架构的 CPU、DDR 内存大小、SSD 磁盘以及 GPU 等外设，这让 BiscuitOS 实践环境得到统一, 也降低开发者的实践成本.
  • Docker 核心层: BiscuitOS 根据内核版本自动选择 Docker 版本，皆在屏蔽不同 HOST 平台兼容性问题，DOCKER Core 提供了 Ubuntu18.06、Ubuntu20.04 以及 Ubuntu24.04 环境，让 BiscuitOS 的使用不再局限于 Ubuntu.
  • 核心平台层(Platform Core): BiscuitOS 的核心逻辑提供了多种实践平台的配置逻辑，开发者可以根据需求自定义实践环境的规格，并一键部署实践所需的全部源码、镜像、模拟器和调试工具，一切为了开发者将实践成本和难度降到最低.
  • 硬件虚拟层(Virtual Hardware Layer): 开发者在模拟器创建的虚拟环境里实践，那么该层是模拟器运行时模拟的硬件环境，包括 CPU、DDR、SSD、GPU、网卡等外设硬件.
  • 内核层(Kernel Layer): 实践的虚拟机分为两层，其中一层是内核层，该层可以是 Linux 内核，也可以是其他内核，例如 MIT XV6 内核、SerenityOS 内核等. 该层很好的模拟了内核的运行环境，可以实践内核相关的知识.
  • 用户空间(Userspace): 实践虚拟机的用户空间，默认 BiscuitOS 提供基于 Busybox 的 Rootfs，同时也支持多种 Rootfs，例如 Debian/Ubuntu、MIT XV6 等.

BiscuitOS 目前支持 linux 0.x、1.x、2.x、3.x、4.x、5.x 以及最新 6.x 内核, 架构方面全量支持 Intel X86_64 以及部分支持 i386、ARM、ARM64、RISCV32 以及 RISCV64 架构. BiscuitOS 项目制作的 Linux 称为 BiscuitOS 发行版, 其包含了 ROOTFS、BUSYBOX、Linux 内核以及第三方开源软件，另外 BiscuitOS 项目使用 QEMU 作为底座，可模拟定制化硬件、也可以直接在 X86 机器上运行. BiscuitOS 为开发者带来六大功能:

功能一: BiscuitOS 社区 为 BiscuitOS 项目提供了巨量的实践文档，包括 BiscuitOS 构建、内存管理、文件系统、虚拟化、基础研究等上百篇实践文档，均基于 BiscuitOS 实践进行简介，让理论和实践最佳结合。

功能二: BiscuitOS 提供了便捷的 Linux 源码查看、编译、调试工具，并提供特定场景的代码，可以边查看 Linux 源码，边对源码进行修改并进行实践，加上 ChatGPT 的加持，让开发者学习 Linux 事半功倍!

功能三: BiscuitOS 支持很多 Linux 内核版本的一键部署，例如最早的 Linux 0.11 内核、最新的 Linux 内核，基于覆盖了所有的 Linux 内核版本，另外还支持 X86 架构、i386 架构、ARM 架构、ARM64 架构以及 RISCV 架构，除此之外还包括对 Debian 特殊版本、Uboot、RaspberryPi、Apollo1、MIT-XV6 以及 SeaBIOS 开发环境的一键部署.

功能四: BiscuitOS 项目提供了丰富的开源软件，既包括应用程序、游戏、内核模块，也包括动态库、调试工具等。所有软件均可使用一键部署功能，轻松实现软件的部署、编译和使用.

功能五: BiscuitOS 项目可以对硬件进行模拟，可支持对 DMA、PCI、PCIe、IOMMU、MMIO、PIO、MSIX、PMEM、DMA-BUF、DMA-POOL、HMM、NUMA 以及 CXL 的实践，另外 Broiler 项目更大自由度的多硬件定制和模拟，开发者不用再为实践而花费购买昂贵硬件，另外开发者可以自定义 BiscuitOS 运行系统的硬件，例如内存大小、CPU 数量、以及不同文件系统的磁盘, 这些在 BiscuitOS 点点手指硬件环境一键部署.

功能六: BiscuitOS 项目提供了特殊的调试工具，可以精准调试: 缺页异常、SWAP OUT/IN 一个物理页、一次完整的系统调用、异步 DROP CACHE 一个 PAGE CACHE、跟踪一次 MMIO 虚拟化完整链路等，这些调试工具可以帮助开发者降低复杂场景的实践难度，加速对新知识的认知.

1.2 BiscuitOS 安装

BiscuitOS 已经支持全量的 Docker 环境，因此只需准备一台可以运行 Docker 的 X86 机器作为开发机，开发机优先推荐 Ubuntu24.04. 准备好一台开发机之后，开发者根据使用不同发行版需要提前安装开发工具，这些工具主要用于项目的下载和部署前期的准备，参考如下代码:

# Ubuntu/Debian
sudo apt-get update
sudo apt-get install git make figlet gawk flex bison docker.io

第一步: 基础开发软件安装完毕之后，接下来从 Gitee 上下载 BiscuitOS 项目源码(BiscuitOS 的下载需要扫描上图二维码，联系 BuddyZhang1 开放下载权限)，开发者为了加快下载速度可以使用 depth 参数，如果想看所有的代码提交，需要一定时间下载，参考如下代码:

git clone https://gitee.com/BiscuitOS_team/BiscuitOS.git --depth=1

  • arch 目录是架构相关的配置
  • board 目录是 BiscuitOS 支持硬件开发板相应的配置
  • boot 是 BiscuitOS 系统使用的 BOOTLOAD 相关的配置
  • config 目录下是 BiscuitOS 项目支持的部署开发环境
  • dl 目录是 BiscuitOS 项目部署过程中下载的源码压缩包
  • fs 目录是 BiscuitOS 使用的文件系统配置
  • kernel 目录是 BiscuitOS 部署内核相关的配置
  • package 目录是 BiscuitOS 支持的开源软件库配置
  • scripts 目录是 BiscuitOS 部署过程中使用的脚本
  • toolchain 目录是 BiscuitOS 部署使用的交叉编译工具配置
  • output 目录是 BiscuitOS 部署不同版本 Linux 开发环境的位置

第二步: BiscuitOS 目前全量支持 Docker 环境开发，接下来联系 BuddyZhang1 获得 Docker 镜像. Docker 镜像下载好之后，执行如下命令:

cd BiscuitOS/
mkdir -p dl/
# 将下载好的 Docker 镜像拷贝到 dl 目录下
cp BiscuitOS-DOCKER-UBUNTU-1604.tar dl/
cp BiscuitOS-DOCKER-UBUNTU-2004.tar dl/
cp BiscuitOS-DOCKER-UBUNTU-2404.tar dl/

第三步: Docker 镜像安装完毕之后，接下来进入 Docker，BiscuitOS 会根据所部署的 Linux 版本选择正确的 Docker 镜像，例如部署 “Linux 6.10” 内核，使用如下命令:

cd BiscuitOS/
make linux-6.10-x86_64_defconfig
make docker

# 注意! 当你在 Docker 里面，想部署其他版本的内核，使用如下命令
# 1. 退出 Docker
#    exit
# 2. 关闭 Docker
#    make docker-clean
# 3. 选择新的 Linux 版本
#    make linux-5.10-x86_64_defconfig
# 4. 进入 Docker
#    make docker

命令执行完毕之后，BiscuitOS 项目将部署基于 X86-64 架构的 Linux 6.0 源码开发环境，如果开发者还想添加其他开源软件一同部署，那么可以直接使用命令开启图形化配置，与 Linux 内核的 Kbuild menuconfig 一致:

make menuconfig

  • Porject Name 选项指明开发环境在 output 目录下的名字
  • Architecture configure 选项下面用于选择部署环境的架构
  • Board setup 选项下面用于选择与模拟硬件相关的信息
  • Bootloaders 选项下面用于选择 BiscuitOS 启动是采用的 Bootloader
  • DIY BiscuitOS/Broiler Hardware 选项下面用于自定义 BiscuitOS 运行时的硬件
  • package 选项下面用于添加第三方开源软件
  • Root-Filesystem 选项下面用于配置 BiscuitOS 系统根文件系统的配置
  • Compile toolchain 选项下面用于配置开发环境编译使用的交叉编译工具
  • linux 用于配置 Linux 的版本.

上图是 Kbuild 图形化配置界面，当开发者使用了 “make linux-6.0-x86_64_defconfig” 命令之后，Kbuild 已经自动配置上图相关的配置，开发者可以根据自己的需要进行修改。修改完毕之后使用如下命令进行一键部署:

make

部署完毕之后，开发者会看到 4 条信息，第一条信息指明了 Linux 开发环境的位置; 第二条信息指明 Linux 源码的位置; 第三条信息指明 Linux 开发手册; 第四条是 BiscuitOS 社区的链接. 接下来进入开发环境所在的目录，BiscuitOS 里所有的开发环境均放在 output 目录下:

  • Broiler-system: Broiler 目录支持自定义硬件模拟
  • busybox: BiscuitOS 系统使用的 BUSYBOX 源码目录
  • FreezeDir: BiscuitOS 系统数据盘挂载目录
  • HardStack.BS: 里面 BiscuitOS 代码仓库配置文件
  • Hardware: BiscuitOS 模拟的硬件，包括磁盘、内存等
  • linux: Linux 源码目录
  • package: 第三方开源软件目录
  • qemu-system: BiscuitOS 模拟底座 QEMU 源码目录
  • README.md: 开发环境说明文档
  • rootfs: BiscuitOS 系统使用的根文件系统
  • RunBiscuitOS.sh: BiscuitOS 运行脚本

BiscuitOS 一键部署的开发环境基本布局如上，其中 RunBiscuitOS.sh 是自动生成，只要在 BiscuitOS 项目顶层执行一次 make 命令，那么 RunBiscuitOS.sh 脚本就自动生成一次，脚本里面包含了 BiscuitOS 虚拟机启动的参数、硬件配置等. README.md 里描述了编译 Linux、Busybox 以及打包 ROOTFS 的命令，由于不同版本的 Linux 配置不同，无法将 README 里面的步骤自动化，因此开发者接下来需要参考 README.md 里面的内容完成最后的编译工作:

当执行完 README.md 里面的命令之后，可以启动 BiscuitOS，此时 BiscuitOS 系统作为一个虚拟机运行，开发者可以发挥自己的想象，任意修改 BiscuitOS 进行实践. 至此 BiscuitOS 安装成功! 当需要完全退出容器时，可以使用如下命令:

cd BiscuitOS/
make docker-clean

1.3 部署基础源码仓

1.3.1 部署应用程序

BiscuitOS 支持应用程序开发环境的一键部署和实践，免去了复杂的源码查找、编写、编译、打包等操作，开发者可以参考如下步骤在 BiscuitOS 上实践应用程序, 首先使用 BiscuitOS 部署应用程序，其部署逻辑如下:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的应用程序
make menuconfig

  [*] Package  --->
      [*] BiscuitOS Demo Code  --->
          [*] Application Demo Code on BiscuitOS  --->

# 配置完毕保存，然后进行部署
make

# 部署完毕之后，切换到开发环境所在的目录
cd BiscuitOS/output/linux-6.0-x86_64/package/BiscuitOS-Application-default/
# 部署源码
make download

应用程序开发环境的目录结构如上图，顶层的 Makefile 用于实现 BiscuitOS 编译控制，README.md 则是介绍编译控制命令介绍，BiscuitOS-Application-default 目录下 “make download” 下载源码之后生成的，其中 main.c 是应用程序的源码, Makefile 是 main.c 编译文件，开发者可以根据自身需求修改编译过程，假如已经编译过源码，BiscuitOS-Application-default 是编译生成的可执行文件，最终在 BiscuitOS 上运行.

# 编译源码
make
# 安装应用程序
make install
# 更新 ROOTFS
make pack
# 运行 BiscuitOS
make run

当 BiscuitOS 运行之后，直接运行 BiscuitOS-Application-default 应用程序，可以看到应用程序按预期打印了字符串。有了上面的应用程序开发环境之后，开发者可以发挥自己的想象修改 main.c 源码，并使用上面命令在 BiscuitOS 实践验证, 如果开发者觉得验证过程中需要输入很多命令才能启动 BiscuitOS，开发者可以在修改并保存代码之后，直接使用 make build 命令进行一键验证，直接提高实践效率。BiscuitOS 应用程序开发环境一共为开发者提供了如下命令:

  • make: 编译应用程序
  • make install: 安装应用程序
  • make pack: 重新打包 BiscuitOS 系统的 ROOTFS
  • make run: 运行 BiscuitOS
  • make build: 一键验证应用程序
  • make clean: 清除编译文件
  • make distclean: 清空源码
  • make download: 下载源码
  • make kernel: 编译内核
  • make broiler: 将应用程序打包到 Broiler
  • make rootfs_install: 将应用程序打包到嵌套 BiscuitOS 系统里

1.3.2 部署内核模块

BiscuitOS 支持内核模块的一键部署和实践，免去了复杂的源码查找、编写、编译、打包等操作，开发者可以参考如下步骤在 BiscuitOS 上实践内核模块, 首先使用 BiscuitOS 部署内核模块，其部署逻辑如下:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核模块
make menuconfig

  [*] Package  --->
      [*] BiscuitOS Demo Code  --->
          [*] Module Demo Code on BiscuitOS  --->

# 配置完毕保存，然后进行部署
make

# 部署完毕之后，切换到开发环境所在的目录
cd BiscuitOS/output/linux-6.0-x86_64/package/BiscuitOS-modules-default/
# 部署源码
make download

内核模块开发环境的目录结构如上图，顶层的 Makefile 用于实现 BiscuitOS 编译控制，README.md 则是介绍编译控制命令介绍，BiscuitOS-module-default 目录下 “make download” 下载源码之后生成的，其中 main.c 是内核模块的源码, Makefile 是 main.c 编译文件，Makefile.host 是在 Host 直接编译的文件，RunBiscuitOS.sh 文件是在 BiscuitOS 运行之后，一键运行模块相关的所有命令，开发者可以向该文件里添加需要运行的命令. 开发者可以根据自身需求修改编译过程，假如已经编译过源码，BiscuitOS-module-default.ko 是编译生成的 KO 文件，最终在 BiscuitOS 上加载运行.

# 编译源码
make
# 安装源码
make install
# 打包 ROOTFS
make pack
# 运行 BiscuitOS
make run

当 BiscuitOS 运行之后，使用 insmod 命令加载内核模块，内核模块位于 “/lib/modules/$(uname -r)/extra/” 目录下，可以看到模块正确加载并打印预期的字符串，开发者如果想加快模块的安装，可以在系统运行之后，直接运行 RunBiscuitOS.sh，其会运行所需的命令。有了上面的内核模块开发环境之后，开发者可以发挥自己的想象修改 main.c 源码，并使用上面命令在 BiscuitOS 实践验证, 如果开发者觉得验证过程中需要输入很多命令才能启动 BiscuitOS，开发者可以在修改并保存代码之后，直接使用 make build 命令进行一键验证，直接提高实践效率。BiscuitOS 应用程序开发环境一共为开发者提供了如下命令:

  • make: 编译应用程序
  • make install: 安装应用程序
  • make pack: 重新打包 BiscuitOS 系统的 ROOTFS
  • make run: 运行 BiscuitOS
  • make build: 一键验证应用程序
  • make clean: 清除编译文件
  • make distclean: 清空源码
  • make download: 下载源码
  • make kernel: 编译内核
  • make broiler: 将应用程序打包到 Broiler
  • make rootfs_install: 将应用程序打包到嵌套 BiscuitOS 系统里

1.3.3 部署内核 INITCALL 程序

BiscuitOS 支持内核 INITCALL 程序的一键部署和实践，免去了复杂的源码查找、编写、编译、打包等操作。在 Linux 启动过程中，会使用 INITCALL 机制按顺序启动内核子系统，那么 BiscuitOS 支持将程序嵌入到内核，并在指定的 INITCALL 之后运行，这可以大大提高对内核功能的验证. 开发者可以参考如下步骤在 BiscuitOS 上实践内核 INITCALL 程序, 首先使用 BiscuitOS 部署内核 INITCALL 程序，其部署逻辑如下:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核 INITCALL 程序
make menuconfig

  [*] Package  --->
      [*] BiscuitOS Demo Code  --->
          [*] Kernel Demo Code on BiscuitOS  --->

# 配置完毕保存，然后进行部署
make

# 部署完毕之后，切换到开发环境所在的目录
cd BiscuitOS/output/linux-6.0-x86_64/package/BiscuitOS-kernel-default/
# 部署源码
make download

内核 INITCALL 程序开发环境的目录结构如上图，顶层的 Makefile 用于实现 BiscuitOS 编译控制，README.md 则是介绍编译控制命令介绍，KRunBiscuitOS.sh 做调试过滤信息使用，后面调试章节会详细介绍. BiscuitOS-kernel-default 目录下 “make download” 下载源码之后生成的，其中 main.c 是内核 INITCALL 程序的源码, Makefile 是 main.c 编译文件，Kconfig 是内核宏定义文件. 开发者可以修改 main.c 源文件里的 XXX_initcall 函数，以此确认程序运行的时机，最后在 BiscuitOS 上加载运行.

# 编译源码
make
# 安装源码
make install
# 打包 ROOTFS
make pack
# 运行 BiscuitOS
make run

BiscuitOS 系统启动过程中，INITCALL 程序就会自动运行，开发者可以在 BiscuitOS 运行之后，使用 dmesg 查看启动 LOG，从中找出 INITCALL 程序运行的足迹，上图可以看出 INITCALL 程序已经正确执行。有了上面的内核 INITCALL 程序开发环境之后，开发者可以发挥自己的想象修改 main.c 源码，并使用上面命令在 BiscuitOS 实践验证, 如果开发者觉得验证过程中需要输入很多命令才能启动 BiscuitOS，开发者可以在修改并保存代码之后，直接使用 make build 命令进行一键验证，直接提高实践效率。BiscuitOS 应用程序开发环境一共为开发者提供了如下命令:

  • make: 编译应用程序
  • make install: 安装应用程序
  • make pack: 重新打包 BiscuitOS 系统的 ROOTFS
  • make run: 运行 BiscuitOS
  • make build: 一键验证应用程序
  • make clean: 清除编译文件
  • make distclean: 清空源码
  • make download: 下载源码
  • make kernel: 编译内核
  • make broiler: 将应用程序打包到 Broiler
  • make rootfs_install: 将应用程序打包到嵌套 BiscuitOS 系统里

开发者有没有发现，每次编译内核 INITCALL 程序的时候，都会重新编译一次内核，因此可以将内核 INITCALL 程序开发环境作为内核编译的接口，直接使用 “make build” 命令就可以快速编译和实践内核.

1.3.4 部署内核 AnyWhere 程序

BiscuitOS 支持将一段独立程序嵌入到内核任何位置的一键部署和实践，免去了复杂的源码查找、编写、编译、打包等操作。BiscuitOS 通过提供一段段独立的模块化代码，用于对内核特定阶段的代码进行实践，这将大大增加 BiscuitOS 对内核的可实践度, 这也是 BiscuitOS 特殊功能之一，开发者可以参考如下步骤在 BiscuitOS 进行部署和实践，其部署逻辑如下:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核 AnyWhere 程序
make menuconfig

  [*] Package  --->
      [*] BiscuitOS Demo Code  --->
          [*] Kernel Anywhere Demo Code on BiscuitOS  --->

# 配置完毕保存，然后进行部署
make

# 部署完毕之后，切换到开发环境所在的目录
cd BiscuitOS/output/linux-6.0-x86_64/package/BiscuitOS-kernel-any-default/
# 部署源码
make download

内核 AnyWhere 程序开发环境的目录结构如上图，顶层的 Makefile 用于实现 BiscuitOS 编译控制，README.md 则是介绍编译控制命令介绍. BiscuitOS-kernel-any-default 目录下 “make download” 下载源码之后生成的，其中 main.c 是内核 AnyWhere 程序的源码, Makefile 是 main.c 编译文件，Kconfig 是内核宏定义文件, BiscuitOS_Insert.bs 是一个配置文件，用于配置 AnyWhere 程序在内核中运行的位置:

在 BiscuitOS_Insert.bs 配置文件中，[Content] 下一个描述 AnyWhere 程序中需要插入的函数名字, [File] 下一行描述 AnyWhere 函数插入位置所在的文件，[Func] 下一行描述 AnyWhere 函数插入文件里指定函数之后一行，例如上图的意思是将 main.c 文件中的 BiscuitOS_Running() 函数插入到 Linux 源码 init/main.c 文件里 setup_arch() 函数之后. 开发者需要注意插入文件中只有一个 [Func] 指向的函数. 最后在 BiscuitOS 上加载运行.

# 编译源码
make
# 安装源码
make install
# 打包 ROOTFS
make pack
# 运行 BiscuitOS
make run

BiscuitOS 系统启动过程中，AnyWhere 程序会在指定位置运行，开发者可以在 BiscuitOS 运行之后，使用 dmesg 查看启动 LOG，从中找出 AnyWhere 程序运行的足迹，上图可以看出 AnyWhere 程序已经正确执行。有了上面的内核 AnyWhere 程序开发环境之后，开发者可以发挥自己的想象修改 main.c 源码，并使用上面命令在 BiscuitOS 实践验证, 如果开发者觉得验证过程中需要输入很多命令才能启动 BiscuitOS，开发者可以在修改并保存代码之后，直接使用 make build 命令进行一键验证，直接提高实践效率。BiscuitOS 应用程序开发环境一共为开发者提供了如下命令:

  • make: 编译应用程序
  • make install: 安装应用程序
  • make pack: 重新打包 BiscuitOS 系统的 ROOTFS
  • make run: 运行 BiscuitOS
  • make build: 一键验证应用程序
  • make clean: 清除编译文件
  • make distclean: 清空源码
  • make download: 下载源码
  • make kernel: 编译内核
  • make broiler: 将应用程序打包到 Broiler
  • make rootfs_install: 将应用程序打包到嵌套 BiscuitOS 系统里

1.3.5 部署字符设备模块

BiscuitOS 支持字符设备相关的用户进程和内核模块一键部署和实践，免去了复杂的源码查找、编写、编译、打包等操作。BiscuitOS 通过提供一套完成的调用程序，充分使用字符设备提供的内核接口，可以快速部署字符设备的应用场景, 这也是 BiscuitOS 特殊功能之一，开发者可以参考如下步骤在 BiscuitOS 进行部署和实践，其部署逻辑如下:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的字符设备模块
make menuconfig

  [*] Package  --->
      [*] BiscuitOS Demo Code  --->
          [*] Char-DD Demo Code on BiscuitOS  --->

# 配置完毕保存，然后进行部署
make

# 部署完毕之后，切换到开发环境所在的目录
cd BiscuitOS/output/linux-6.0-x86_64/package/BiscuitOS-Char-default/
# 部署源码
make download

字符设备开发环境的目录结构如上图，顶层的 Makefile 用于实现 BiscuitOS 编译控制，README.md 则是介绍编译控制命令介绍. BiscuitOS-Char-default 目录下 “make download” 下载源码之后生成的，其中 main.c 是字符设备驱动的源码, app.c 是调用字符设备接口的应用程序，Makefile 是 main.c 编译文件，Kconfig 是内核宏定义文件, Makefile.host 是字符设备在主机上的编译脚本, RunBiscuitOS.sh 是实践案例运行的所有命令合集，最后在 BiscuitOS 上加载运行.

# 编译源码
make
# 安装源码
make install
# 打包 ROOTFS
make pack
# 运行 BiscuitOS
make run

当 BiscuitOS 运行之后，使用 insmod 命令加载内核模块，内核模块位于 “/lib/modules/$(uname -r)/extra/” 目录下，可以看到模块正确加载并打印预期的字符串，接着运行应用程序 APP，可以看到应用程序与字符设备模块进行数据交互. 开发者如果想加快模块的安装，可以在系统运行之后，直接运行 RunBiscuitOS.sh，其会运行所需的命令。有了上面的内核模块开发环境之后，开发者可以发挥自己的想象修改 main.c 源码，并使用上面命令在 BiscuitOS 实践验证, 如果开发者觉得验证过程中需要输入很多命令才能启动 BiscuitOS，开发者可以在修改并保存代码之后，直接使用 make build 命令进行一键验证，直接提高实践效率。BiscuitOS 应用程序开发环境一共为开发者提供了如下命令:

  • make: 编译应用程序
  • make install: 安装应用程序
  • make pack: 重新打包 BiscuitOS 系统的 ROOTFS
  • make run: 运行 BiscuitOS
  • make build: 一键验证应用程序
  • make clean: 清除编译文件
  • make distclean: 清空源码
  • make download: 下载源码
  • make kernel: 编译内核
  • make broiler: 将应用程序打包到 Broiler
  • make rootfs_install: 将应用程序打包到嵌套 BiscuitOS 系统里

1.3.6 部署 MISC 设备模块

BiscuitOS 支持 MISC 设备相关的用户进程和内核模块一键部署和实践，免去了复杂的源码查找、编写、编译、打包等操作。BiscuitOS 通过提供一套完成的调用程序，充分使用 MISC 设备提供的内核接口，可以快速部署 MISC 设备的应用场景, 这也是 BiscuitOS 特殊功能之一，开发者可以参考如下步骤在 BiscuitOS 进行部署和实践，其部署逻辑如下:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的 MISC 设备模块
make menuconfig

  [*] Package  --->
      [*] BiscuitOS Demo Code  --->
          [*] MISC-DD Demo Code on BiscuitOS  --->

# 配置完毕保存，然后进行部署
make

# 部署完毕之后，切换到开发环境所在的目录
cd BiscuitOS/output/linux-6.0-x86_64/package/BiscuitOS-MISC-default/
# 部署源码
make download

MISC 设备开发环境的目录结构如上图，顶层的 Makefile 用于实现 BiscuitOS 编译控制，README.md 则是介绍编译控制命令介绍. BiscuitOS-MISC-default 目录下 “make download” 下载源码之后生成的，其中 main.c 是 MISC 设备驱动的源码, app.c 是调用 MISC 设备接口的应用程序，Makefile 是 main.c 编译文件，Kconfig 是内核宏定义文件, Makefile.host 是 MISC 设备在主机上的编译脚本, RunBiscuitOS.sh 是实践案例运行的所有命令合集，最后在 BiscuitOS 上加载运行.

# 编译源码
make
# 安装源码
make install
# 打包 ROOTFS
make pack
# 运行 BiscuitOS
make run

当 BiscuitOS 运行之后，使用 insmod 命令加载内核模块，内核模块位于 “/lib/modules/$(uname -r)/extra/” 目录下，可以看到模块正确加载并打印预期的字符串，接着运行应用程序 APP，可以看到应用程序与 MISC 设备模块进行数据交互. 开发者如果想加快模块的安装，可以在系统运行之后，直接运行 RunBiscuitOS.sh，其会运行所需的命令。有了上面的内核模块开发环境之后，开发者可以发挥自己的想象修改 main.c 源码，并使用上面命令在 BiscuitOS 实践验证, 如果开发者觉得验证过程中需要输入很多命令才能启动 BiscuitOS，开发者可以在修改并保存代码之后，直接使用 make build 命令进行一键验证，直接提高实践效率。BiscuitOS 应用程序开发环境一共为开发者提供了如下命令:

  • make: 编译应用程序
  • make install: 安装应用程序
  • make pack: 重新打包 BiscuitOS 系统的 ROOTFS
  • make run: 运行 BiscuitOS
  • make build: 一键验证应用程序
  • make clean: 清除编译文件
  • make distclean: 清空源码
  • make download: 下载源码
  • make kernel: 编译内核
  • make broiler: 将应用程序打包到 Broiler
  • make rootfs_install: 将应用程序打包到嵌套 BiscuitOS 系统里

1.3.7 部署 Platform 设备模块

BiscuitOS 支持 Platform 设备内核模块一键部署和实践，免去了复杂的源码查找、编写、编译、打包等操作。内核里有很多需要使用 Platform 的场景，BiscuitOS 可以快速部署 Platform 设备的应用场景, 这也是 BiscuitOS 特殊功能之一，开发者可以参考如下步骤在 BiscuitOS 进行部署和实践，其部署逻辑如下:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的 Platform 设备模块
make menuconfig

  [*] Package  --->
      [*] BiscuitOS Demo Code  --->
          [*] Platform Device Driver Demo  --->

# 配置完毕保存，然后进行部署
make

# 部署完毕之后，切换到开发环境所在的目录
cd BiscuitOS/output/linux-6.0-x86_64/package/BiscuitOS-Platform-default/
# 部署源码
make download

Platform 设备开发环境的目录结构如上图，顶层的 Makefile 用于实现 BiscuitOS 编译控制，README.md 则是介绍编译控制命令介绍. BiscuitOS-Platform-default 目录下 “make download” 下载源码之后生成的，其中 main.c 是 Platform 设备驱动的源码, Makefile 是 main.c 编译文件，Kconfig 是内核宏定义文件, Makefile.host 是 MISC 设备在主机上的编译脚本, RunBiscuitOS.sh 是实践案例运行的所有命令合集，最后在 BiscuitOS 上加载运行.

# 编译源码
make
# 安装源码
make install
# 打包 ROOTFS
make pack
# 运行 BiscuitOS
make run

当 BiscuitOS 运行之后，使用 insmod 命令加载内核模块，内核模块位于 “/lib/modules/$(uname -r)/extra/” 目录下，可以看到模块正确加载并打印预期的字符串. 开发者如果想加快模块的安装，可以在系统运行之后，直接运行 RunBiscuitOS.sh，其会运行所需的命令。有了上面的内核模块开发环境之后，开发者可以发挥自己的想象修改 main.c 源码，并使用上面命令在 BiscuitOS 实践验证, 如果开发者觉得验证过程中需要输入很多命令才能启动 BiscuitOS，开发者可以在修改并保存代码之后，直接使用 make build 命令进行一键验证，直接提高实践效率。BiscuitOS 应用程序开发环境一共为开发者提供了如下命令:

  • make: 编译应用程序
  • make install: 安装应用程序
  • make pack: 重新打包 BiscuitOS 系统的 ROOTFS
  • make run: 运行 BiscuitOS
  • make build: 一键验证应用程序
  • make clean: 清除编译文件
  • make distclean: 清空源码
  • make download: 下载源码
  • make kernel: 编译内核
  • make broiler: 将应用程序打包到 Broiler
  • make rootfs_install: 将应用程序打包到嵌套 BiscuitOS 系统里

1.3.8 部署第三方开源软件

开发过程中进程需要使用第三方开源软件，例如 lspci、strace、numactl 等，BiscuitOS 支持第三方开源软件一键部署和实践，免去了复杂的源码查找、编写、编译、打包等操作，本节以 strace 开源软件为例进行讲解，开发者可以参考如下步骤在 BiscuitOS 进行部署和实践，其部署逻辑如下:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的 strace
make menuconfig

  [*] Package  --->
      [*] strace  --->

# 配置完毕保存，然后进行部署
make

# 部署完毕之后，切换到开发环境所在的目录
cd BiscuitOS/output/linux-6.0-x86_64/package/strace-5.0/
# 部署源码
make download
# 解压源码
make tar

第三方开源软件下载之后需，一般以压缩包形式存在，有的是直接从 git 仓库下载下来，此时需要使用 “make tar” 命令进行源码解压。解压之后如上图，顶层的 Makefile 用于实现 BiscuitOS 编译控制，README.md 则是介绍编译控制命令介绍. strace-5.0.tar.xz 是源码压缩包，第一次部署时 BiscuitOS 会从网上进行下载，下载还之后放在 BiscuitOS 项目的 dl 目录下，因此在离线场景中，可以先将源码压缩包放在 dl 目录下; strace-5.0 目录是解压之后的源码目录，最后编译源码并在 BiscuitOS 上运行:

# 配置项目
make configure
# 编译源码
make
# 安装源码
make install
# 打包 ROOTFS
make pack
# 运行 BiscuitOS
make run

当 BiscuitOS 运行之后，可以直接运行 strace 第三方开源软件，有了上面的第三方开发环境之后，开发者可以发挥自己的想象修改源码，并使用上面命令在 BiscuitOS 实践验证, 如果开发者觉得验证过程中需要输入很多命令才能启动 BiscuitOS，开发者可以在修改并保存代码之后，直接使用 make build 命令进行一键验证，直接提高实践效率。BiscuitOS 应用程序开发环境一共为开发者提供了如下命令:

  • make: 编译应用程序
  • make install: 安装应用程序
  • make pack: 重新打包 BiscuitOS 系统的 ROOTFS
  • make run: 运行 BiscuitOS
  • make build: 一键验证应用程序
  • make clean: 清除编译文件
  • make distclean: 清空源码
  • make download: 下载源码
  • make kernel: 编译内核
  • make broiler: 将应用程序打包到 Broiler
  • make rootfs_install: 将应用程序打包到嵌套 BiscuitOS 系统里
  • make prepare: 自动安装依赖库

1.3.9 部署共享库

开发过程中进程需要使用动态共享库，例如 libnuma、libelf、libz 等，BiscuitOS 支持开源共享库的一键部署和实践，免去了复杂的源码查找、编写、编译、打包等操作，本节以 libnuma 开源软件为例进行讲解，开发者可以参考如下步骤在 BiscuitOS 进行部署和实践，其部署逻辑如下:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的 libnuma
make menuconfig

  [*] Package  --->
      [*] NUMA Mechanism  --->
          [*] numctl tools and libnuma library  ---> 

# 配置完毕保存，然后进行部署
make

# 部署完毕之后，切换到开发环境所在的目录
cd BiscuitOS/output/linux-6.0-x86_64/package/numactl-libnuma-default/
# 部署源码
make download
# 解压源码
make tar

开源动态库下载之后需，一般以压缩包形式存在，有的是直接从 git 仓库下载下来，此时需要使用 “make tar” 命令进行源码解压。解压之后如上图，顶层的 Makefile 用于实现 BiscuitOS 编译控制，README.md 则是介绍编译控制命令介绍. 第一次部署时 BiscuitOS 会从网上进行下载，下载还之后放在 BiscuitOS 项目的 dl 目录下，因此在离线场景中，可以先将源码压缩包放在 dl 目录下; numactl-libnuma-default 目录是解压之后的源码目录，最后编译源码并在 BiscuitOS 上运行:

# 配置项目
make configure
# 编译源码
make
# 安装源码
make install
# 打包 ROOTFS
make pack
# 运行 BiscuitOS
make run

当 BiscuitOS 运行之后，可以在 /usr/lib 目录下查看 libnuma 相关的库，也可以直接使用 libnuma 开源项目提供的命令 numactrl 等，有了上面的动态库开发环境之后，开发者可以发挥自己的想象修改源码，并使用上面命令在 BiscuitOS 实践验证, 如果开发者觉得验证过程中需要输入很多命令才能启动 BiscuitOS，开发者可以在修改并保存代码之后，直接使用 make build 命令进行一键验证，直接提高实践效率。BiscuitOS 应用程序开发环境一共为开发者提供了如下命令:

  • make: 编译应用程序
  • make install: 安装应用程序
  • make pack: 重新打包 BiscuitOS 系统的 ROOTFS
  • make run: 运行 BiscuitOS
  • make build: 一键验证应用程序
  • make clean: 清除编译文件
  • make distclean: 清空源码
  • make download: 下载源码
  • make kernel: 编译内核
  • make broiler: 将应用程序打包到 Broiler
  • make rootfs_install: 将应用程序打包到嵌套 BiscuitOS 系统里
  • make prepare: 自动安装依赖库

1.3.10 快速配置、编译内核

BiscuitOS 项目是为内核开发而生，因此 BiscuitOS 集成了内核快速开发的命令，开发者可以参考本节实现内核的快速开发。首先开发者需要在 BiscuitOS 上部署内核开发工具集, 其部部署逻辑如下:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [*] Package  --->
      [*] BiscuitOS Demo Code  --->
          [*] Kernel Demo Code on BiscuitOS  --->

# 配置完毕保存，然后进行部署
make

# 部署完毕之后，切换到开发环境所在的目录
cd BiscuitOS/output/linux-6.0-x86_64/package/BiscuitOS-kernel-default/

内核开发工具集的目录结构如上图，顶层的 Makefile 用于实现 BiscuitOS 编译控制，README.md 则是介绍编译控制命令介绍，KRunBiscuitOS.sh 做调试过滤信息使用，后面调试章节会详细介绍. 接下来介绍工具集命令:

  • make: 编译内核
  • make menuconfig: 配置内核
  • make install: 安装 KRunBiscuitOS.sh 脚本
  • make pack: 重新打包 BiscuitOS 系统的 ROOTFS
  • make run: 运行 BiscuitOS
  • make build: 一键编译并运行内核
  • make broiler: 将编译好的内核打包到 Broiler
  • make rootfs_install: 将编译好的内核打包到嵌套 BiscuitOS 系统里
  • make module: 编译内核模块

有了上面命令之后，开发者无需关系什么架构或者什么版本内核，直接使用上面的命令就可以实现内核快速编译，make build 命令更可一键实现编译加运行，大大提高了内核开发效率. make menuconfig 命令可以方便配置内核选项，make module 命令会编译出内核模块依赖文件，这会影响独立模块编译.

2. BiscuitOS 内存能力

2.1 修改 DDR 内存大小

BiscuitOS 可以为模拟的系统设置内存大小，默认 DDR 内存大小为 512M，开发者可以参考如下命令修改模拟系统内存的大小:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      (512) Memory Size(MiB)

# 保存并退出，配置生效
make

开发者可以在 “Memory Size” 选项里写入内存的大小，单位为 MiB. 设置完毕并退出保存，最后执行 “make” 命令可以生效. 再次运行 BiscuitOS 已经是最新的内存大小.

3. BiscuitOS 存储能力

3.1 修改系统盘 Rootfs 大小

BiscuitOS 系统盘默认大小为 300MiB，当需要增加 BiscuitOS 系统盘大小的时候，可以使用如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      (300) Rootfs Size(MiB)

# 保存并退出，配置生效
make

开发者可以在 “Rootfs Size” 选项里写入新系统盘的大小，单位为 MiB. 设置完毕并退出保存，最后执行 “make” 命令可以生效. 再次运行 BiscuitOS 并使用 “df” 命令查看，此时系统盘已经是最新.

3.3 新增一个 EXT4 数据盘

当需要向 BiscuitOS 系统挂载一个 EXT4 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: EXT4 Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/ext4” 目录挂载新的 EXT4 磁盘.

3.4 新增一个 EXT2 数据盘

当需要向 BiscuitOS 系统挂载一个 EXT2 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: EXT2 Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/ext2” 目录挂载新的 EXT2 磁盘.

3.5 新增一个 EXT3 数据盘

当需要向 BiscuitOS 系统挂载一个 EXT3 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: EXT3 Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/ext3” 目录挂载新的 EXT3 磁盘.

3.6 新增一个 MINIXFS 数据盘

当需要向 BiscuitOS 系统挂载一个 MINIXFS 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: MINIX Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/minix” 目录挂载新的 MINIXFS 磁盘.

3.7 新增一个 VFAT 数据盘

当需要向 BiscuitOS 系统挂载一个 VFAT 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: VFAT Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/vfat” 目录挂载新的 VFAT 磁盘.

3.8 新增一个 MSDOS 数据盘

当需要向 BiscuitOS 系统挂载一个 MSDOS 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: MSDOS Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/msdos” 目录挂载新的 MSDOS 磁盘.

3.9 新增一个 FAT 数据盘

当需要向 BiscuitOS 系统挂载一个 FAT 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: FAT Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/fat” 目录挂载新的 FAT 磁盘.

3.10 新增一个 CRAMFS 数据盘

当需要向 BiscuitOS 系统挂载一个 CRAMFS 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: CRAMFS Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/cramfs” 目录挂载新的 CRAMFS 磁盘.

3.11 新增一个 BFS 数据盘

当需要向 BiscuitOS 系统挂载一个 BFS 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: BFS Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/bfs” 目录挂载新的 BFS 磁盘.

3.12 新增一个 JFFS2 数据盘

当需要向 BiscuitOS 系统挂载一个 JFFS2 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: JFFS2 Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/jffs2” 目录挂载新的 JFFS2 磁盘.

3.13 新增一个 UBIFS 数据盘

当需要向 BiscuitOS 系统挂载一个 UBIFS 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: UBIFS Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/ubifs” 目录挂载新的 UBIFS 磁盘.

3.14 新增一个 SQUASHFS 数据盘

当需要向 BiscuitOS 系统挂载一个 SQUASHFS 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: SQUASHFS Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/squashfs” 目录挂载新的 SQUASHFS 磁盘.

3.15 新增一个 BTRFS 数据盘

当需要向 BiscuitOS 系统挂载一个 BTRFS 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: BTRFS Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/btrfs” 目录挂载新的 BTRFS 磁盘.

3.16 新增一个 REISERFS 数据盘

当需要向 BiscuitOS 系统挂载一个 REISERFS 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: REISERFS Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/reiserfs” 目录挂载新的 REISERFS 磁盘.

3.17 新增一个 JFS 数据盘

当需要向 BiscuitOS 系统挂载一个 JFS 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: JFS Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/jfs” 目录挂载新的 JFS 磁盘.

3.18 新增一个 XFS 数据盘

当需要向 BiscuitOS 系统挂载一个 XFS 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: XFS Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/xfs” 目录挂载新的 XFS 磁盘.

3.19 新增一个 GFS2 数据盘

当需要向 BiscuitOS 系统挂载一个 GFS2 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: GFS2 Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/gfs2” 目录挂载新的 GFS2 磁盘.

3.20 新增一个 F2FS 数据盘

当需要向 BiscuitOS 系统挂载一个 F2FS 数据盘，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: F2FS Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在 “/mnt/f2fs” 目录挂载新的 F2FS 磁盘.

3.21 新增一个 9P 网络文件系统

当需要向 BiscuitOS 系统挂载一个 9P 网络文件系统，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: 9P Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在将主机侧的目录挂载到 “/mnt/HOST-BiscuitOS” 目录下，方便 HOST 侧和 BiscuitOS 内部数据交互.

4. BiscuitOS 网络能力

4.1 BiscuitOS 网络基础环境配置

BiscuitOS 目前配备一个 VIRTIO 网卡，因此可以在 BiscuitOS 内部通过该网卡与外接连通，第一次使用 BiscuitOS 网络能力之前，需要配置基础的网络环境，在 HOST 侧执行如下命令:

# 打开转发功能
sudo echo 1 > /proc/sys/net/ipv4/ip_forward
# 选择 HOST 侧转发的网卡
ip link
# 执行完 ip link 命令之后会输出可用的网卡，例如可用的网卡为 eth0
# 设置转化规则
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
# 如果需要在 BiscuitOS 内访问外网，则需要关闭外网
sudo ufw disable

当 BiscuitOS 启动之后，使用 “ip addr” 命令可以看到一个可用的网卡 eth0, 其默认的 IP 是 “172.88.1.6”, 网桥的 IP 是 “172.88.1.1”, 此时可以直接使用 PING 命令访问外网. 如果需要修改默认 IP，则在 BiscuitOS 内修改 “/etc/init.d/rcS” 文件，将文件里的 “172.88.1.6” 替换成 “172.88.1.X” 段的 IP, 重启即生效.

4.2 BiscuitOS ssh 能力

BiscuitOS 目前配备一个 VIRTIO 网卡，当配置号 4.1 节的网络基础环境之后，开发者可以在 HOST 侧使用 SSH 命令登录 BiscuitOS，参考如下命令:

# BiscuitOS 网卡默认 IP 是 172.88.1.6
ssh root@172.88.1.6

BiscuitOS 默认账号是 root，没有登录密码，直接可以通过 ssh 登录到虚拟机内部

4.3 BiscuitOS telnet 能力

BiscuitOS 目前配备一个 VIRTIO 网卡，当配置号 4.1 节的网络基础环境之后，开发者可以在 HOST 侧使用 TELNET 命令登录 BiscuitOS，参考如下命令:

# BiscuitOS 网卡默认 IP 是 172.88.1.6
telnet 172.88.1.6

BiscuitOS 默认账号是 root，没有登录密码，直接可以通过 telnet 登录到虚拟机内部

4.4 BiscuitOS 9P 网络共享文件系统

当需要向 BiscuitOS 系统挂载一个 9P 网络文件系统，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Virtio-BLK: 9P Filesystem Disk

# 保存并退出，配置生效
make

当再次启动 BiscuitOS 之后, 系统自动在将主机侧的目录挂载到 “/mnt/HOST-BiscuitOS” 目录下，方便 HOST 侧和 BiscuitOS 内部数据交互.

5. BiscuitOS 外设能力

5.1 部署带 IO-BAR/MMIO-BAR 的 PCIE/PCI 设备

当需要在 BiscuitOS 系统里配备一个带 IO-BAR/MMIO-BAR 的 PCIE/PCI 设备，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] BiscuitOS PCI/PCIe IO-BAR and MMIO-BAR

# 保存并退出，配置生效
make

当 BiscuitOS 启动完毕之后，通过 “lspci” 命令可以看到 “VENDOR:DEVICE” 为 “1016:1413” 的 PCI/PCIE 设备就是配备的设备.

5.2 部署支持 INTX 中断的 PCIE/PCI 设备

当需要在 BiscuitOS 系统里配备一个支持 INTX 中断的 PCIE/PCI 设备，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] BiscuitOS PCI/PCIe with INTX Interrupt

# 保存并退出，配置生效
make

当 BiscuitOS 启动完毕之后，通过 “lspci” 命令可以看到 “VENDOR:DEVICE” 为 “1016:1991” 的 PCI/PCIE 设备就是配备的设备.

5.3 部署支持 MSI 中断的 PCIE/PCI 设备

当需要在 BiscuitOS 系统里配备一个支持 MSI 中断的 PCIE/PCI 设备，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] BiscuitOS PCI/PCIe with MSI Interrupt

# 保存并退出，配置生效
make

当 BiscuitOS 启动完毕之后，通过 “lspci” 命令可以看到 “VENDOR:DEVICE” 为 “1001:1991” 的 PCI/PCIE 设备就是配备的设备.

5.4 部署支持 MSIX 中断的 PCIE/PCI 设备

当需要在 BiscuitOS 系统里配备一个支持 MSIX 中断的 PCIE/PCI 设备，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] BiscuitOS PCI/PCIe with MSIX Interrupt

# 保存并退出，配置生效
make

当 BiscuitOS 启动完毕之后，通过 “lspci” 命令可以看到 “VENDOR:DEVICE” 为 “1002:1991” 的 PCI/PCIE 设备就是配备的设备.

5.5 部署支持 INTX 中断 DMA 的 PCIE/PCI 设备

当需要在 BiscuitOS 系统里配备一个支持 INTX 中断 DMA 的 PCIE/PCI 设备，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] BiscuitOS PCI/PCIe DMA with INTX Interrupt

# 保存并退出，配置生效
make

当 BiscuitOS 启动完毕之后，通过 “lspci” 命令可以看到 “VENDOR:DEVICE” 为 “0309:1991” 的 PCI/PCIE 设备就是配备的设备.

5.6 部署支持 MSI 中断 DMA 的 PCIE/PCI 设备

当需要在 BiscuitOS 系统里配备一个支持 MSI 中断 DMA 的 PCIE/PCI 设备，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] BiscuitOS PCI/PCIe DMA with MSI Interrupt

# 保存并退出，配置生效
make

当 BiscuitOS 启动完毕之后，通过 “lspci” 命令可以看到 “VENDOR:DEVICE” 为 “1024:1991” 的 PCI/PCIE 设备就是配备的设备.

5.7 部署支持 MSIX 中断 DMA 的 PCIE/PCI 设备

当需要在 BiscuitOS 系统里配备一个支持 MSIX 中断 DMA 的 PCIE/PCI 设备，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] BiscuitOS PCI/PCIe DMA with MSIX Interrupt

# 保存并退出，配置生效
make

当 BiscuitOS 启动完毕之后，通过 “lspci” 命令可以看到 “VENDOR:DEVICE” 为 “1026:1991” 的 PCI/PCIE 设备就是配备的设备.

5.8 部署支持 DMA-BUF 的 PCIE/PCI 设备

当需要在 BiscuitOS 系统里配备一个支持 DMA-BUF 的 PCIE/PCI 设备，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] BiscuitOS PCI/PCIe DMA-BUF

# 保存并退出，配置生效
make

当 BiscuitOS 启动完毕之后，通过 “lspci” 命令可以看到 “VENDOR:DEVICE” 为 “1019:1991”、”1018:1991”、”101a:1991” 的 PCI/PCIE 设备就是配备的设备.

5.9 部署支持 P2PDMA 中断的 PCIE 设备

当需要在 BiscuitOS 系统里配备一个支持 P2PDMA 中断的 PCIE 设备，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] BiscuitOS PCIe P2PDMA

# 保存并退出，配置生效
make

当 BiscuitOS 启动完毕之后，通过 “lspci” 命令可以看到 “VENDOR:DEVICE” 为 “0827:1991”、”0826:1991” 的 PCIE 设备就是配备的设备.

5.10 部署支持 SGDMA 中断的 PCIE/PCI 设备

当需要在 BiscuitOS 系统里配备一个支持 SGDMA 中断的 PCIE/PCI 设备，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] BiscuitOS PCI SGDMA

# 保存并退出，配置生效
make

当 BiscuitOS 启动完毕之后，通过 “lspci” 命令可以看到 “VENDOR:DEVICE” 为 “0828:1991” 的 PCIE/PCI 设备就是配备的设备.

6. BiscuitOS CPU 能力

6.1 设置 CPU 数量

当需要在 BiscuitOS 系统里配置 CPU 的数量，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] (2)   CPU Number

# 保存并退出，配置生效
make

当 BiscuitOS 启动之后，可以使用 “cat /proc/cpuinfo” 命令查看当前系统 CPU 的数量.

6.2 选择 INTEL Q35 架构

当需要在 BiscuitOS 系统里配置 Intel Q35 架构，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [ ] Intel i440FX 
      [\*] Intel Q35

# 保存并退出，配置生效
make

当 BiscuitOS 启动之后，可以使用 “dmesg | grep Q35” 命令确认当前系统采用 Intel Q35 架构.

6.3 选择 INTEL i440FX 架构

当需要在 BiscuitOS 系统里配置 Intel i440FX 架构，可以参考如下命令:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] DIY BiscuitOS/Broiler Hardware  --->
      [\*] Intel i440FX
      [  ] Intel Q35

# 保存并退出，配置生效
make

当 BiscuitOS 启动之后，可以使用 “dmesg | grep i440FX” 命令确认当前系统采用 Intel i440FX 架构.

9. BiscuitOS 调试能力

9.1 内存流动工具

BiscuitOS 默认支持内存流动工具，并在所有架构中支持内存流动工具. 请更新 BiscuitOS 到最新的版本，然后参考如下命令进行部署:

# 切换到 BiscuitOS 项目目录
cd BiscuitOS
# 选择开发环境，如果已经选择过可以跳过，这里与 linux 6.0 X86 为例
make linux-6.0-x86_64_defconfig
# 通过 Kbuild 选择需要部署的内核开发工具集
make menuconfig

  [\*] Package  --->
      [\*] BiscuitOS Demo Code --->
           [\*] Kernel Demo Code on BiscuitOS --->

# 保存并退出，配置生效
make
make install_tools

# 更新内核
cd /BiscuitOS/output/linux-6.0-x86_64/package/BiscuitOS-kernel-default
make

编译通过之后，内核就支持内存流动工具，接下来介绍在用户空间使用内存工具，参考如下:

用户态使用 “BiscuitOS_memory_fluid_enable()” 函数开启内存流动工具，使用 “BiscuitOS_memory_fluid_disable()” 关闭内存流动工具. 例如上图中 32 行和 34 行添加内存流动工具，用于检测 33 行的缺页行为.

内核态使用 “BiscuitOS_memory_fluid_enable()” 函数开启内存流动工具，使用 “BiscuitOS_memory_fluid_disable()” 关闭内存流动工具, 并使用 “bs_debug()” 函数进行内存流动跟踪. 例如上图 17 行和 20 行添加内存流动工具，用于跟踪 19 行的 “page_alloc()” 函数分配物理页过程，并在 18 行进行内存流动跟踪.