1
int main(int argc, char **argv)
2
{
3
    // 1. 初始化 SPDK 环境（内部调用 DPDK EAL 初始化）
4
    struct spdk_env_opts opts;
5
    spdk_env_opts_init(&opts);
6
    opts.name = "spdk_app";
7
    opts.core_mask = "0x7";       // 使用 core 0-2
8
    opts.mem_size = 2048;         // 2GB 大页内存
9
    spdk_env_init(&opts);
10

11
    // 2. 初始化 bdev 子系统
12
    spdk_bdev_initialize(bdev_init_done, NULL);
13

14
    // 3. 初始化 blobstore（如果需要）
15
    // spdk_bs_init(...);
16

17
    // 4. 启动 Target 服务（iSCSI / NVMe-oF）
18
    // spdk_nvmf_tgt_start(...);
19

20
    // 5. 进入事件循环（轮询模式）
21
    spdk_app_start(&opts, app_start_fn, NULL);
22

23
    // 6. 清理
24
    spdk_app_fini();
25
    return 0;
26
}

1
// SPDK 用户态 NVMe 驱动的 PCI BAR 映射（简化流程）
2
int nvme_pcie_ctrlr_map_bars(struct spdk_nvme_ctrlr *ctrlr)
3
{
4
    // 1. 通过 DPDK EAL 获取 PCI 设备信息
5
    struct rte_pci_device *dev = ctrlr->devhandle;
6

7
    // 2. 映射 BAR0（MMIO 寄存器空间）
8
    ctrlr->regs = spdk_pci_device_map_bar(dev, 0);
9
    // 映射后，ctrlr->regs 指向用户态的 MMIO 寄存器基地址
10
    // 对 ctrlr->regs 的读写就是直接操作硬件寄存器
11

12
    // 3. 读取控制器能力
13
    uint64_t cap = spdk_mmio_read_8(&ctrlr->regs->cap);
14
    ctrlr->mqes = (cap & 0xFFFF) + 1;  // 最大队列深度
15
    ctrlr->cqr = (cap >> 16) & 0x1;    // CQ 是否与 SQ 绑定
16

17
    return 0;
18
}

1
// 写 SQ Tail Doorbell — 通知 NVMe 控制器有新命令
2
static inline void
3
spdk_nvme_mmio_write_sq_tdbl(struct spdk_nvme_ctrlr *ctrlr,
4
                              uint16_t qid, uint16_t tail)
5
{
6
    // 直接写 MMIO 寄存器，无需系统调用
7
    spdk_mmio_write_4(&ctrlr->regs->doorbell[qid * 2], tail);
8
}
9

10
// 读 CQ 完成条目 — 检查 I/O 是否完成
11
static inline bool
12
spdk_nvme_cq_check_completion(struct spdk_nvme_cq *cq,
13
                               struct spdk_nvme_cpl *cpl)
14
{
15
    // 检查 phase 位是否翻转（轮询模式）
16
    if ((cq->cpl[cq->head].status.p & 0x1) != cq->phase)
17
        return false;  // 没有新完成
18

19
    *cpl = cq->cpl[cq->head];
20
    cq->head = (cq->head + 1) % cq->size;
21

22
    // 如果 head 到达了 CQ 阶段翻转点，翻转 phase
23
    if (cq->head == 0)
24
        cq->phase = !cq->phase;
25

26
    return true;
27
}

1
#include <spdk/env.h>
2
#include <spdk/nvme.h>
3

4
struct ctrlr_entry {
5
    struct spdk_nvme_ctrlr  *ctrlr;
6
    struct spdk_nvme_ns     *ns;
7
    struct spdk_nvme_qpair  *qpair;
8
};
9

10
// 探测回调：发现 NVMe 设备时调用
11
static bool probe_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,
12
                     struct spdk_nvme_ctrlr_opts *opts)
13
{
14
    printf("发现 NVMe 控制器: %s\n", trid->traddr);
15
    return true;  // 接受此设备
16
}
17

18
// 连接回调：控制器初始化完成时调用
19
static void attach_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,
20
                      struct spdk_nvme_ctrlr *ctrlr,
21
                      const struct spdk_nvme_ctrlr_opts *opts)
22
{
23
    struct ctrlr_entry *entry = malloc(sizeof(*entry));
24
    entry->ctrlr = ctrlr;
25

26
    // 获取第一个 Namespace
27
    entry->ns = spdk_nvme_ctrlr_get_ns(ctrlr, 1);
28
    printf("Namespace 大小: %lu MB\n",
29
           spdk_nvme_ns_get_size(entry->ns) / (1024 * 1024));
30

31
    // 分配 I/O qpair（SQ + CQ 对）
32
    entry->qpair = spdk_nvme_ctrlr_alloc_io_qpair(ctrlr, NULL, 0);
33

34
    *(struct ctrlr_entry **)cb_ctx = entry;
35
}
36

37
int main(int argc, char **argv)
38
{
39
    struct spdk_env_opts opts;
40
    struct ctrlr_entry *entry = NULL;
41

42
    // 初始化 SPDK 环境
43
    spdk_env_opts_init(&opts);
44
    opts.name = "nvme_hello";
45
    opts.core_mask = "0x1";
46
    opts.mem_size = 512;
47
    spdk_env_init(&opts);
48

49
    // 探测 NVMe 设备
50
    spdk_nvme_probe(NULL, &entry, probe_cb, attach_cb, NULL);
51

52
    if (!entry) {
53
        fprintf(stderr, "未找到 NVMe 设备\n");
54
        return 1;
55
    }
56

57
    // ... 执行 I/O 操作（见下文） ...
58

59
    // 清理
60
    spdk_nvme_ctrlr_free_io_qpair(entry->qpair);
61
    spdk_nvme_detach(entry->ctrlr);
62
    return 0;
63
}

1
// I/O 完成回调
2
static void read_complete(void *arg, const struct spdk_nvme_cpl *cpl)
3
{
4
    struct io_context *ctx = arg;
5

6
    if (spdk_nvme_cpl_is_error(cpl)) {
7
        fprintf(stderr, "I/O 错误: status 0x%x\n", cpl->status.sc);
8
    } else {
9
        printf("读取完成: LBA %lu, %u bytes\n", ctx->lba, ctx->size);
10
        // 处理读取到的数据...
11
    }
12

13
    ctx->completed = true;
14
}
15

16
// 异步读取示例
17
void nvme_async_read(struct ctrlr_entry *entry,
18
                     void *buf, uint32_t size, uint64_t lba)
19
{
20
    struct io_context ctx = {
21
        .lba = lba,
22
        .size = size,
23
        .completed = false,
24
    };
25

26
    // 提交异步读请求
27
    int rc = spdk_nvme_ns_cmd_read(entry->ns, entry->qpair,
28
                                    buf,          // 数据缓冲区
29
                                    lba,          // 起始 LBA
30
                                    size / 512,   // LBA 数量
31
                                    read_complete, // 完成回调
32
                                    &ctx,         // 回调参数
33
                                    0);           // IO flags
34
    if (rc != 0) {
35
        fprintf(stderr, "读请求提交失败: %d\n", rc);
36
        return;
37
    }
38

39
    // 轮询完成（SPDK 的轮询模式）
40
    while (!ctx.completed) {
41
        spdk_nvme_qpair_process_completions(entry->qpair, 0);
42
    }
43
}
44

45
// 异步写入示例
46
static void write_complete(void *arg, const struct spdk_nvme_cpl *cpl)
47
{
48
    struct io_context *ctx = arg;
49
    if (!spdk_nvme_cpl_is_error(cpl)) {
50
        printf("写入完成: LBA %lu\n", ctx->lba);
51
    }
52
    ctx->completed = true;
53
}
54

55
void nvme_async_write(struct ctrlr_entry *entry,
56
                      void *buf, uint32_t size, uint64_t lba)
57
{
58
    struct io_context ctx = { .lba = lba, .completed = false };
59

60
    int rc = spdk_nvme_ns_cmd_write(entry->ns, entry->qpair,
61
                                     buf, lba, size / 512,
62
                                     write_complete, &ctx, 0);
63
    if (rc != 0) {
64
        fprintf(stderr, "写请求提交失败: %d\n", rc);
65
        return;
66
    }
67

68
    while (!ctx.completed) {
69
        spdk_nvme_qpair_process_completions(entry->qpair, 0);
70
    }
71
}

1
// Virtio vring 结构（简化）
2
struct vring_desc {
3
    uint64_t addr;     // Guest 物理地址
4
    uint32_t len;      // 缓冲区长度
5
    uint16_t flags;    // VRING_DESC_F_NEXT 等
6
    uint16_t next;     // 下一个描述符索引
7
};
8

9
struct vring_avail {
10
    uint16_t flags;    // VRING_AVAIL_F_NO_INTERRUPT 等
11
    uint16_t idx;      // 下一个可用槽位
12
    uint16_t ring[];   // 描述符 ID 数组
13
};
14

15
struct vring_used_elem {
16
    uint32_t id;       // 描述符 ID
17
    uint32_t len;      // 写入长度
18
};
19

20
struct vring_used {
21
    uint16_t flags;
22
    uint16_t idx;
23
    struct vring_used_elem ring[];
24
};

1
# 创建 vhost-blk 设备
2
# 方式一：使用 SPDK 的 RPC 接口
3
rpc.py vhost_create_blk_controller --cpumask 0x2 vhost.blk0 Malloc0
4

5
# 方式二：使用 SPDK 的配置文件
6
cat > spdk_vhost.conf << 'EOF'
7
[VhostBlk0]
8
  Name vhost.blk0
9
  Dev Malloc0
10
  Cpumask 0x2
11
EOF
12

13
# QEMU 启动参数（连接 vhost-blk 设备）
14
qemu-system-x86_64 \
15
  -chardev socket,id=char0,path=/var/tmp/vhost.blk0 \
16
  -device vhost-user-blk-pci,chardev=char0 \
17
  -m 4G -smp 2 \
18
  ...

1
// 打开 bdev
2
int spdk_bdev_open(struct spdk_bdev *bdev, bool write,
3
                   spdk_bdev_remove_cb_t remove_cb, void *remove_ctx,
4
                   struct spdk_bdev_desc **desc);
5

6
// 获取 I/O channel（每个线程一个，无锁访问）
7
struct spdk_io_channel *spdk_bdev_get_io_channel(struct spdk_bdev_desc *desc);
8

9
// 异步读
10
int spdk_bdev_read(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
11
                   void *buf, uint64_t offset, uint64_t nbytes,
12
                   spdk_bdev_io_completion_cb cb, void *cb_arg);
13

14
// 异步写
15
int spdk_bdev_write(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
16
                    void *buf, uint64_t offset, uint64_t nbytes,
17
                    spdk_bdev_io_completion_cb cb, void *cb_arg);
18

19
// 异步 unmap（TRIM）
20
int spdk_bdev_unmap(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
21
                    uint64_t offset, uint64_t nbytes,
22
                    spdk_bdev_io_completion_cb cb, void *cb_arg);
23

24
// 异步 flush
25
int spdk_bdev_flush(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
26
                    uint64_t offset, uint64_t nbytes,
27
                    spdk_bdev_io_completion_cb cb, void *cb_arg);

1
# 创建 NVMe bdev
2
rpc.py bdev_nvme_attach_controller -b Nvme0 -t pcie -a 0000:01:00.0
3

4
# 在 NVMe bdev 上创建分区
5
rpc.py bdev_split_create Nvme0n1 2
6
# 生成 Nvme0n1p0, Nvme0n1p1
7

8
# 创建 malloc bdev（内存盘，用于测试）
9
rpc.py bdev_malloc_create -b Malloc0 1024 512
10
# 创建 1GB、块大小 512 字节的内存盘

1
// 典型的 bdev I/O 使用模式
2
struct my_app_ctx {
3
    struct spdk_bdev_desc *desc;
4
    struct spdk_io_channel *ch;
5
};
6

7
void do_io_read(struct my_app_ctx *ctx, uint64_t lba, uint32_t count)
8
{
9
    // 分配 I/O buffer（从 SPDK 大页内存池）
10
    void *buf = spdk_dma_zmalloc(count * 512, 4096, NULL);
11

12
    // 通过 I/O channel 提交异步读
13
    spdk_bdev_read(ctx->desc, ctx->ch, buf,
14
                   lba * 512, count * 512,
15
                   io_read_complete, buf);
16
}
17

18
static void io_read_complete(void *cb_arg, int bdev_status)
19
{
20
    void *buf = cb_arg;
21
    if (bdev_status == 0) {
22
        // 处理读取的数据...
23
    }
24
    spdk_dma_free(buf);
25
}

1
+------------------------------------------------------------------+
2
| Super Block (Page 0)  |  Metadata Pages  |  Data Clusters  ...   |
3
+------------------------------------------------------------------+
4
| 4KB                   |  4KB each        |  1MB each             |

1
// 创建 blob（thin provisioning）
2
static void blob_create_complete(void *cb_arg, struct spdk_blob *blob, int bserrno)
3
{
4
    struct blob_ctx *ctx = cb_arg;
5
    if (bserrno != 0) {
6
        fprintf(stderr, "创建 blob 失败: %d\n", bserrno);
7
        return;
8
    }
9

10
    ctx->blob = blob;
11
    printf("Blob 创建成功, ID: 0x%lx\n", spdk_blob_get_id(blob));
12

13
    // 设置 blob 大小（仅修改元数据，不分配物理空间）
14
    spdk_blob_resize(blob, 1024);  // 1024 clusters = 1GB
15
    spdk_blob_sync_md(blob, blob_sync_complete, ctx);
16
}
17

18
void create_blob(struct spdk_blob_store *bs, struct spdk_io_channel *ch)
19
{
20
    struct blob_ctx *ctx = calloc(1, sizeof(*ctx));
21
    ctx->bs = bs;
22
    ctx->channel = ch;
23

24
    // 创建 blob — thin provisioning，不分配物理空间
25
    spdk_bs_create_blob(bs, NULL, 0, blob_create_complete, ctx);
26
}

1
// Blob 完整生命周期示例
2
struct blob_ctx {
3
    struct spdk_blob_store  *bs;
4
    struct spdk_io_channel  *channel;
5
    struct spdk_blob        *blob;
6
    spdk_blob_id             id;
7
};
8

9
// 1. 打开 blob
10
static void blob_open_complete(void *cb_arg, struct spdk_blob *blob, int bserrno)
11
{
12
    struct blob_ctx *ctx = cb_arg;
13
    ctx->blob = blob;
14

15
    // 获取 blob 的大小
16
    uint64_t num_clusters = spdk_blob_get_num_clusters(blob);
17
    printf("Blob 大小: %lu clusters (%lu MB)\n",
18
           num_clusters, num_clusters * 1024 * 1024 / (1024 * 1024));
19
}
20

21
void open_blob(struct blob_ctx *ctx, spdk_blob_id id)
22
{
23
    ctx->id = id;
24
    spdk_bs_open_blob(ctx->bs, id, blob_open_complete, ctx);
25
}
26

27
// 2. 读写 blob
28
static void blob_write_complete(void *cb_arg, int bserrno)
29
{
30
    if (bserrno == 0) {
31
        printf("Blob 写入完成\n");
32
    }
33
}
34

35
void write_blob_data(struct blob_ctx *ctx, void *data, uint64_t offset, uint64_t length)
36
{
37
    // 写入数据到 blob（offset 和 length 以 Page 为单位）
38
    spdk_blob_io_write(ctx->blob, ctx->channel,
39
                       data, offset / 4096, length / 4096,
40
                       blob_write_complete, NULL);
41
}
42

43
static void blob_read_complete(void *cb_arg, int bserrno)
44
{
45
    void *data = cb_arg;
46
    if (bserrno == 0) {
47
        printf("Blob 读取完成\n");
48
        // 处理读取的数据...
49
    }
50
    spdk_dma_free(data);
51
}
52

53
void read_blob_data(struct blob_ctx *ctx, uint64_t offset, uint64_t length)
54
{
55
    void *buf = spdk_dma_zmalloc(length, 4096, NULL);
56
    spdk_blob_io_read(ctx->blob, ctx->channel,
57
                      buf, offset / 4096, length / 4096,
58
                      blob_read_complete, buf);
59
}
60

61
// 3. 关闭 blob
62
void close_blob(struct blob_ctx *ctx)
63
{
64
    spdk_blob_close(ctx->blob, blob_close_complete, ctx);
65
}
66

67
// 4. 删除 blob
68
void delete_blob(struct blob_ctx *ctx, spdk_blob_id id)
69
{
70
    spdk_bs_delete_blob(ctx->bs, id, blob_delete_complete, ctx);
71
}

1
// 创建快照
2
static void snapshot_complete(void *cb_arg, spdk_blob_id snapshot_id, int bserrno)
3
{
4
    if (bserrno == 0) {
5
        printf("快照创建成功, ID: 0x%lx\n", snapshot_id);
6
    }
7
}
8

9
void create_snapshot(struct blob_ctx *ctx)
10
{
11
    // 将当前 blob 设为只读快照，返回快照 ID
12
    spdk_bs_create_snapshot(ctx->bs, ctx->id, NULL, 0,
13
                            snapshot_complete, NULL);
14
}
15

16
// 基于快照创建克隆
17
static void clone_complete(void *cb_arg, spdk_blob_id clone_id, int bserrno)
18
{
19
    if (bserrno == 0) {
20
        printf("克隆创建成功, ID: 0x%lx\n", clone_id);
21
    }
22
}
23

24
void create_clone(struct blob_ctx *ctx, spdk_blob_id snapshot_id)
25
{
26
    // 基于快照创建可写克隆
27
    spdk_bs_create_clone(ctx->bs, snapshot_id, NULL, 0,
28
                         clone_complete, NULL);
29
}

1
# 配置 SPDK iSCSI Target
2
# 1. 创建 malloc bdev 作为后端存储
3
rpc.py bdev_malloc_create -b Malloc0 4096 512
4

5
# 2. 创建 iSCSI Target portal（监听地址）
6
rpc.py iscsi_create_portal_group 1 -a 10.0.0.1 -p 3260
7

8
# 3. 创建 iSCSI Target
9
rpc.py iscsi_create_initiator_group 2 -n ANY
10

11
# 4. 创建 LUN（映射 bdev 到 Target）
12
rpc.py iscsi_create_target_node disk0 Malloc0 1 2 -d 0
13

14
# 5. 在发起端（Initiator）连接
15
# Linux 内核 Initiator：
16
iscsiadm -m discovery -t st -p 10.0.0.1:3260
17
iscsiadm -m node -T disk0 -p 10.0.0.1:3260 --login

1
# 配置 SPDK NVMe-oF Target
2
# 1. 创建 NVMe bdev
3
rpc.py bdev_nvme_attach_controller -b Nvme0 -t pcie -a 0000:01:00.0
4

5
# 2. 创建 NVMe-oF subsystem
6
rpc.py nvmf_create_subsystem nqn.2026-01.io.spdk:cnode0 \
7
    -s SPDK0001 -d "SPDK NVMe-oF Target"
8

9
# 3. 将 NVMe bdev 添加到 subsystem
10
rpc.py nvmf_subsystem_add_ns nqn.2026-01.io.spdk:cnode0 Nvme0n1
11

12
# 4. 创建 NVMe-oF transport（RDMA）
13
rpc.py nvmf_create_transport -t rdma -u 8192
14

15
# 5. 创建 listener（监听 RDMA 端口）
16
rpc.py nvmf_subsystem_add_listener nqn.2026-01.io.spdk:cnode0 \
17
    -t rdma -a 10.0.0.1 -s 4420
18

19
# 6. 允许主机连接
20
rpc.py nvmf_subsystem_allow_any_host nqn.2026-01.io.spdk:cnode0 true
21

22
# 在发起端连接 NVMe-oF Target
23
nvme connect -t rdma -n nqn.2026-01.io.spdk:cnode0 -a 10.0.0.1 -s 4420
24

25
# 验证远程 NVMe 设备
26
nvme list

1
# 创建 NVMe-oF TCP transport
2
rpc.py nvmf_create_transport -t tcp -u 8192
3

4
# 添加 TCP listener
5
rpc.py nvmf_subsystem_add_listener nqn.2026-01.io.spdk:cnode0 \
6
    -t tcp -a 10.0.0.1 -s 4420
7

8
# 发起端通过 TCP 连接
9
nvme connect -t tcp -n nqn.2026-01.io.spdk:cnode0 -a 10.0.0.1 -s 4420

1
# 安装依赖
2
sudo apt install build-essential libaio-dev libiscsi-dev \
3
    libncurses5-dev librdmacm-dev libnuma-dev meson ninja-build
4

5
# 克隆 SPDK 源码
6
git clone https://github.com/spdk/spdk.git
7
cd spdk
8

9
# 安装 SPDK 依赖（自动检测并安装）
10
sudo scripts/pkgdep.sh --all
11

12
# 编译 SPDK（含 DPDK）
13
./configure
14
make -j$(nproc)
15

16
# 配置大页内存
17
echo 1024 | sudo tee /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
18

19
# 绑定 NVMe 设备到用户态驱动（从内核驱动解绑）
20
sudo scripts/setup.sh
21

22
# 验证 NVMe 设备已被 SPDK 接管
23
scripts/setup.sh status
24
# 输出类似：
25
# NVMe Device at 0000:01:00.0 -- using vfio-pci

1
# 运行 SPDK 自带的 NVMe identify 示例
2
build/examples/nvme_identify
3

4
# 输出类似：
5
# ========================================
6
# NVMe Controller at 0000:01:00.0
7
# ========================================
8
# PCI Vendor ID:            0x8086
9
# PCI Device ID:            0x0a54
10
# Controller Model:         INTEL SSDPE2KX040T8
11
# Serial Number:            PHAB12345678
12
# Firmware Revision:        VDV10103
13
# Maximum Queue Entries:    16384
14
# Namespace 1:
15
#   Size (in LBAs):         781422768
16
#   Capacity (in LBAs):     781422768
17
#   LBA Data Size:          512
18
#   Total Capacity:         375 GB

1
build/examples/nvme_hello_world
2

3
# 输出类似：
4
# Initializing NVMe Controller 0000:01:00.0
5
# Attached to NVMe Controller 0000:01:00.0
6
# Namespace 1: 375 GB, LBA 512 bytes
7
# Writing sector 0...
8
# Writing sector 1...
9
# ...
10
# Read complete for sector 0
11
# Read complete for sector 1
12
# ...
13
# Hello World completed successfully!

1
# 1. 启动 SPDK vhost 进程
2
build/bin/vhost -S /var/tmp -m 0x2 &
3

4
# 2. 创建 1GB 内存盘
5
rpc.py bdev_malloc_create -b Malloc0 1024 512
6

7
# 3. 创建 vhost-blk 控制器
8
rpc.py vhost_create_blk_controller --cpumask 0x2 vhost.blk0 Malloc0
9

10
# 4. 验证 vhost-blk 设备已创建
11
rpc.py vhost_get_controllers
12

13
# 5. 启动 QEMU 虚拟机，连接 vhost-blk 设备
14
qemu-system-x86_64 \
15
    -name vm0 \
16
    -m 4G -smp 2 \
17
    -chardev socket,id=char0,path=/var/tmp/vhost.blk0 \
18
    -device vhost-user-blk-pci,chardev=char0 \
19
    -drive file=/path/to/os.qcow2,if=virtio \
20
    -enable-kvm \
21
    -cpu host \
22
    -net nic -net user
23

24
# 6. 在虚拟机中验证磁盘
25
# 登录虚拟机后：
26
lsblk
27
# 应该能看到一个新的块设备（如 /dev/vdb）

1
# SPDK 用户态 NVMe 性能测试
2
# 4K 随机读，队列深度 128，1 个 core
3
build/bin/spdk_nvme_perf -q 128 -o 4096 -w randread -t 60 -c 0x1
4

5
# 输出类似：
6
# =========================================================
7
# Device Information
8
# =========================================================
9
# Name               QD   IOPS      MiB/s    Avg Latency  P99 Latency
10
# 0000:01:00.0      128   2350000   9180     54.3 us      78.2 us
11

12
# 内核 NVMe 性能测试（使用 fio）
13
# 首先将 NVMe 设备绑定回内核驱动
14
sudo scripts/setup.sh reset
15

16
# 使用 fio 测试
17
fio --filename=/dev/nvme0n1 \
18
    --ioengine=libaio \
19
    --direct=1 \
20
    --rw=randread \
21
    --bs=4k \
22
    --iodepth=128 \
23
    --numjobs=1 \
24
    --time_based \
25
    --runtime=60 \
26
    --group_reporting \
27
    --name=kernel_nvme
28

29
# 输出类似：
30
#   IOPS=820000, BW=3203MiB/s, avg lat=155.8us, p99 lat=210.5us