存储技术实践笔记3_深入NVMe磁盘操作（从用户态ioctl到内核态bio的完整路径解析）

1. 从零开始：理解NVMe磁盘操作的两条技术路径

你好，我是老张，一个在存储领域摸爬滚打了十多年的老码农。今天咱们不聊那些虚头巴脑的概念，就聊点实在的——当你手里有一块NVMe固态硬盘，你想绕过文件系统，直接跟它“对话”，该怎么操作？这就像你想跟仓库管理员直接沟通，而不是通过层层上报的文书流程。

我见过很多刚接触这块的朋友，一上来就被内核、驱动、bio这些词给唬住了。其实没那么复杂，核心就两条路：一条是在用户态，用ioctl系统调用配合struct nvme_user_io结构体，直接给NVMe设备发命令；另一条是钻进内核态，写一个内核模块，用struct block_device和struct bio来发起I/O请求。这两条路，一条在外面敲门，一条在里面开门，各有各的用处和门道。

为什么需要了解这两条路呢？想象一下，你正在开发一个高性能的数据库，或者一个定制化的存储引擎。文件系统的通用缓存和调度策略可能反而成了瓶颈，你需要更精细地控制数据何时、以何种方式落盘。又或者，你在做存储系统的调试和性能剖析，需要绕过中间层，直接观测磁盘的真实行为。这时候，掌握从用户态到内核态的完整I/O路径，就成了你的基本功。

我刚开始搞这块的时候也踩了不少坑，比如用户态写的地址不对，内核模块一加载就把系统搞崩了。但把这些坑填平后，你会发现对磁盘的理解会上一个全新的台阶。接下来，我就带你一步步走通这两条路，把每个关键步骤掰开揉碎了讲清楚。

2. 环境准备与磁盘“格式化”：为实验扫清障碍

动手之前，得先把“战场”准备好。咱们需要一个干净的NVMe磁盘来做实验，避免残留数据干扰结果。这个过程，我习惯称之为“格式化”，但更准确地说，是初始化和清零。

2.1 创建并识别你的NVMe实验盘

首先，你得有一块NVMe磁盘。如果在虚拟机上（比如VirtualBox或VMware），添加一块NVMe控制器和虚拟磁盘非常方便。物理机上就更简单了，插上就行。添加完成后，开机第一件事就是确认系统识别到了它。

打开终端，用lsblk或者直接看/dev目录：

ls /dev/nvme*

你应该能看到类似/dev/nvme0n1这样的设备文件。nvme0代表第一个NVMe控制器，n1代表该控制器下的第一个命名空间（Namespace），这通常就是我们能直接操作的块设备。

再用lsblk看看它的详细信息：

lsblk

输出里找到你的NVMe磁盘，记下它的名字和大小。这一步千万不能错，后续所有操作都针对这个设备文件，要是搞错了目标盘，数据可就没了。

2.2 彻底清空磁盘：使用dd命令

为了确保实验从一个绝对干净的状态开始，我们需要用dd命令把磁盘全部填零。这相当于把一张写满字的纸全部涂黑，让你能在上面重新写字。

sudo dd if=/dev/zero of=/dev/nvme0n1 bs=1M status=progress

我来解释一下这个命令：

• if=/dev/zero：输入文件，/dev/zero是一个特殊的设备文件，它会源源不断地提供0x00字节。
• of=/dev/nvme0n1：输出文件，这里就是你的NVMe磁盘设备。再次警告，务必确认这个路径正确！
• bs=1M：块大小（Block Size），这里设为1MB。意味着dd每次读取和写入的数据块是1MB。这个值会影响拷贝速度，一般设为1M或4M在速度和内存占用上比较平衡。
• status=progress：显示拷贝进度和速度，让你心里有底。

这个命令会运行一段时间，取决于你的磁盘大小。完成后，整个磁盘的每一个字节都变成了0。你可以用hexdump快速看一眼磁盘开头的内容来验证：

sudo hexdump -C /dev/nvme0n1 | head -20

如果看到满屏的00，那就对了。有的朋友可能会想用mkfs（制作文件系统）来“格式化”，但mkfs只是在磁盘开头写入特定的文件系统元数据（如superblock），并不会清零所有数据。对于我们的底层操作实验，用dd填零是更彻底、干扰更少的做法。

2.3 认识NVMe磁盘的“身份证”：nvme-cli工具

NVMe协议比传统的SATA/AHCI复杂得多，提供了丰富的管理命令。在Linux上，nvme-cli工具包就是与这些功能交互的瑞士军刀。安装它：

sudo apt install nvme-cli # Ubuntu/Debian

用它查看磁盘的详细信息，这对理解后续操作至关重要：

sudo nvme list

这个命令会列出所有NVMe设备。重点关注输出中的Format这一列。它显示了磁盘的逻辑块格式，比如512 B + 0 B。这里的512 B就是逻辑块大小（Logical Block Size, LBA Size）。这是NVMe磁盘与主机系统交互的基本数据单元。你通过ioctl或bio读写时，地址（slba）和数量（nblocks）都是以这个逻辑块为单位的。也就是说，你告诉磁盘“从第0块开始写1块”，磁盘实际处理的就是512字节的数据。

另一个有用的命令是查看智能日志：

sudo nvme smart-log /dev/nvme0n1

这里面有温度、读写量、寿命百分比等信息，在做性能测试和健康监控时非常有用。环境准备好，磁盘也擦干净了，接下来我们就开始第一种玩法：在用户态直接操控。

3. 用户态直通车：使用ioctl与NVMe设备对话

用户态下操作NVMe磁盘，核心是ioctl系统调用。ioctl是“input/output control”的缩写，顾名思义，就是用来对设备进行输入输出控制的。它像一个万能遥控器，你可以通过发送不同的命令码（command code）来让设备执行特定操作。对于NVMe设备，Linux内核已经为我们定义好了一套命令和数据结构，其中最常用的就是struct nvme_user_io。

3.1 解剖struct nvme_user_io：I/O请求的蓝图

这个结构体定义在<linux/nvme_ioctl.h>里，它是你构建一个NVMe读写命令的“申请表”。我来带你看看里面几个关键的字段，理解了它们，你就掌握了直接指挥NVMe磁盘的密码。

struct nvme_user_io { __u8 opcode; // 操作码：读(0x02)还是写(0x01)？ __u8 flags; __u16 control; __u16 nblocks; // 要操作多少个逻辑块？ __u16 rsvd; __u64 metadata; __u64 addr; // 数据缓冲区在用户空间的地址 __u64 slba; // 起始逻辑块地址(Start Logical Block Address) __u32 dsmgmt; __u32 reftag; __u16 apptag; __u16 appmask; };

核心字段解读：

• opcode：这是命令的灵魂。0x01代表NVME_CMD_WRITE（写），0x02代表NVME_CMD_READ（读）。这个值直接决定了你是往磁盘存数据还是从磁盘取数据。
• slba(Start Logical Block Address)：这是数据的“门牌号”。它告诉NVMe磁盘：“从第几个逻辑块开始操作”。这里有个关键点：slba的增量单位是1，但每个逻辑块对应着物理上的512字节（或你在nvme list里看到的大小）。如果你设置slba=0，操作的就是磁盘最开始的512字节；slba=1，操作的就是紧接着的第二个512字节，以此类推。
• nblocks：要连续操作多少个逻辑块。nblocks=0表示操作1个块，nblocks=1表示操作2个块，实际块数 = nblocks + 1。这是NVMe协议的历史遗留设计，需要特别注意。
• addr：这是一个用户空间的内存地址，指向你准备好的数据缓冲区。对于写操作，内核会从这个地址拷贝数据到磁盘；对于读操作，磁盘数据会被读到这个地址指向的内存。

3.2 手把手编写一个用户态NVMe读写程序

理论说再多不如一行代码。下面这个完整的C程序，演示了如何打开NVMe设备，填充nvme_user_io结构体，并通过ioctl完成一次写和读。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <linux/nvme_ioctl.h> // 关键头文件，包含结构体和IOCTL号 #include <sys/ioctl.h> #define NVME_DEVICE "/dev/nvme0n1" #define BLOCK_SIZE 512 // 逻辑块大小，需与`nvme list`显示的一致 int main() { int fd; char write_buffer[BLOCK_SIZE] = "Hello, NVMe World! This is a test string."; char read_buffer[BLOCK_SIZE] = {0}; struct nvme_user_io io; // 1. 打开NVMe设备文件 fd = open(NVME_DEVICE, O_RDWR); if (fd < 0) { perror("Failed to open NVMe device"); return -1; } // 2. 准备写操作 memset(&io, 0, sizeof(io)); io.opcode = 0x01; // NVMe写命令 io.addr = (__u64)write_buffer; // 数据从哪来 io.slba = 0; // 写到磁盘的哪个位置（第0个逻辑块） io.nblocks = 0; // 写入 (0+1)=1 个逻辑块，即512字节 printf("Attempting to write to LBA 0...\n"); if (ioctl(fd, NVME_IOCTL_SUBMIT_IO, &io) == -1) { perror("Write IOCTL failed"); close(fd); return -1; } printf("Write successful.\n"); // 3. 准备读操作（验证刚才写的数据） memset(&io, 0, sizeof(io)); // 清空结构体，避免字段干扰 io.opcode = 0x02; // NVMe读命令 io.addr = (__u64)read_buffer; // 数据读到哪去 io.slba = 0; // 从磁盘的哪个位置读（还是第0块） io.nblocks = 0; // 读取 (0+1)=1 个逻辑块 printf("Attempting to read from LBA 0...\n"); if (ioctl(fd, NVME_IOCTL_SUBMIT_IO, &io) == -1) { perror("Read IOCTL failed"); close(fd); return -1; } printf("Read successful.\n"); printf("Data read from disk: [%s]\n", read_buffer); close(fd); return 0; }

编译和运行：

gcc -o nvme_ioctl_demo nvme_ioctl_demo.c sudo ./nvme_ioctl_demo

注意，因为直接操作块设备需要root权限，所以要用sudo运行。

3.3 深入分析：slba与数据布局的奥秘

程序跑通了，但真正的理解来自实验和观察。我们来玩点花的，看看slba是怎么影响数据布局的。

实验一：连续写入不同位置修改上面的代码，在一个循环里，分别向slba=0和slba=1写入不同的字符串，比如“Block0”和“Block1”。然后，不用你的程序读，直接用系统命令cat或hexdump去看整个磁盘头部的内容：

sudo dd if=/dev/nvme0n1 bs=512 count=2 | hexdump -C

你会看到类似这样的输出：

00000000 42 6c 6f 63 6b 30 00 00 ... (Block0的数据) |Block0...| 00000200 42 6c 6f 63 6b 31 00 00 ... (Block1的数据) |Block1...|

注意地址0x00000200，这正好是十进制的512。这直观地证明了**slba每增加1，操作的起始地址就偏移一个逻辑块大小（这里是512字节）**。

实验二：理解nblocks的“+1”规则这是一个经典的坑。如果我们想写入2个逻辑块（1024字节），nblocks应该设多少？根据公式实际块数 = nblocks + 1，要写2块，nblocks应该设为1。如果你的数据缓冲区只有512字节，却设置了nblocks=1，程序可能会因为访问越界而崩溃（比如“stack smashing detected”错误）。务必保证你的数据缓冲区大小 >= (nblocks + 1) * 逻辑块大小。

用户态的方式直截了当，适合快速测试、原型验证和做一些简单的底层工具。但它有个限制：每次I/O都需要从用户态切换到内核态（系统调用开销），并且数据需要从用户缓冲区拷贝到内核缓冲区（内存拷贝开销）。对于追求极致性能的场景，我们得把战场转移到内核内部。

4. 深入内核腹地：使用block_device与bio发起I/O

当你需要在内核中实现一个文件系统、一个设备驱动，或者一个需要极低延迟的存储服务时，用户态的ioctl路径就显得有些“绕远路”了。这时，你需要在内核模块里直接操作。内核为我们抽象出了两个核心数据结构：struct block_device和struct bio。

你可以把struct block_device想象成内核里代表一个块设备（比如我们的/dev/nvme0n1）的“身份证”或“句柄”。而struct bio（Block I/O）则是描述一个块I/O请求的“任务单”，上面写着：从哪个设备的哪个扇区开始，读写多少数据，数据放在哪几页内存里。

4.1 内核模块编程基础框架

编写内核模块和写普通C程序有些不同，它没有main函数，而是通过module_init和module_exit宏指定加载和卸载时执行的函数。下面是一个最简框架：

#include <linux/module.h> #include <linux/kernel.h> static int __init my_module_init(void) { printk(KERN_INFO "My NVMe module loaded.\n"); // 你的初始化代码在这里 return 0; // 返回0表示成功 } static void __exit my_module_exit(void) { printk(KERN_INFO "My NVMe module unloaded.\n"); // 你的清理代码在这里 } module_init(my_module_init); module_exit(my_module_exit); MODULE_LICENSE("GPL"); // 必须声明许可证 MODULE_DESCRIPTION("A simple NVMe kernel module");

用make编译生成.ko文件后，用sudo insmod my_module.ko加载，用sudo rmmod my_module卸载。查看内核日志用dmesg | tail。

4.2 获取block_device：与磁盘建立连接

在内核中操作一个块设备，第一步是获取它的struct block_device指针。这通过blkdev_get_by_path函数实现：

#include <linux/blkdev.h> // 包含block_device相关定义 struct block_device *bdev; const char *disk_path = "/dev/nvme0n1"; // FMODE_READ | FMODE_WRITE 表示以读写模式打开 bdev = blkdev_get_by_path(disk_path, FMODE_READ | FMODE_WRITE, NULL); if (IS_ERR(bdev)) { printk(KERN_ERR "Failed to get block device: %ld\n", PTR_ERR(bdev)); return PTR_ERR(bdev); }

这个函数类似于用户态的open，它根据设备路径找到内核中对应的设备对象，并返回一个指针。后续所有的I/O请求都需要关联这个bdev。

4.3 构造与提交bio：发起读写请求

拿到bdev后，就可以构造bio请求了。这个过程比用户态的ioctl稍复杂，因为涉及到内核的内存管理（页分配）。

核心步骤拆解：

1. 分配bio结构体：bio_alloc是专门用来分配bio的函数。你需要指定内存分配标志（通常是GFP_KERNEL）和这个bio可能包含的“向量”数量。对于简单的单页请求，设为1即可。

   struct bio *bio = bio_alloc(GFP_KERNEL, 1); if (!bio) { printk(KERN_ERR "Failed to allocate bio.\n"); return -ENOMEM; }

2. 设置bio属性：

   • bi_opf：操作标志。REQ_OP_READ表示读，REQ_OP_WRITE表示写。
   • bi_iter.bi_sector：起始扇区号。注意，这里单位是扇区（Sector），通常是512字节，而不是NVMe的逻辑块地址（LBA）。在大多数系统中，1扇区=512字节，所以如果你的NVMe逻辑块大小是512字节，那么slba和sector在数值上是相等的。但为了严谨，最好用bdev_logical_block_size(bdev)获取逻辑块大小进行计算。
   • 关联块设备：通过bio_set_dev(bio, bdev)或直接设置bio->bi_bdev = bdev。

   bio->bi_opf = REQ_OP_WRITE; // 这是一个写请求 bio->bi_iter.bi_sector = sector_offset; // 起始扇区 bio_set_dev(bio, bdev); // 关联目标设备

3. 为数据分配内存页：内核I/O通常使用“页”作为内存单位（一页通常是4096字节）。我们需要分配一个页来存放要写入的数据。

   struct page *page = alloc_page(GFP_KERNEL); if (!page) { printk(KERN_ERR "Failed to allocate page.\n"); bio_put(bio); // 记得释放bio return -ENOMEM; } // 将用户数据拷贝到内核页 char *kaddr = page_address(page); memcpy(kaddr, your_data_buffer, data_length);

4. 将内存页添加到bio：bio_add_page函数将我们分配的内存页“挂载”到bio请求上，告诉内核数据在哪里。

   if (bio_add_page(bio, page, data_length, 0) == 0) { printk(KERN_ERR "Failed to add page to bio.\n"); __free_page(page); bio_put(bio); return -EIO; }

   参数分别是：bio结构体、内存页、数据长度、页内偏移（通常为0）。

5. 提交并等待请求完成：submit_bio_wait是同步提交函数，它会将bio请求发送到块设备层，并等待这个请求完全执行完毕（数据写入磁盘或从磁盘读出）后才返回。这对于保证数据落盘的顺序和可靠性很重要。

   submit_bio_wait(bio);

6. 对于读请求：步骤类似，但bi_opf设为REQ_OP_READ。提交请求后，数据会被磁盘控制器直接DMA到我们之前关联的内存页中。完成后，我们再从page_address(page)把数据读出来。

   // 提交读请求 submit_bio_wait(bio); // 从内核页拷贝数据到你的缓冲区 memcpy(your_read_buffer, page_address(page), data_length);

7. 资源清理：无论成功失败，都必须释放申请的资源，这是内核编程的好习惯，防止内存泄漏。

   __free_page(page); // 释放页 bio_put(bio); // 释放bio结构体

4.4 一个完整的内核模块读写示例

把上面的步骤组合起来，下面是一个可以在内核模块初始化函数中直接调用的、向NVMe磁盘特定扇区写入字符串并读回的示例函数：

static int nvme_kernel_rw_test(struct block_device *bdev) { int ret = 0; sector_t start_sector = 8; // 从第8个扇区开始操作（避开可能存在的MBR等区域） char write_data[] = "Kernel says hello to NVMe!"; char read_data[512] = {0}; struct bio *bio = NULL; struct page *page = NULL; /* --- 写操作 --- */ bio = bio_alloc(GFP_KERNEL, 1); if (!bio) { ret = -ENOMEM; goto out; } bio->bi_opf = REQ_OP_WRITE; bio->bi_iter.bi_sector = start_sector; bio_set_dev(bio, bdev); page = alloc_page(GFP_KERNEL); if (!page) { ret = -ENOMEM; goto free_bio; } memcpy(page_address(page), write_data, sizeof(write_data)); if (bio_add_page(bio, page, PAGE_SIZE, 0) == 0) { ret = -EIO; goto free_page; } submit_bio_wait(bio); // 同步写 printk(KERN_INFO "Write to sector %llu done.\n", (unsigned long long)start_sector); // 清理写操作资源，准备读 bio_put(bio); __free_page(page); /* --- 读操作 --- */ bio = bio_alloc(GFP_KERNEL, 1); if (!bio) { ret = -ENOMEM; goto out; } bio->bi_opf = REQ_OP_READ; bio->bi_iter.bi_sector = start_sector; bio_set_dev(bio, bdev); page = alloc_page(GFP_KERNEL); if (!page) { ret = -ENOMEM; goto free_bio; } // 读请求，页是空的，等待bio填充 if (bio_add_page(bio, page, PAGE_SIZE, 0) == 0) { ret = -EIO; goto free_page; } submit_bio_wait(bio); // 同步读 memcpy(read_data, page_address(page), sizeof(read_data)); printk(KERN_INFO "Read from sector %llu: %s\n", (unsigned long long)start_sector, read_data); free_page: __free_page(page); free_bio: bio_put(bio); out: return ret; }

在模块初始化函数中，先获取block_device，然后调用这个测试函数即可。加载模块后，用dmesg就能看到打印的读写成功信息。你也可以用dd或hexdump命令去验证磁盘对应扇区的数据是否被正确修改。

5. 双路径对比与选型：何时走大门，何时走后门？

走通了用户态和内核态两条路，你可能会问：我该用哪个？这没有标准答案，完全取决于你的应用场景。我把它们的核心区别和适用情况列了个表，你可以一目了然：

我个人的经验之谈：

• 如果你是初学者，或者只是想写个工具快速读写一下NVMe盘的某个区域，验证某个想法，那么无脑选用户态的ioctl方式。它快、安全、出错了顶多程序core dump，不会把系统搞挂。我很多临时的调试脚本都是用这个方式写的。
• 如果你正在开发一个产品级的、对性能有苛刻要求的存储服务，比如数据库的WAL（Write-Ahead Logging）模块，或者一个用户态文件系统的内核辅助模块，那么你必须深入内核，使用bio接口。只有这样才能榨干硬件的最后一滴性能，实现亚微秒级的延迟。但这条路意味着更高的开发成本、更严格的测试和更痛苦的调试过程。我建议你先用用户态实现核心逻辑，验证无误后，再将性能瓶颈部分移植到内核模块中。

6. 从块操作到文件系统：下一步的思考

现在，我们已经掌握了直接对NVMe磁盘进行原始读写的能力。无论是从用户态敲门，还是从内核态开门，我们都能精准地控制数据存放在磁盘的哪个“格子”里。但这仅仅是开始。磁盘管理真正的挑战在于：如何高效、可靠、易用地组织这些海量的“格子”？

这就是文件系统要解决的问题。你可以把我们刚才的读写操作，想象成在仓库的指定货架上存取一个指定编号的箱子。而文件系统，则是给这个仓库建立一套完整的目录索引、货架分配表、货物分类规则和存取流程。

基于我们现在已经实现的能力，你可以尝试思考和实践以下方向，这会让你的存储技术理解再深一层：

1. 实现一个最简单的“扁平”文件系统：比如，设计一个固定在磁盘开头的“超级块”，里面记录文件总数。然后划出一片区域作为“inode表”，每个inode记录一个文件名、大小、以及它数据所在的起始LBA和块数。剩下的区域就是数据区。你的内核模块可以实现mount、read、write等操作，根据文件名查inode，再通过bio去对应的LBA读写数据。这就是一个最原始的文件系统雏形。

2. 研究现有文件系统（如Ext4）的磁盘布局：用我们写的工具，去直接读取一块格式化为Ext4的磁盘的前几个扇区。对照Ext4的文档，尝试解析出超级块（Superblock）、块组描述符表（Group Descriptor Table）等内容。你会亲眼看到文件系统的元数据是如何实实在在排列在磁盘上的，这种感觉非常奇妙。

3. 探索NVMe的高级特性：NVMe协议不止有简单的读和写。它支持多队列（SQ/CQ）、原子写、端到端数据保护、命名空间管理等等。通过ioctl发送不同的命令（Opcode），或者在内核中构造更复杂的struct request，你可以尝试启用这些特性，比如用多队列来提升并发I/O性能。

这条路走下去，你会发现存储技术的天地非常广阔。从最底层的磁盘扇区操作，到上层的分布式存储架构，每一层都有其精妙之处。我自己的经验是，越是深入底层，对上层的设计理解就越透彻，解决问题时也越有底气。希望这篇笔记能帮你打通这关键的第一步，后面的路，就需要你带着好奇心和动手能力去探索了。如果在实践中遇到问题，多查内核源码（include/linux/blkdev.h,block/目录）、多看看nvme-cli的源码实现，你会发现很多答案就在那里。