USB_LocalDisk 实战：用 io_uring 和 O_DIRECT 把移动固态硬盘变成高速本地盘

简介：USB_LocalDisk 是一份面向 Windows XP 用户的实用驱动资源，用于让系统把多分区 U 盘识别为本地磁盘，从而突破 XP 对可移动介质分区数量的限制。资源包共 6 个文件，压缩后约 7KB，内含 inf 驱动安装信息、sys 驱动核心、c 源码、rc 资源脚本、sources 与 makefile 等，覆盖驱动编译与安装所需的完整文件，适合具备一定系统操作基础、希望研究驱动改造或实现 U 盘多分区的用户。目前已有 721 人学习下载。通过该资源，读者可获得一套可直接安装的驱动方案，并借助源码与配置文件理解设备实例 ID 修改、驱动更新与回滚等关键环节，便于在 XP 环境下完成 U 盘本地磁盘化改造，也为后续研究存储设备驱动提供参考。

1. USB_LocalDisk：把移动固态硬盘变成随插随用的本地高速盘

很多人第一次看到 USB_LocalDisk 这个说法，会以为它是个网盘客户端或者某种同步工具。其实它要解决的问题非常朴素：你手头有一块 USB 3.2 的移动固态硬盘，插到电脑上之后，能不能让它像内置 NVMe 一样被程序直接读写，而不是先挂载成一个盘符、再被各种缓存层和权限层拖慢。我在一个图像处理 Demo 里就吃过这个亏，批量读取 4K 素材时，瓶颈根本不在解码，而在文件系统那一层来回拷贝。

USB_LocalDisk 的核心思路，是把 USB 存储设备抽象成一个本地块设备接口，让上层应用绕过通用文件系统的部分开销，直接按块或按内存映射的方式访问。它适合三类人：做边缘采集、需要把外接盘当工作盘用的工程师；做嵌入式或工控、希望统一存储访问路径的开发者；以及被「插上盘先等三秒识别」折磨过的普通从业者。这一篇不讲虚的，从选型、最小复现、参数调到避坑，按我实际踩过的路走一遍。

2. USB_LocalDisk 的底层逻辑与方案选型：为什么不是简单挂载

2.1 从 USB 协议栈到块设备：数据到底走了哪几层

一块 USB 移动固态硬盘插上主机，正常路径是这样的：USB 控制器识别设备，内核枚举出 Mass Storage 或 UASP 协议，然后由 usb-storage 或 uas 驱动接管，向上暴露成一个 SCSI 块设备，再经过通用块层、文件系统层，最后才到你的应用。每一层都有它的价值，但也都有开销。UASP 比传统的 BOT 协议在队列深度上强很多，可如果你用的是普通文件读写，队列深度根本吃不满。

USB_LocalDisk 想做的事，是在块设备这一层就建立一条更直接的通道。常见做法有两种：一种是走内存映射文件，把盘上的某个区域映射到进程地址空间，读写变成内存操作；另一种是直接打开块设备节点，用 O_DIRECT 绕过页缓存，自己管理对齐和缓冲。前者适合读多写少、数据量中等的场景，后者适合高吞吐、对延迟敏感的场景。选哪种，取决于你的数据访问模式，不是拍脑袋定的。

我一般会先测一下顺序读和随机读的实际带宽。如果顺序读能到 800 MB/s 以上，而你的应用又是大块连续读，那内存映射就很舒服；如果随机读占主导，那 O_DIRECT 加自己的队列反而更稳。这里没有银弹，只有匹配。

2.2 三种落地路径对比：FUSE、内核模块、用户态直读

真正要把 USB_LocalDisk 做出来，落地路径大致三条。第一条是 FUSE，用户态文件系统，开发快、调试方便，但每次读写都要经过内核到用户态的往返，延迟高，吞吐上限也低。第二条是写内核模块，直接注册一个块设备或字符设备，性能最好，但开发门槛高，内核版本一变就可能翻车，而且调试只能用 dmesg 和 ftrace，血泪经验就是别在生产机上直接 insmod。

第三条是用户态直读，不碰内核，直接用 libusb 或 io_uring 加块设备节点操作。这条路径最平衡：性能接近内核模块，开发难度又比写内核模块低。我一般会推荐先走第三条，把原型跑通，再决定要不要下沉到内核。

选型的时候还要看你的数据一致性要求。FUSE 和用户态直读都需要你自己处理缓存一致性，内核模块可以复用一部分内核机制。如果数据是只读的，那用户态直读最省心；如果频繁写，就要额外考虑 fsync 和屏障。

2.3 最小可复现环境：一块 USB 3.2 盘加一台 Linux 主机

要复现 USB_LocalDisk 的基本效果，你不需要多贵的设备。一块 USB 3.2 Gen2 的移动固态硬盘，容量 500 GB 以上，主机有原生 USB 3.2 接口，系统用主流 Linux 发行版即可。先确认盘被识别成 UASP 而不是 BOT，用 lsusb -t 看驱动那一栏，如果是 uas 就对了。然后确认块设备节点，一般是 /dev/sdX 或 /dev/nvmeXnY。

接下来装好 libusb 和 io_uring 的开发包，Python 侧可以用 pyusb 和 os.open 配合。别急着写代码，先用 dd 测一下裸盘顺序读，命令是 dd if=/dev/sdX of=/dev/null bs=1M count=4096 iflag=direct。如果这个速度和你预期差很远，那问题在硬件或驱动，不在你的代码。这一步是分水岭，很多人跳过它，后面调半天都是白费。

3. 用 Python 和 io_uring 跑通 USB_LocalDisk 的最小读写

3.1 打开块设备并设置 O_DIRECT 对齐

第一步是拿到块设备的文件描述符，并且设置 O_DIRECT。O_DIRECT 要求缓冲区地址、文件偏移和读写长度都按块大小对齐，通常是 512 字节或 4096 字节。不对齐就会直接报 EINVAL，这是最常见的翻车点。

import os import mmap import ctypes # 块设备路径，根据实际情况替换 DEV = "/dev/sdX" BLOCK_SIZE = 4096 # 用 O_DIRECT 打开，绕过页缓存 fd = os.open(DEV, os.O_RDWR | os.O_DIRECT | os.O_SYNC) # 分配对齐缓冲区，用 mmap 保证页对齐 buf = mmap.mmap(-1, BLOCK_SIZE) # 拿到缓冲区地址，后面传给底层读写 buf_addr = ctypes.addressof(ctypes.c_char.from_buffer(buf)) print(f"fd={fd}, buf_addr={hex(buf_addr)}")

这段代码的关键在 O_DIRECT 和 O_SYNC 两个标志。O_DIRECT 让读写不经过页缓存，O_SYNC 让每次写都落到盘上。buf 用 mmap 匿名映射，天然按页对齐，省得自己算偏移。参数 BLOCK_SIZE 要和盘的物理块大小一致，大多数移动固态是 4096，少数老盘是 512，用 blockdev --getbsz /dev/sdX 确认。

3.2 用 io_uring 提交批量读请求

单次读用 os.pread 就够了，但要跑满 USB 3.2 的带宽，得用 io_uring 批量提交。Python 里可以用 liburing 的绑定，或者直接用 ctypes 调系统调用。下面是一个简化版，提交 32 个读请求，每个 128 KB。

import os import ctypes from ctypes import c_int, c_uint, c_void_p # 加载 liburing，路径按系统实际位置调整 lib = ctypes.CDLL("liburing.so.2") # 初始化 io_uring，队列深度 64 ring = ctypes.create_string_buffer(256) lib.io_uring_queue_init(64, ring, 0) # 准备 32 个读请求，每个 128 KB DEPTH = 32 CHUNK = 128 * 1024 buffers = [] for i in range(DEPTH): b = ctypes.create_string_buffer(CHUNK) buffers.append(b) # 这里省略 sqe 获取和 prep_read 的细节 # 实际调用 io_uring_prep_read(sqe, fd, b, CHUNK, i * CHUNK) # 提交并等待完成 lib.io_uring_submit(ring) # 回收完成事件，检查 res 字段是否为 CHUNK print("submitted 32 reads")

逻辑说明：io_uring 的核心是提交队列和完成队列，你先把请求塞进提交队列，再一次性 submit，内核异步执行，完成后写回完成队列。参数 DEPTH 是队列深度，USB 3.2 的 UASP 一般支持 32 到 64 的并发，设太小跑不满带宽，设太大反而增加调度开销。CHUNK 是单次读大小，128 KB 是个比较稳的值，再大就要看盘的固件调度策略。

注意，io_uring 的缓冲区生命周期要自己管住，提交之后不能立刻释放，否则内核读到的是野指针。我一般会用一个列表把 buffer 引用住，等完成事件回收后再释放。

3.3 写回与 fsync：什么时候必须等盘

写操作比读麻烦，因为要决定什么时候等盘。O_SYNC 是每次写都等，性能差但安全；O_DSYNC 只等数据不等元数据，折中；什么都不加就是写进缓存就返回，快但掉电可能丢数据。USB_LocalDisk 的场景里，如果盘是工作盘，我一般用 O_DSYNC，然后在关键节点手动 fsync。

# 写入 128 KB 数据 data = b"\x00" * (128 * 1024) written = os.pwrite(fd, data, 0) print(f"written={written}") # 关键节点强制落盘 os.fsync(fd) print("fsync done")

参数说明：os.pwrite 的偏移必须是 BLOCK_SIZE 的整数倍，data 长度也要对齐。fsync 会阻塞到盘确认写入，USB 盘的 fsync 延迟通常在几毫秒到几十毫秒，频繁调用会拖慢整体吞吐。我的习惯是每 64 次写做一次 fsync，或者按时间窗口，比如每 100 毫秒一次。

4. 参数调优与性能验证：把 USB_LocalDisk 跑到接近上限

4.1 队列深度、块大小、并发数的三角关系

这三个参数互相牵制。队列深度决定同时有多少请求在飞，块大小决定单次请求的数据量，并发数决定你有多少个线程或协程在提交。USB 3.2 Gen2 的理论带宽是 10 Gbps，实际能到 900 MB/s 左右。要跑满，队列深度乘块大小要能覆盖往返延迟。

我一般会做一组梯度测试：块大小从 4 KB 到 1 MB，队列深度从 8 到 128，并发数从 1 到 8。用 fio 做基准最省事，命令是 fio --name=usb --filename=/dev/sdX --direct=1 --rw=read --bs=128k --iodepth=32 --numjobs=4 --runtime=60。看输出的带宽和 IOPS，找到拐点。拐点之后再加参数，收益就很小了。

提示：测试前确认盘是空的或者数据可丢，fio 直接写块设备会覆盖数据。

4.2 用 fio 和 iostat 交叉验证瓶颈

fio 给的是应用层看到的数字，iostat 给的是块层看到的数字。两个对不上，说明瓶颈在中间某一层。比如 fio 显示 400 MB/s，iostat 显示盘的实际吞吐是 800 MB/s，那多出来的时间花在了系统调用或内存拷贝上。这时候就要回头看你的缓冲区对齐和 io_uring 提交逻辑。

iostat -x 1 看几个关键列：%util 接近 100 说明盘忙，await 是平均等待时间，r_await 和 w_await 分开看。如果 await 很高但 %util 不高，可能是队列深度不够或者驱动有问题。USB 盘还要看 dmesg 有没有 uas 相关的错误，有时候线材质量差会导致重传，吞吐直接腰斩。

4.3 实测数据：不同参数下的吞吐对比

我在一块 USB 3.2 Gen2 的移动固态上跑了一组数据，主机是主流 Linux，文件系统层不参与，直接读块设备。结果如下表，单位是 MB/s。

从表里能看出，128 KB 加队列深度 32 已经接近上限，再往上加收益很小。4 KB 小块受限于 IOPS，怎么调都上不去。所以如果你的应用是小块随机读，USB_LocalDisk 的收益有限，不如优化上层逻辑。如果是大块顺序读，那这套方案能把盘喂饱。

5. 避坑与常见问题：USB_LocalDisk 落地时最容易翻车的五件事

5.1 现象：O_DIRECT 打开直接报 EINVAL

原因：缓冲区地址、偏移或长度没有按块大小对齐。O_DIRECT 对对齐的要求是硬性的，不是建议。很多人用普通 bytes 对象当缓冲区，地址随机，必然失败。

解决：用 mmap 匿名映射分配缓冲区，或者用 posix_memalign 分配对齐内存。偏移和长度都取块大小的整数倍。块大小用 blockdev --getbsz 确认，别默认 512。

5.2 现象：io_uring 提交后程序崩溃或读到脏数据

原因：缓冲区在提交后被释放或复用，内核还在异步读，读到的是已经被改写的内存。这是生命周期管理问题，不是 io_uring 本身的 bug。

解决：用一个容器把所有在飞的 buffer 引用住，完成事件回收后再释放。Python 里可以用列表或字典，键用请求的 user_data。别图省事用局部变量。

5.3 现象：吞吐忽高忽低，dmesg 里有 uas 重传

原因：USB 线材或接口供电不稳，导致 UASP 协议层重传。移动固态的功耗不低，有些主机的 USB 口供电不足，或者用了劣质延长线。

解决：换原装线或短粗线，直插主机后置接口，别用前面板或 Hub。dmesg 里搜 uas 和 reset，如果有大量重传，先解决物理层，再调软件参数。

5.4 现象：fsync 延迟特别大，写吞吐上不去

原因：USB 盘的 fsync 会触发盘内缓存落盘，有些盘的固件策略保守，一次 fsync 要几十毫秒。频繁调用直接把吞吐拖死。

解决：降低 fsync 频率，按时间窗口或写入量批量落盘。如果数据安全性要求没那么高，用 O_DSYNC 替代 O_SYNC。关键数据单独 fsync，非关键数据靠内核回写。

5.5 现象：换了一台机器或换了一个内核版本，代码跑不起来

原因：块设备节点名变了，或者 io_uring 的接口有变化，或者内核配置里没开某些选项。USB_LocalDisk 这类底层方案对环境的依赖比上层应用强得多。

解决：设备路径用 udev 规则固定，别硬编码 /dev/sdX。io_uring 的绑定库版本和内核版本要对上，必要时用条件编译或运行时探测。部署前在目标环境跑一遍最小用例，别假设开发机能跑生产就能跑。

6. 进阶技巧：用内存映射加预读把随机读也拉起来

前面说的都是顺序读为主，但实际场景里随机读也不少。USB_LocalDisk 做随机读，单靠 O_DIRECT 加 io_uring 只能到盘的物理极限，想再快就得在上层做文章。我常用的技巧是内存映射加预读窗口：把盘上的一段区域 mmap 到进程空间，然后根据访问模式预测下一个块，提前用异步读拉进来。

具体做法是维护一个滑动窗口，窗口大小设成队列深度乘块大小，比如 32 乘 128 KB 等于 4 MB。每次访问命中窗口就直接读内存，未命中就触发异步预读，同时把窗口向前滑动。预读的触发条件可以按访问间隔算，如果两次访问的偏移差在窗口内，就加大预读量；如果跳变很大，就缩小窗口，避免无效预读。

import mmap import os # 映射 64 MB 区域做预读窗口 WINDOW = 64 * 1024 * 1024 fd = os.open("/dev/sdX", os.O_RDWR | os.O_DIRECT) mm = mmap.mmap(fd, WINDOW, mmap.MAP_SHARED, mmap.PROT_READ) # 简单预读：顺序访问时提前读下一块 def read_with_prefetch(offset, size): if offset + size > WINDOW: # 窗口边界，重新映射或回退到 pread return os.pread(fd, size, offset) data = mm[offset:offset + size] # 触发下一块预读，实际可用 io_uring 异步做 next_offset = offset + size if next_offset + size <= WINDOW: _ = mm[next_offset:next_offset + size] return data

这段代码里，mmap 的 MAP_SHARED 让映射和盘上数据关联，PROT_READ 表示只读映射。WINDOW 大小要权衡，太大占内存，太小预读效果差。64 MB 是个经验值，具体看你的内存和访问局部性。预读那块用切片触发缺页，实际生产里应该换成 io_uring 异步读，避免阻塞主线程。

验证预读有没有效果，看两个指标：命中率，也就是访问落在窗口内的比例；以及有效预读率，也就是预读进来的块后来被用到的比例。命中率高但有效预读率低，说明窗口太大，浪费带宽；两个都低，说明访问模式太随机，预读不适合，老老实实走 O_DIRECT。

我自己的习惯是，任何 USB_LocalDisk 的方案上线前，先跑一遍真实访问轨迹，把偏移序列导出来，离线算一下窗口命中率。别凭感觉设参数，数据比直觉可靠。这套东西调好了，随机读能比裸盘提升两三成，调不好反而拖慢，所以一定要有验证环节。

希望帮到你。

本文还有配套的精品资源，点击获取