一步一步走进块驱动之第六章

最新推荐文章于 2024-01-07 21:04:59 发布
最新推荐文章于 2024-01-07 21:04:59 发布
阅读量1.7k 收藏
点赞数
分类专栏： Arm-driver 文章标签： disk tree struct insert module initialization

第六章

本教程修改自赵磊的网上的一系列教程.本人觉得该系列教程写的非常不错.以风趣幽默的语言将块驱动写的非常详细,对于入门教程,应该属于一份经典了. 本人在这对此系列教程最后附上对Linux 2.6.36版本的代码.并编译运行成功. 该教程所有版权仍归作者赵磊所有,本人只做附录代码的添加,并为对原文修改.有不懂的地方,可以联系我 97164811@qq.com 或者给我留言.   

+---------------------------------------------------+

|                 写一个块设备驱动                  

+---------------------------------------------------+

| 作者：赵磊                                        

| email: zhaoleidd@hotmail.com                      

+---------------------------------------------------+

| 文章版权归原作者所有。                            

| 大家可以自由转载这篇文章，但原版权信息必须保留。  

| 如需用于商业用途，请务必与原作者联系，若因未取得  

| 授权而收起的版权争议，由侵权者自行负责。          

+---------------------------------------------------+

经历了内容极为简单的前两章的休息，现在大家一定感到精神百倍了。

作为已经坚持到现在的读者，对接下去将要面临的内容大概应该能够猜得八九不离十了，

具体的内容猜不出来也无妨，但一定将是具有增加颅压功效的。

与物理块设备驱动程序的区别在于，我们的驱动程序使用内存来存储块设备中的数据。

到目前为止，我们一直都是使用这样一个静态数组来担负这一功能的：

unsigned char simp_blkdev_data[SIMP_BLKDEV_BYTES];

如果读者懂得一些模块的知识，或者现在赶紧去临时抱佛脚google一些模块知识，

应该知道模块其实是加载在非线性映射区域的。

详细来说，在加载模块时，根据模块的ELF信息(天哪，又要去google elf了)，确定这个模块所需的静态内存大小。

这些内存用来容纳模块的二进制代码，以及静态变量。然后申请容纳这些数据的一大堆页面。

当然，这些页面并不是连续的，而代码和变量却不可能神奇到即使被切成一块一块的也能正常工作。

因此需要在非线性映射区域中找到一块连续的地址(现在有要去google非线性映射区域了)，用来将刚才申请到的一块一块的内存页映射到这个地址段中。

最后模块被请到这段区域中，然后执行模块的初始化函数......

现在看我们这个模块中的simp_blkdev_data变量，如果不是现在刻意关注，这个变量看起来显得那么得普通。

正如其它的一些名字原先也是那么的普通，但由于一些突发的事件受到大家的热烈关注，

比如一段视频让我们熟悉了kappa和陆佳妮，比如呼吸税让我们认识了蒋有绪。

现在我们开始关注simp_blkdev_data变量了，导火索是刚才介绍的非线性映射区域。

模块之所以被加载到非线性映射区域，是因为很难在线性映射区域中得到加载模块所需的连续的内存。

但使用非线性映射区域也并非只赚不赔的生意，至少在i386结构中，非线性映射区域实在是太小了。

在物理内存大于896M的i386系统中，整个非线性映射区域不会超过128M。

相反如果物理内存小于896M(不知道该算是幸运还是不幸)，非线性映射区域反而会稍微大一些，这种情况我想我们可以不用讨论了，毕竟不能为了加载一个模块去拔内存。

因此我们的结论是：非线性映射区域是很紧张的资源，我们要节约使用。

而像我们现在这个模块中的simp_blkdev_data却是个如假包换的反面典型，居然上来就吃掉了16M！这还是因为我们没有把SIMP_BLKDEV_BYTES定义得更大。

现在我们开始列举simp_blkdev_data的种种罪行：

1：剩余的非线性映射区域较小时导致模块加载失败

2：模块加载后占用了大量的非线性映射区域，导致其它模块加载失败。

3：模块加载后占用了大量的非线性映射区域，影响系统的正常运行。

   这是因为不光模块，系统本身的很多功能也依赖非线性映射区域空间。

对于这样的害群之马，我们难道还有留下他的理由吗？

本章的内容虽然麻烦一些，但想到能够一了百了地清除这个体大膘肥的simp_blkdev_data，倒也相当值得。

也希望今后能够看到在对贪官的处理上，能够也拿出这样的魄力和勇气。

现在在清除simp_blkdev_data的问题上，已经不存在什么悬念了，接下来我们需要关注的是将simp_blkdev_data碎尸万段后，拿出一个更恰当方法来代替它。

首先，我们决定不用静态声明的数组，而改用动态申请的内存。

其次，使用类似vmalloc()的函数可以动态申请大段内存，但其实这段内存占用的还是非线性映射区域，就好像用一个比较隐蔽的贪官来代替下马的贪官，我们不会愚蠢在这种地步。

剩下的，就是在线性映射区域申请很多个页的内存，然后自己去管理。这个方法一了百了地解决了使用大段非线性映射区域的问题，而唯一的问题是由于需要自己管理申请到的页面，使程序复杂了不少。

但为了整个系统的利益，这难道不是我们该做的吗？

申请一个内存页是很容易的，这里我们将采用所有容易的方法中最容易的那个：

__get_free_page函数，原型是：

unsigned long __get_free_page(gfp_t gfp_mask);

这个函数用来申请一个页面的内存。gfp_mask包含一些对申请内存时的指定，比如，要在DMA区域中啦、必须清零等。

我们这里倒是使用最常见的__get_free_page(GFP_KERNEL)就可以了。

通过__get_free_page申请到了一大堆内存页，新的问题来了，在读写块设备时，我们得到是块设备的偏移，如何快速地通过偏移找到对应的内存页呢？

最简单的方法是建立一个数组，用来存放偏移到内存的映射，数组中的每项对应一个一个页：

数组定义如下：

void *simp_blkdev_data[(SIMP_BLKDEV_BYTES + PAGE_SIZE - 1) / PAGE_SIZE];

PAGE_SIZE是系统中每个页的大小，对i386来说，通常是4K，那堆加PAGE_SIZE减1的代码是考虑到SIMP_BLKDEV_BYTES不是PAGE_SIZE的整数倍时要让末尾的空间也能访问。

然后申请内存的代码大概是：

for (i=0; i < (SIMP_BLKDEV_BYTES + PAGE_SIZE - 1) / PAGE_SIZE; i++) {

        p = (void *)__get_free_page(GFP_KERNEL);

        simp_blkdev_data[i] = p;

}

通过块设备偏移得到内存中的数据地址的代码大概是：

mem_addr = simp_blkdev_data[dev_addr/PAGE_SIZE] + dev_addr % PAGE_SIZE;

这种方法实现起来还是比较简单的，但缺点也不是没有：存放各个页面地址的数组虽然其体积比原先那个直接存放数据的数组已经缩小了很多，

但本身毕竟还是在非线性映射区域中。如果块设备大小为16M，在i386上，需要4096个页面，数组大小16K，这不算太大。

但如果某个疯子打算建立一个2G的虚拟磁盘，数组大小将达到2M，这就不算小了。

或者我们可以不用数组，而用链表来存储偏移到内存页的映射关系，这样可以回避掉数组存在的问题，但在链表中查找指定元素却不是一般的费时，

毕竟我们不希望用户觉得这是个软盘。

接下来作者不打断继续卖关子了，我们最终选择使用的是传说中的基树。

关于linux中基树细节的文档不多，特别是中文文档更少，更糟的是我们这篇文档也不打算作详细的介绍(因为作者建议去RTFSC)。

但总的来说，相对于二叉平衡树的红黑树来说，基树是一个n叉(一般为64叉)非平衡树，n叉减少了搜索的深度，非平衡减少了复杂的平衡操作。

当然，这两个特点也不是仅仅带来优点，但在这里我们就视而不见了，毕竟我们已经选择了基树，因此护短也是自认而然的事情，正如公仆护着王细牛一样。

从功能上来说，基树好像是为我们量身定做的一样，好用至极。

(其实我们也可以考虑选择红黑树和哈希表来实现这个功能，感兴趣的读者可以了解一下)

接下来的代码中，我们将要用到基树种的如下函数：

  void INIT_RADIX_TREE((struct radix_tree_root *root, gfp_t mask);

  用来初始化一个基树的结构，root是基树结构指针，mask是基树内部申请内存时使用的标志。

  int radix_tree_insert(struct radix_tree_root *root, unsigned long index, void *item);

  用来往基树中插入一个指针，index是指针的索引，item是指针，将来可以通过index从基树中快速获得这个指针的值。

  void *radix_tree_delete(struct radix_tree_root *root, unsigned long index);

  用来根据索引从基树中删除一个指针，index是指针的索引。

  void *radix_tree_lookup(struct radix_tree_root *root, unsigned long index);

  用来根据索引从基树中查找对应的指针，index是指针的索引。

其实基树的功能不仅限于此，比如，还可以给指针设定标志，详情还是请去读linux/lib/radix-tree.c

现在开始改造我们的代码：

首先删除那个无耻的数组：

unsigned char simp_blkdev_data[SIMP_BLKDEV_BYTES];

然后引入它的替代者--一个基树结构：

static struct radix_tree_root simp_blkdev_data;

然后增加两个函数，用来申请和释放块设备的内存：

申请内存的函数如下：

int alloc_diskmem(void)
{
        int ret;
        int i;
        void *p;
        INIT_RADIX_TREE(&simp_blkdev_data, GFP_KERNEL);
        for (i = 0; i < (SIMP_BLKDEV_BYTES + PAGE_SIZE - 1) >> PAGE_SHIFT;
                i++) {
                p = (void *)__get_free_page(GFP_KERNEL);
                if (!p) {
                        ret = -ENOMEM;
                        goto err_alloc;
                }
                ret = radix_tree_insert(&simp_blkdev_data, i, p);
                if (IS_ERR_VALUE(ret))
                        goto err_radix_tree_insert;
        }
        return 0;
err_radix_tree_insert:
        free_page((unsigned long)p);
err_alloc:
        free_diskmem();
        return ret;
}

先初始化基树结构，然后申请需要的每一个页面，按照每页面的次序作为索引，将指针插入基树。

代码中的“>> PAGE_SHIFT”与“/ PAGE_SIZE”作用相同，

if (不明白为什么要这样)

        do_google()；

释放内存的函数如下：

void free_diskmem(void)
{
        int i;
        void *p;
        for (i = 0; i < (SIMP_BLKDEV_BYTES + PAGE_SIZE - 1) >> PAGE_SHIFT;
                i++) {
                p = radix_tree_lookup(&simp_blkdev_data, i);
                radix_tree_delete(&simp_blkdev_data, i);
                /* free NULL is safe */
                free_page((unsigned long)p);
        }
}

遍历每一个索引，得到页面的指针，释放页面，然后从基树中释放这个指针。

由于alloc_diskmem()函数在中途失败时需要释放申请过的页面，因此我们把free_diskmem()函数设计成能够释放建立了一半的基树的形式。

对于只建立了一半的基树而言，有一部分索引对应的指针还没来得及插入基树，对于不存在的索引，radix_tree_delete()函数会返回NULL，幸运的是free_page()函数能够忽略传入的NULL指针。

因为alloc_diskmem()函数需要调用free_diskmem()函数，在代码中需要把free_diskmem()函数写在alloc_diskmem()前面，或者在文件头添加函数的声明。

然后在模块的初始化和释放函数中添加对alloc_diskmem()和free_diskmem()的调用，

也就是改成这个样子：

static int __init simp_blkdev_init(void)
{
        int ret;
        simp_blkdev_queue = blk_alloc_queue(GFP_KERNEL);
        if (!simp_blkdev_queue) {
                ret = -ENOMEM;
                goto err_alloc_queue;
        }
        blk_queue_make_request(simp_blkdev_queue, simp_blkdev_make_request);
        simp_blkdev_disk = alloc_disk(SIMP_BLKDEV_MAXPARTITIONS);
        if (!simp_blkdev_disk) {
                ret = -ENOMEM;
                goto err_alloc_disk;
        }
        ret = alloc_diskmem();
        if (IS_ERR_VALUE(ret))
                goto err_alloc_diskmem;
        strcpy(simp_blkdev_disk->disk_name, SIMP_BLKDEV_DISKNAME);
        simp_blkdev_disk->major = SIMP_BLKDEV_DEVICEMAJOR;
        simp_blkdev_disk->first_minor = 0;
        simp_blkdev_disk->fops = &simp_blkdev_fops;
        simp_blkdev_disk->queue = simp_blkdev_queue;
        set_capacity(simp_blkdev_disk, SIMP_BLKDEV_BYTES>>9);
        add_disk(simp_blkdev_disk);
        return 0;
err_alloc_diskmem:
        put_disk(simp_blkdev_disk);
err_alloc_disk:
        blk_cleanup_queue(simp_blkdev_queue);
err_alloc_queue:
        return ret;
}
static void __exit simp_blkdev_exit(void)
{
        del_gendisk(simp_blkdev_disk);
        free_diskmem();
        put_disk(simp_blkdev_disk);
        blk_cleanup_queue(simp_blkdev_queue);
}

最麻烦的放在最后：

我们需要修改simp_blkdev_make_request()函数，让它适应新的数据结构。

原先的实现中，对于一个bio_vec，我们找到对应的内存中数据的起点，直接传送bvec->bv_len个字节就大功告成了，比如，读块设备时就是：

memcpy(iovec_mem, dsk_mem, bvec->bv_len);

但现在由于容纳数据的每个页面地址是不连续的，因此可能出现bio_vec中的数据跨越页面边界的情况。

也就是说，一个bio_vec中的数据的前半段在一个页面中，后半段在另一个页面中。

虽然这两个页面对应的块设备地址连续，但在内存中的地址不一定连续，因此像原先那样简单使用memcpy看样子是解决不了问题了。

实际上，虽然bio_vec可能跨越页面边界，但它无论如何也不可能跨越2个以上的页面。

这是因为bio_vec本身对应的数据最大长度只有一个页面。

因此如果希望做最简单的实现，只要在代码中做一个条件判断就OK了：

if (没有跨越页面) {

        1个memcpy搞定

} else {

        /* 肯定是跨越2个页面了 */

        2个memcpy搞定

}

但为了表现出物理设备一次传送1个扇区数据的处理方式(这种情况下一个bio_vec可能会跨越2个以上的扇区)，我们让代码支持2个以上页面的情况。

首先列出修改后的simp_blkdev_make_request()函数：

static int simp_blkdev_make_request(struct request_queue *q, struct bio *bio)
{
        struct bio_vec *bvec;
        int i;
        unsigned long long dsk_offset;
        if ((bio->bi_sector << 9) + bio->bi_size > SIMP_BLKDEV_BYTES) {
                printk(KERN_ERR SIMP_BLKDEV_DISKNAME
                        ": bad request: block=%llu, count=%u\n",
                        (unsigned long long)bio->bi_sector, bio->bi_size);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
                bio_endio(bio, 0, -EIO);
#else
                bio_endio(bio, -EIO);
#endif
                return 0;
        }
        dsk_offset = bio->bi_sector << 9;
        bio_for_each_segment(bvec, bio, i) {
                unsigned int count_done, count_current;
                void *iovec_mem;
                void *dsk_mem;
                iovec_mem = kmap(bvec->bv_page) + bvec->bv_offset;
                count_done = 0;
                while (count_done < bvec->bv_len) {
                        count_current = min(bvec->bv_len - count_done,
                                (unsigned int)(PAGE_SIZE
                                - ((dsk_offset + count_done) & ~PAGE_MASK)));
                        dsk_mem = radix_tree_lookup(&simp_blkdev_data,
                                (dsk_offset + count_done) >> PAGE_SHIFT);
                        if (!dsk_mem) {
                                printk(KERN_ERR SIMP_BLKDEV_DISKNAME
                                        ": search memory failed: %llu\n",
                                        (dsk_offset + count_done)
                                        >> PAGE_SHIFT);
                                kunmap(bvec->bv_page);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
                                bio_endio(bio, 0, -EIO);
#else
                                bio_endio(bio, -EIO);
#endif
                                return 0;
                        }
                        dsk_mem += (dsk_offset + count_done) & ~PAGE_MASK;
                        switch (bio_rw(bio)) {
                        case READ:
                        case READA:
                                memcpy(iovec_mem + count_done, dsk_mem,
                                        count_current);
                                break;
                        case WRITE:
                                memcpy(dsk_mem, iovec_mem + count_done,
                                        count_current);
                                break;
                        default:
                                printk(KERN_ERR SIMP_BLKDEV_DISKNAME
                                        ": unknown value of bio_rw: %lu\n",
                                        bio_rw(bio));
                                kunmap(bvec->bv_page);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
                                bio_endio(bio, 0, -EIO);
#else
                                bio_endio(bio, -EIO);
#endif
                                return 0;
                        }
                        count_done += count_current;
                }
                kunmap(bvec->bv_page);
                dsk_offset += bvec->bv_len;
        }
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
        bio_endio(bio, bio->bi_size, 0);
#else
        bio_endio(bio, 0);
#endif
        return 0;
}

看样子长了一些，但不要被吓着了，因为读的时候我们可以对代码做一些简化：

1：去掉乱七八糟的出错处理

2：无视每行80字符限制

3：把比特运算改成等价但更易读的乘除运算

4：无视碍眼的类型转换

5：假设内核版本大于2.6.24，以去掉判断版本的宏

就会变成这样了：

static int simp_blkdev_make_request(struct request_queue *q, struct bio *bio)
{
        struct bio_vec *bvec;
        int i;
        unsigned long long dsk_offset;
        dsk_offset = bio->bi_sector * 512;
        bio_for_each_segment(bvec, bio, i) {
                unsigned int count_done, count_current;
                void *iovec_mem;
                void *dsk_mem;
                iovec_mem = kmap(bvec->bv_page) + bvec->bv_offset;
                count_done = 0;
                while (count_done < bvec->bv_len) {
                        count_current = min(bvec->bv_len - count_done, PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE);
                        dsk_mem = radix_tree_lookup(&simp_blkdev_data, (dsk_offset + count_done) / PAGE_SIZE);
                        dsk_mem += (dsk_offset + count_done) % PAGE_SIZE;
                        switch (bio_rw(bio)) {
                        case READ:
                        case READA:
                                memcpy(iovec_mem + count_done, dsk_mem, count_current);
                                break;
                        case WRITE:
                                memcpy(dsk_mem, iovec_mem + count_done, count_current);
                                break;
                        }
                        count_done += count_current;
                }
                kunmap(bvec->bv_page);
                dsk_offset += bvec->bv_len;
        }
        bio_endio(bio, 0);
        return 0;
}

是不是清楚多了？

count_current = min(bvec->bv_len - count_done, PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE);

假设dsk_offset = 0;

bv_len = 100;

count_done = 0;

bvec->bv_len - count_done = 100;

PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE = 1024 - (0 + 0) % 1024 = 1024 - 0 = 1024;

count_current = 100;

假设dsk_offset = 100;

bv_len = 100;

count_done = 0;

bvec->bv_len - count_done = 100;

PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE = 1024 - (100 + 0) % 1024 = 1024 - 100 = 924;

count_current = 100;

假设dsk_offset = 512;

bv_len = 1000;

count_done = 0;

bvec->bv_len - count_done = 1000 - 0 = 1000;

PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE = 1024 - (512 + 0) % 1024 = 1024 - 512 = 512;

count_current = 512;

(dsk_offset + count_done) / PAGE_SIZE = (512 + 0) / 1024 = 0;

bv_len = 1000;

count_done = 512;

bvec->bv_len - count_done = 1000 - 512 = 488;

PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE = 1024 - (512 + 512) % 1024 = 1024 - 1024 = 0;

count_current = 488;

(dsk_offset + count_done) / PAGE_SIZE = (512 + 512) / 1024 = 1;

dsk_offset用来存储当前要处理的数据在块设备上的偏移，初始值是bio->bi_sector * 512，也就是起始扇区对应的偏移，也是第一个bio_vec对应的块设备偏移。

每处理完成一个bio_vec时，dsk_offset值会被更新：dsk_offset += bvec->bv_len，以指向将要处理的数据在块设备上的偏移。

在bio_for_each_segment()中代码的起始和末尾，执行kmap和kunmap开映射当前这个bio_vec的内存，这个知识在前面的章节中已经提到了，

这个处理的结果是iovec_mem指向当前的bio_vec中的缓冲区。

现在在kmap和kunmap之间的代码的功能已经很明确了，就是完成块设备上偏移为dsk_offset、长度为bvec->bv_len的数据与iovec_mem地址之间的传送。

假设不考虑bio_vec跨越页面边界的情况，这段代码应该十分写意：

dsk_mem = radix_tree_lookup(&simp_blkdev_data, dsk_offset / PAGE_SIZE) + dsk_offset % PAGE_SIZE;
switch (bio_rw(bio)) {
case READ:
case READA:
        memcpy(iovec_mem, dsk_mem, bvec->bv_len);
        break;
case WRITE:
        memcpy(dsk_mem, iovec_mem, bvec->bv_len);
        break;
}

首先使用dsk_offset / PAGE_SIZE、也就是块设备偏移在内存中数据所位于的页面次序作为索引，查找该页的内存起始地址，

然后加上块设备偏移在该页内的偏移、也就是dsk_offset % PAGE_SIZE，

就得到了内存中数据的地址，然后就是简单的数据传送。

关于块设备偏移到内存地址的转换，我们举个例子：

假使模块加载时我们分配的第1个页面的地址为0xd0000000，用于存放块设备偏移为0~4095的数据

第2个页面的地址为0xd1000000，用于存放块设备偏移为4096~8191的数据

第3个页面的地址为0xc8000000，用于存放块设备偏移为8192~12287的数据

第4个页面的地址为0xe2000000，用于存放块设备偏移为12288~16383的数据

对于块设备偏移为9000的数据，首先通过9000 / PAGE_SIZE确定它位于第3个页面中，

然后使用radix_tree_lookup(&simp_blkdev_data, 3)将查找出0xc8000000这个地址。

这是第3个页面的起始地址，这个地址的数据在块设备中的偏移是8192，

因此我们还要加上块设备偏移在页内的偏移量，也就是9000 % PAGE_SIZE = 808，

得到的才是块设备偏移为9000的数据在内存中的数据地址。

当然，假设终归是假设，往往大多数情况下是自欺欺人的，就好像彩迷总喜欢跟女友说如果中了500万，就要怎么怎么对她好一样。

现在回到残酷的现实，我们还是要去考虑bio_vec跨越页面边界的情况。

这意味着对于一个bio_vec，我们将有可能传送多次。

为了记录前几次中已经完成的数据量，我们引入了一个新的变量，叫做count_done。

在进行bio_vec内的第一次传送前，count_done的值是0，每完成一次传送，count_done将加上这次完成的数据量。

当count_done == bvec->bv_len时，就是大功告成的之日。

接着就是边界的判断。

当前块设备偏移所在的内存页中，块设备偏移所在位置到页头的距离为：

offset % PAGE_SIZE

块设备偏移所在位置到页尾的距离为：

PAGE_SIZE - offset % PAGE_SIZE

这个距离也就是不超越页边界时所能传送的数据的最大值。

因此在bio_vec内的每一次中，我们使用

count_current = min(bvec->bv_len - count_done, PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE);

来确定这一次传送的数据量。

bvec->bv_len - count_done指的是余下需要传送的数据总量，

PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE指的是从当前块设备偏移开始、不超越页边界时所能传送的数据的最大值。

如果bvec->bv_len - count_done > PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE，说明这一次将传送从当前块设备偏移到其所在内存页的页尾之间的数据，

余下的数据位于后续的页面中，将在接下来的循环中搞定，

如果bvec->bv_len - count_done <= PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE，那么可喜可贺，这将是当前bio_vec的最后一次传送，完成后就可以回家洗澡了。

结合以上的说明，我想应该不难看懂simp_blkdev_make_request()的代码了，而我们的程序也已经大功告成。

现在总结一下修改的位置：

1：把unsigned char simp_blkdev_data[SIMP_BLKDEV_BYTES];换成static struct radix_tree_root simp_blkdev_data;

2：把本文中的free_diskmem()和alloc_diskmem()函数添加到代码中，虽然没有特别意义，但建议插在紧邻simp_blkdev_init()之前的位置。

   但有特别意义的是free_diskmem()和alloc_diskmem()的顺序，如果读者到这里还打算提问是什么顺序，作者可要哭了。

3：把simp_blkdev_make_request()、simp_blkdev_init()和simp_blkdev_exit()函数替换成文中的代码。

   注意不要企图使用简化过的simp_blkdev_make_request()函数，否则造成的后果：从程序编译失败到读者被若干美女轮奸，作者都概不负责。

从常理分析，在修改完程序后，我们都将试验一次修改的效果。

这次也不例外，因为审判彭宇的王法官也是这么推断的。

首先证明我们的模块至今为止仍然经得起编译、能够加载：

# make

make -C /lib/modules/2.6.18-53.el5/build SUBDIRS=/root/test/simp_blkdev/simp_blkdev_step06 modules

make[1]: Entering directory `/usr/src/kernels/2.6.18-53.el5-i686'

  CC [M]  /root/test/simp_blkdev/simp_blkdev_step06/simp_blkdev.o

  Building modules, stage 2.

  MODPOST

  CC      /root/test/simp_blkdev/simp_blkdev_step06/simp_blkdev.mod.o

  LD [M]  /root/test/simp_blkdev/simp_blkdev_step06/simp_blkdev.ko

make[1]: Leaving directory `/usr/src/kernels/2.6.18-53.el5-i686'

# insmod simp_blkdev.ko

#

看看模块的加载时分配的非线性映射区域大小：

# lsmod

Module                  Size  Used by

simp_blkdev             8212  0

...

#

如果这个Size一栏的数字没有引起读者的足够重视的话，我们拿修改前的模块来对比一下：

# lsmod

Module                  Size  Used by

simp_blkdev         16784392  0

看出区别了没？

如果本章到这里还不结束的话，估计读者要开始闪人了。

好的，我们马上就结束，希望在这之前闪掉的读者不要太多。

由于还没有来得及闪掉而看到这段话的读者们，作者相信你们具有相当的毅力。

学习是需要毅力的，这时的作者同样也需要毅力来坚持完成这本教程。

最后还是希望读者坚持，坚持看完所有的章节，坚持在遇到每一个不明白的问题时都努力寻求答案，

坚持在发现自己感兴趣的内容时能够深入地去了解、探寻、思考。

<未完，待续>

#include <linux/init.h>
#include <linux/module.h>
#include <linux/genhd.h>		//add_disk
#include <linux/blkdev.h>		//struct block_device_operations

#define _DEBUG_

#define BLK_DISK_NAME				"block_name"
#define BLKDEV_DEVICEMAJOR        		COMPAQ_SMART2_MAJOR
#define BLKDEV_BYTES        			(16*1024*1024)
#define MAX_PARTITIONS				64
static int MAJOR_NR = 0;

static struct gendisk *g_blkdev_disk;
static struct request_queue *g_blkdev_queue;
//unsigned char blkdev_data[BLKDEV_BYTES];
struct radix_tree_root blk_dev_data;

static int blkdev_make_request(struct request_queue *q, struct bio *bio)
{
	struct bio_vec *bvec;
	int i;
	unsigned long long disk_offset = 0;

	if ((bio->bi_sector << 9) + bio->bi_size > BLKDEV_BYTES) {
		printk(KERN_ERR BLK_DISK_NAME
				": bad request: block=%llu, count=%u\n",
				(unsigned long long)bio->bi_sector, bio->bi_size);
		bio_endio(bio, -EIO);
		return 0;
	}

	disk_offset = bio->bi_sector << 9;

	bio_for_each_segment(bvec, bio, i) {
		unsigned int count_current = 0;
		unsigned int count_done = 0;
		void *iovec_mem;
		void *dsk_mem = NULL;
		iovec_mem = kmap(bvec->bv_page) + bvec->bv_offset;
		count_done = 0;
		while(count_done < bvec->bv_len){
			count_current = min(bvec->bv_len - count_done,
						(unsigned int)(PAGE_SIZE - ((disk_offset + count_done) & ~PAGE_MASK)));
			//bvec->bv_len - count_done指的是余下需要传送的数据总量，
			//PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE指的是从当前块设备偏移开始、不超越页边界时所能传送的数据的最大值。
			//如果bvec->bv_len - count_done > PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE，
			//说明这一次将传送从当前块设备偏移到其所在内存页的页尾之间的数据，
			//余下的数据位于后续的页面中，将在接下来的循环中搞定，
			//如果bvec->bv_len - count_done <= PAGE_SIZE - (dsk_offset + count_done) % PAGE_SIZE，
			//那么可喜可贺，这将是当前bio_vec的最后一次传送，完成后就可以回家洗澡了。
			dsk_mem = radix_tree_lookup(&blk_dev_data,(disk_offset + count_done) >> PAGE_SHIFT);
			//(disk_offset + count_done) >> PAGE_SHIFT 如果在传送的数据是跨页的情况下,
			//那么这个disk_offset + count_done 正好为页对齐地址,也就是下一面的地址.
			//当前要传送的数据的后半段数据,放到了下一个页的的前面,正好完成了数据的后半段搬移
			if(!dsk_mem){
				printk(KERN_ERR BLK_DISK_NAME
						": search memory failed: %llu\n",
                        (disk_offset + count_done)>> PAGE_SHIFT);
		            kunmap(bvec->bv_page);
				bio_endio(bio,-EIO);
				return 0;
			}
			dsk_mem += (disk_offset + count_done) & ~PAGE_MASK;
			switch(bio_rw(bio)){
			case READ:
			case READA:
				memcpy(iovec_mem + count_done,dsk_mem,count_current);
				break;
			case WRITE:
				memcpy(dsk_mem,iovec_mem + count_done,count_current);
				break;
			}
			count_done += count_current;
			//当前完成的字节数,这次必须加上,一方面是根据此值来获得min中计算数据,另一方面,那就是hang住啦~~while的循环条件的原因
		}
		kunmap(bvec->bv_page);
		disk_offset += bvec->bv_len;
	}		
	
	bio_endio(bio, 0);

	return 0;
}
/*
struct hd_geometry {
      unsigned char heads;		//磁头数255		//有几个磁头,也叫盘面数
      unsigned char sectors;		//扇区数64		//一个柱面有几个扇区
      unsigned short cylinders;	//柱面			//有多少个磁道的数量
      unsigned long start;
};
/*
int gendisk_getgeo(struct block_device *pblk_dev, struct hd_geometry *phd_geo)
{
	/*
	 * capacity        	heads       sectors   	cylinders
	 * 0~16M        		1        	1        	0~32768
	 * 16M~512M  		1        	32        	1024~32768
	 * 512M~16G  		32        	32        	1024~32768
	 * 16G~...       		255        	63        	2088~...
	 */
	if (BLKDEV_BYTES < 16 * 1024 * 1024) {
		phd_geo->heads = 1;
		phd_geo->sectors = 1;
	} else if (BLKDEV_BYTES < 512 * 1024 * 1024) {
		phd_geo->heads = 1;
		phd_geo->sectors = 32;
	} else if (BLKDEV_BYTES < 16ULL * 1024 * 1024 * 1024) {
		phd_geo->heads = 32;
		phd_geo->sectors = 32;
	} else {
		phd_geo->heads = 255;
		phd_geo->sectors = 63;
	}

	phd_geo->cylinders = BLKDEV_BYTES >> 9 / phd_geo->heads / phd_geo->sectors;
	
	return 0;
}

struct block_device_operations fop = {
	.owner = THIS_MODULE,
	.getgeo = gendisk_getgeo,
};

//采用基树清空申请的页面
void delete_diskmem(void)
{
	int i = 0;
	void *p = NULL;
	for(i = 0; i < (BLKDEV_BYTES + PAGE_SIZE - 1) / PAGE_SIZE; i++){
		p = radix_tree_lookup(&blk_dev_data,i);
		radix_tree_delete(&blk_dev_data,i);
		free_page((unsigned long)p);
	}
}

//采用基树申请页面
int alloc_diskmem(void)
{
	int ret = 0;
	int i = 0;
	void *p = NULL;
	//初始化基树,基树一般用于内存页管理
	INIT_RADIX_TREE(&blk_dev_data,GFP_KERNEL);
	//(BLKDEV_BYTES + PAGE_SIZE - 1) / PAGE_SIZE 防止页面不对齐的情况下,增加一页.这样剩余的数据也能用.不然不对齐超过部分不能使用了
	for(i = 0; i < (BLKDEV_BYTES + PAGE_SIZE - 1) / PAGE_SIZE; i++){
		p = (void*)__get_free_page(GFP_KERNEL);
		if(NULL == p){
			ret = -ENOMEM;
			goto err_get_page;
		}
		ret = radix_tree_insert(&blk_dev_data,i,p);
		if(IS_ERR_VALUE(ret)){
			goto err_insert;
		}
	}

	return 0;
	
err_insert:
	free_page((unsigned long)p);	//插入失败,先释放该页面
err_get_page:
	delete_diskmem();
	return ret;
}

static int __init initialization_function(void)
{
	int ret = 0;
	
	MAJOR_NR = register_blkdev(0, BLK_DISK_NAME);
	if(MAJOR_NR < 0)
	{		
		return -1;
	}
	
	g_blkdev_queue = blk_alloc_queue(GFP_KERNEL);
	if(NULL == g_blkdev_queue){
		ret = -ENOMEM;		
		goto err_alloc_queue;
	}
	
	blk_queue_make_request(g_blkdev_queue, blkdev_make_request);
	
	g_blkdev_disk = alloc_disk(MAX_PARTITIONS);
	if(NULL == g_blkdev_disk){
		ret = -ENOMEM;		
		goto err_alloc_disk;
	}
	
	//申请页面空间
	ret = alloc_diskmem();
	if(IS_ERR_VALUE(ret)){
		goto err_alloc_disk;
	}
	
	strcpy(g_blkdev_disk->disk_name,BLK_DISK_NAME);
	g_blkdev_disk->major = MAJOR_NR;
	g_blkdev_disk->first_minor = 0;
	g_blkdev_disk->fops = &fop;
	g_blkdev_disk->queue = g_blkdev_queue;
	
	set_capacity(g_blkdev_disk, BLKDEV_BYTES>>9);
	
	add_disk(g_blkdev_disk);
#ifdef _DEBUG_
	printk(KERN_WARNING "ok\n");
#endif
	return ret;
	
err_alloc_disk:
	blk_cleanup_queue(g_blkdev_queue);
err_alloc_queue:
	unregister_blkdev(MAJOR_NR, BLK_DISK_NAME);
	return ret;
}

static void __exit cleanup_function(void)
{
	del_gendisk(g_blkdev_disk);						//->add_disk
	delete_diskmem();								//->alloc_diskmem
	put_disk(g_blkdev_disk);						//->alloc_disk
	blk_cleanup_queue(g_blkdev_queue);					//->blk_init_queue
	unregister_blkdev(MAJOR_NR, BLK_DISK_NAME);
}

//注册模块加载卸载函数
module_init(initialization_function);					//指定模块加载函数
module_exit(cleanup_function);						//指定模块卸载函数

//模块信息及许可证
MODULE_AUTHOR("LvApp");								//作者
MODULE_LICENSE("Dual BSD/GPL");						//许可证
MODULE_DESCRIPTION("A simple block module");				//描述
MODULE_ALIAS("block");								//别名

本人是在参考教程之后修改的教程内容.如有不同.可能有遗漏没有修改.造成对读者的迷惑,在此致歉~~ 

yyttiao
关注
专栏目录
华为数字化转型之道 实践篇 第十章 数字化办公：构建全方位的连接与协同
沧海之巅的专栏
01-12 5698
基于这样的产品理念，WeLink确定了以4个连接为核心向外延伸的架构设计，即连接团队、连接知识、连接业务、连接设备，如图10-5所示。
走进VR游戏开发的世界
热门推荐
逍遥剑客
05-01 2万+
注: 原文2016年2月发表于公司内部社区, 最近才由同事转载出来, 删去了文中引用的一些内部文章和视频. 在这里我也只是把外网版本转过来, 留做备份. 背景介绍我们组在2014年下半年尝试开发了一款 XboxOne 平台的体感游戏, 2015年上半年进行收尾工作的同时, 结合之前积累的体感交互经验, 开始进行 VR 游戏的预研工作. 在这近一年的时间里, 一方面从外界感受到了一股虚拟现实快速发展
写一个块设备驱动－第6章
cnctloveyu的专栏
06-16 655
转自：http://linux.chinaunix.net/bbs/thread-1045283-2-1.html +---------------------------------------------------+|                 写一个块设备驱动                  |+-----------------------------------
写一个块设备驱动－第1章
cnctloveyu的专栏
06-16 1117
转自：http://linux.chinaunix.net/bbs/thread-1045283-1-1.html +---------------------------------------------------+|                 写一个块设备驱动                  |+-----------------------------------
《unix设备驱动》块设备驱动程序（加示例代码）
weixin_34279061的博客
03-31 286
块设备驱动程序 一个块设备驱动程序主要通过传输固定大小的随机数据来访问设备。 块驱动程序是在核心内存和其他存储介质之间的管道，因此他们可以认为是虚拟内存子系统的组成部分。 一些概念 一个数据块指的是固定大小的数据，而大小的值有内核决定 与数据块对应的是扇区，它是由底层硬件决定大小的一个块。 无论何时内核向用户提供一个扇区编号，该扇区的大小就是51...
非常简单的一个块设备驱动，simp_blkdev，2.6.31之后的变化
u011068616的专栏
05-05 1628
以下代码亲测在2.6.38上测试通过，在3的内核上不行，因为3的内核有许多API已经变了（见上篇），而且3的struct request没有buffer这个成员 simp_blkdev.c: #include #include #include #include #include #define SIMP_BLKDEV_MAJOR 180  #define SIM
写一个块设备驱动11，12（转）
dieqms的专栏
11-13 350
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> 第11章 +---------------------------------------------------+ |???????????????? 写一
手把手带你制作WIFI智能开关.走进物联网-ESP8266学习日记（一）
rowan2020的博客
05-05 4939
最初的目的是为了远程控制家里的一台NAS的开机，最终变成了一个小小的物联网项目，在折腾过程中踩了一个又一个的坑，作为了记录，下面我来带大家解开一个小小的物联网项目神秘面纱。如果有一点电路和编程基础最好，没有基础的话完全按照如下步骤也没问题。 家里有一台NAS，主要作为照片备份和影音服务器用。由于使用频率不是很高。一般都是用的时候开机，用完就关机了 这样就有了一个问题，偶尔出差的时候需要用，又...
跟我一起走进内联汇编的世界
雨时水滴猿先晓的博客之家
09-09 1309
一、基本内联汇编： 内联汇编代码比较容易整合到c/c++的代码中，可以做一些对于单独使用c/c++来说笨重或者不可能完成的任务。而且它还可以访问寄存器的值、访问条件码、使用一些特殊的指令和特殊的内存地址等等。 内联汇编主要用于如下场合:1.使用汇编语言编写特定的函数；2.编写对速度要求非常高的代码；3.设备驱动程序中直接访问硬件；4.编写"Naked" Call的初始化和结束代码。 C/C...
走进Deep Sort系列（二）--《Multiple Object Tracking A Literature Review》翻译及理解
weixin_45032769的博客
07-13 8449
多目标跟踪这一课题具有很大的商业潜力和发展潜力，被广泛关注，本文从以下几点为这一课题做出贡献： 1）多目标跟踪系统的关键方向，包括公式(formulation)，分类(categorization)，关键原则(key principles)，以及测评(evaluation)； 2）根据现有技术所属的不同方向来进行讨论，再将每个方向的方法划分为成组，然后对组内方法的原则、优缺点进行讨论； 3）检验现有公开的实验并且总结在主流数据集上的实验结果，再进行量化地对比，与此同时指出分析中发现的几个有
高清几何破折号新页面「HD Geometry Dash New Page」-crx插件
03-16
Geometry Dash HD壁纸让您的Chrome焕然一新 欢迎使用有趣的搜索框。 我们在19-02-2018中添加了最迷人的高质量Geometry Dash壁纸您想看Geometry Dash的壁纸吗？ 有数百种壁纸可以查看更多壁纸，请浏览我们的网站。 您可以在funsearchox.com上找到很多壁纸以及更多！ 您可以将自己喜欢的图片（家庭，游戏，电影，名人等）设置为背景！ Geometry Dash的一些强大功能如下所述：1-将Geometry Dash设置为主页时，浏览器的主页完全不同。 2-日期和天气特征。 您可以为天气小部件设置多个位置！ 3-每次刷新页面时，您都会看到一张新的Geometry Dash照片。 4-在您的浏览器中添加注释，以后再查看！ 5-提醒功能。 您可以设置一个提醒，它会在您选择的日期开始通知您。 6-您可以设置最喜欢的Geometry Dash照片并将其粘贴！ 7-社交媒体和购物链接对于您更快地浏览网络至关重要。 8-您将拥有一个干净的搜索引擎！ 9-您将拥有可定制的小部件。 例如，您将可以在屏幕上创建rss feed小部件。 10-今天的游戏部分，我们将在您的浏览器中为您提供所有您想玩的游戏列表。 11-您可以创建自定义背景，例如家庭照片或您喜欢的任何照片。 你在等什么？ 立即将浏览器的主页设置为funsearchbox.com，并具有更多功能。 支持语言:English,日本語
写一个linux块设备驱动
02-22
IBM公司一个牛人：赵磊写的一个学习linux块设备的文档，该文档分为15章，逐步教我们自己写linux块设备驱动
写一个块设备驱动 15
流年偷换的专栏
03-30 1856
第 15章 (最终章) +---------------------------------------------------+ |                 写一个块设备驱动                   | +---------------------------------------------------+ | 作者：赵磊
第5章 写一个块设备驱动
opendba的专栏
06-13 878
第5章 +---------------------------------------------------+ |                 写一个块设备驱动                  | +---------------------------------------------------+ | 作者：赵磊
linux 下块设备驱动开发学习笔记 1
Bean Huo
03-23 1511
一、块设备的I/O操作特点 字符设备与块设备I/O操作的不同在于： ① 块设备只能以块为单位接受输入和返回输出，而字符设备则以字节为单位。大多数设备是字符设备，因为它们不需要缓冲而且不以固定块大小进行操作。 ② 块设备对于I/O请求有对应的缓冲区，因此它们可以选择以什么顺序进行响应，字符设备无需缓冲且被直接读写。对于存储设备而言调整读写的顺序作用巨大，因为在读写连续的扇区比分离的扇区更快。
Linux块设备驱动(1)---块驱动中相关的结构体及其操作
BIRDYME的专栏
04-27 2735
  1.字符设备与块设备IO操做的区别 1)块设备只能以块为单位接收输入返回输出,而字符设备则以byte为单位.大多数设备是字符设备,他们不需要缓冲并且不以固定块大小进行操作.2)块设备对于IO请求有对应的缓冲区,所以他们可以选择以什么顺序进行响应.字符设备无须缓冲且被直接读写.3)字符设备只能被顺序读写,块设备可以随机访问.  2.block_de
linux驱动开发之块驱动
小段孩
06-14 3675
块驱动的IO操作特点 块设备对于io请求有缓冲区。为什么会有缓冲区呢，因为块设备的最终都是要读写磁盘的扇区的，而读写操作，都是要移动磁臂这个物理操作，所以连续读写要比分散读写快的多。所以需要有缓冲区，然后在实际读写磁盘的时候可以优化自己的操作顺序，提高工作效率。 linux的块设备子系统示意图如下： 块设备驱动结构 块设备结构体 struct block_device_operation...
Linux学习第50天：Linux块设备驱动实验（二）：Linux三大驱动之一
最新发布
01-07 608
本节笔记主要学习使用请求队列实验和不使用请求队列实验。重点在编程。
体验Linux 块设备驱动实验（模拟块）
weixin_46829095的博客
03-09 1210
用内存来模拟一个块设备进行驱动
NAND Flash坏块管理优化与逻辑层驱动设计
"NAND Flash坏块管理算法及逻辑层驱动设计" 随着21世纪的到来，NAND Flash存储器因其在移动设备和嵌入式系统中的广泛应用，已成为主流的大容量存储解决方案。然而，NAND Flash在出厂时和使用过程中都会产生坏块，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值