stackbd 是一个虚拟的块设备，它作为另一个块设备的前端，如 USB 闪存盘或循环设备。它将I/O请求传递给底层设备，同时它打印请求信息用于调试。它还有可能修改请求。
堆叠块设备（stackbd）是基于 Linux 设备映射器的代码，它是 Linux 内核中的一个块设备，RedHat 支持，用于创建逻辑卷，或者说，修改 I/O 请求的地址值和目标设备。
stackbd，暂时不修改请求。它的作用是作为一个嗅探器，对每一个请求，都会打印出它的读/写状态，块地址，页数，以及总的字节大小。
除了调试目的外，这个简单的设备是学习Linux内核中块设备编程的好方法。
1. 下载源代码并构建
首先，最好在虚拟机上工作，因为内核出错会导致操作系统崩溃，虚拟机的重启速度要快得多。
1.1 下载源代码
从GitHub下载源代码（或以Git或SVN检出）代码：
git clone https://github.com/OrenKishon/stackbd.git
1.2 修改错误
实验环境如下：
操作系统：Ubuntu 14.04
内核版本：4.4.0-148-generic
下载后，由于内核版本问题，直接编译会报错。根据错误提示直接定位报错位置：
vim ~/stackbd/module/stackbd.c +65
修改为如下内容：
trace_block_bio_remap(bdev_get_queue(stackbd.bdev_raw), bio,
bio->bi_bdev->bd_dev, bio->bi_iter.bi_sector);
vim ~/stackbd/module/stackbd.c +106
printk("stackbd: make request %-5s block %-12llu #pages %-4hu total-size "
"%-10u ", bio_data_dir(bio) == WRITE ? "write" : "read",
(long long )bio->bi_iter.bi_sector, bio->bi_vcnt, bio->bi_iter.bi_size);
vim ~/stackbd/module/stackbd.c +139
struct block_device *bdev_raw = lookup_bdev(dev_path, 0);
vim ~/stackbd/module/stackbd.c +173
printk("stackbd: Device real capacity: %llu ", (long long)stackbd.capacity);
vim ~/stackbd/module/stackbd.c +264
blk_queue_make_request(stackbd.queue, (void *)stackbd_make_request);
如果是其它内核版本，报错可能不一样，需自行修改。
1.3 编译
在 "module" 目录中构建内核模块：
cd ~/stackbd/module
make
make -C /usr/src/linux-headers-4.4.0-148-generic SUBDIRS=/home/abin/stackbd/module modules
make[1]: Entering directory `/usr/src/linux-headers-4.4.0-148-generic'
CC [M] /home/abin/stackbd/module/stackbd.o
Building modules, stage 2.
MODPOST 1 modules
CC /home/abin/stackbd/module/stackbd.mod.o
LD [M] /home/abin/stackbd/module/stackbd.ko
make[1]: Leaving directory `/usr/src/linux-headers-4.4.0-148-generic'
在 "util" 目录中构建用户端工具：
cd ~/stackbd/util
make
cc -c -o stackbd_util.o stackbd_util.c
gcc -o stackbd_util stackbd_util.c
2. 创建用于测试的回路设备
我们需要一种设备来充当基础的“真实”设备。最简单的方法是基于文件系统中的文件创建循环设备。
创建一个100 MB的文件 disk_file，它将用作设备存储：
cd ~/stackbd
dd if=/dev/urandom of=disk_file bs=1024 count=100000
在此文件上设置循环设备 / dev / loop0：
sudo losetup /dev/loop0 disk_file
确认已创建大小为200,000（512字节块）的设备：
sudo blockdev --getsize /dev/loop0
200000
注意，循环设备在重启后不会持久化，所以一旦创建了文件disk_file，重启后只需要重复执行losetup命令。
3. 跟踪内核调试打印
stackbd 模块使用 printk 命令打印调试信息，所以我们需要通过跟踪 syslog 文件来跟踪它们。新开一个 shell 窗口，输入如下命令：
tail -f /var/log/syslog
这篇文章中的以下所有命令都应该在这个文件中产生调试信息。
4. 初始化堆叠设备
将 stackbd.ko 模块加载进内核，该操作只会创建新设备 / dev / stackbd0，而不会将其与另一个设备关联：
cd ~/stackbd/module
sudo insmod ./stackbd.ko
内核 syslog 输出如下：
Jan 10 21:52:29 ubuntu kernel: [ 2873.847052] stackbd: loading out-of-tree module taints kernel.
Jan 10 21:52:29 ubuntu kernel: [ 2873.847118] stackbd: module verification failed: signature and/or required key missing - tainting kernel
Jan 10 21:52:29 ubuntu kernel: [ 2873.849754] stackbd: init done
使用用户端 util 使 stackbd 打开循环设备，它使用 ioctl命令来控制内核模块：
cd ~/stackbd/util
sudo stackbd_util /dev/loop0
do it... </dev/loop0>
OK
确认新设备 / dev / stackbd0 存在，并且大小与基础设备相同：
ls -l /dev/stackbd0
brw-rw---- 1 root disk 251, 0 Jan 10 21:54 /dev/stackbd0
sudo blockdev --getsize /dev/stackbd0
200000
执行上面命令后的 syslog 中的消息 应类似于：
Jan 10 21:54:25 ubuntu kernel: [ 2990.252739] *** DO IT!!!!!!! ***
Jan 10 21:54:25 ubuntu kernel: [ 2990.252739]
Jan 10 21:54:25 ubuntu kernel: [ 2990.252745] Opened /dev/loop0
Jan 10 21:54:25 ubuntu kernel: [ 2990.252761] stackbd: Device real capacity: 200000
Jan 10 21:54:25 ubuntu kernel: [ 2990.252763] stackbd: Max sectors: 255
Jan 10 21:54:25 ubuntu kernel: [ 2990.252870] stackbd: done initializing successfully
Jan 10 21:54:25 ubuntu kernel: [ 2990.254140] stackbd: make request read block 199808 #pages 1 total-size 4096
Jan 10 21:54:25 ubuntu kernel: [ 2990.254228] stackbd: make request read block 199984 #pages 1 total-size 4096
......
Jan 10 21:54:25 ubuntu kernel: [ 2990.258612] stackbd: make request read block 4096 #pages 1 total-size 4096
5. 安装设备并使用
首先，在主目录下创建一个目录mnt，用于挂载。该操作只需执行一次，因为重启后目录还会保留：
mkdir ~/mnt
在设备上创建一个文件系统，示例为 ext4：
sudo mkfs.ext4 /dev/stackbd0
mke2fs 1.42.9 (4-Feb-2014)
Filesystem label=
OS type: Linux
Block size=1024 (log=0)
Fragment size=1024 (log=0)
Stride=0 blocks, Stripe width=0 blocks
25064 inodes, 100000 blocks
5000 blocks (5.00%) reserved for the super user
First data block=1
Maximum filesystem blocks=67371008
13 block groups
8192 blocks per group, 8192 fragments per group
1928 inodes per group
Superblock backups stored on blocks:
8193, 24577, 40961, 57345, 73729
Allocating group tables: done
Writing inode tables: done
Creating journal (4096 blocks): done
Writing superblocks and filesystem accounting information: done
在目录 mnt上挂载文件系统：
sudo mount -t ext4 /dev/stackbd0 ~/mnt/
赋予非root用户在挂载点上的读写权限：
sudo chmod -R 777 ~/mnt/
创建文件并将其写入设备中，然后，读取文件。
echo test > ~/mnt/1.txt
cat ~/mnt/1.txt
在上述操作过程中，查看详细记录I/O请求的调试打印。举个例子：
Jan 10 22:04:33 ubuntu kernel: [ 3597.680126] stackbd: make request read block 518 #pages 1 total-size 1024
Jan 10 22:04:33 ubuntu kernel: [ 3597.680270] stackbd: make request write block 16902 #pages 1 total-size 1024
Jan 10 22:04:38 ubuntu kernel: [ 3602.816174] stackbd: make request write block 98344 #pages 1 total-size 1024
Jan 10 22:04:38 ubuntu kernel: [ 3602.816194] stackbd: make request write block 98346 #pages 1 total-size 1024
6. 取消挂载并卸载设备
为了重新测试设备（例如在修改代码后），可以将其卸载并重新安装。
卸载文件系统（取消挂载）：
sudo umount /dev/stackbd0
删除模块，这将删除设备 / dev / stackbd0：
sudo rmmod stackbd
Jan 10 22:08:00 ubuntu kernel: [ 3804.559709] stackbd: exit
7. 有趣的内核代码片段
在这个块设备里面打开底层的块设备，使用它的路径（在这里的例子中，路径是/dev/loop0）。用于打开块设备的函数有 lookup_dev()、bdget() 和 blkdev_get()：
struct block_device *bdev_raw = lookup_bdev(dev_path);
printk("Opened %s
", dev_path);
if (IS_ERR(bdev_raw))
{
printk("stackbd: error opening raw device <%lu>
", PTR_ERR(bdev_raw));
return NULL;
}
if (!bdget(bdev_raw->bd_dev))
{
printk("stackbd: error bdget()
");
return NULL;
}
if (blkdev_get(bdev_raw, STACKBD_BDEV_MODE, &stackbd))
{
printk("stackbd: error blkdev_get()
");
bdput(bdev_raw);
return NULL;
}
return bdev_raw;
实际上，只是将一个 I/O 请求从这个块设备重新映射到底层块设备。函数 trace_block_bio_remap() 只是简单地修改了请求的目标设备和地址，并将请求发送到另一个设备的队列中（使用 generic_make_request() 函数）：
static void stackbd_io_fn(struct bio *bio)
{
bio->bi_bdev = stackbd.bdev_raw;
trace_block_bio_remap(bdev_get_queue(stackbd.bdev_raw), bio,
bio->bi_bdev->bd_dev, bio->bi_sector);
/* No need to call bio_endio() */
generic_make_request(bio);
}
块设备队列函数。块设备异步处理请求（与字符设备不同）。它们定义了一个请求回调并将其注册到队列中。内核调用这个回调来处理 I/O，这个函数作为一个生产者线程，因为它只将 I/O 请求添加到一个内部列表 (struct bio list) 中，而不处理它。它向作为消费者的另一个线程发出信号，让它实际执行 I/O 操作。
static void stackbd_make_request(struct request_queue *q, struct bio *bio)
{
spin_lock_irq(&stackbd.lock);
if (!stackbd.bdev_raw)
{
printk("stackbd: Request before bdev_raw is ready, aborting
");
goto abort;
}
if (!stackbd.is_active)
{
printk("stackbd: Device not active yet, aborting
");
goto abort;
}
bio_list_add(&stackbd.bio_list, bio);
wake_up(&req_event);
spin_unlock_irq(&stackbd.lock);
return;
abort:
spin_unlock_irq(&stackbd.lock);
printk("<%p> Abort request
", bio);
bio_io_error(bio);
}
块设备 "消费者 "线程函数--等待 "生产者 "线程（也就是实际的队列线程）发出信号，表示有请求被添加到列表中，wait_event_interruptible() 是睡眠等待队列线程发出信号唤醒的函数。
static int stackbd_threadfn(void *data)
{
struct bio *bio;
while (!kthread_should_stop())
{
/* wake_up() is after adding bio to list. No need for condition */
wait_event_interruptible(req_event, kthread_should_stop() ||
!bio_list_empty(&stackbd.bio_list));
spin_lock_irq(&stackbd.lock);
if (bio_list_empty(&stackbd.bio_list))
{
spin_unlock_irq(&stackbd.lock);
continue;
}
bio = bio_list_pop(&stackbd.bio_list);
spin_unlock_irq(&stackbd.lock);
stackbd_io_fn(bio);
}
return 0;
}
