当前位置： 首页 > news >正文

Linux驱动-块设备驱动

news 2025/7/9 2:42:20

Linux驱动-块设备驱动

  • 一，块设备驱动简介
  • 二，无请求队列情况（EMMC和SD卡等）
  • 三，请求队列情况（磁盘等带有I/O调度的设备）
  • 四，两者在驱动上区别

一，块设备驱动简介

  块设备驱动的关键结构在于：结构体gendisk，表示一个块设备，包含设备号，分区，操作函数集，相对于字符设备驱动区别在于：
在这里插入图片描述
  有I/O调度的块设备：（I/O调度意思就是在应用层对块设备进行操作时候，这个调度模块会把对块设备的操作转化为请求request，然后放到请求队列当中，因此在处理时候，主要是对请求队列中的bio请求进行操作），请求队列模式：通过 blk_init_queue 初始化请求队列，由调度器管理 request，再分发给驱动，如磁盘设备。
在这里插入图片描述

  没有I/O调度的设备：EMMC以及SD卡，当其使用时候，相当于直接对结构体bio进行操作，此时的bio不在request结构体中了，绕过传统的 I/O 调度器，每个 bio 直接传递给驱动处理，不再合并为 request，随机进行访问，不需要控制。

  对于块设备的操作，相当于存储设备操作，那么有三个要清除的地方:①物理存储器的地址在哪②内存中的地址在哪③存储长度是多少。由bio来控制，其中bi_sector即物理设备，比如EMMC，bio_vec即内存,比如RAM。
在这里插入图片描述

二，无请求队列情况（EMMC和SD卡等）

  其实这样操作感觉还是不太对劲，相当于在RAM开辟一段空间，来模拟EMMC或者SD卡，但EMMC和SD卡操作时候是和内存RAM进行交互，现在就变成了开辟的RAM和RAM进行操作…主要流程包括①块设备注册（因为是在RAM中开辟的空间，因此在disk_init中对2MB空间进行开辟，真实情况下，连接EMMC是不用开辟这段空间的，这个是模拟EMMC）②申请gendisk③设置自旋锁（无请求队列的起始用不到这个）④初始化请求队列⑤将请求队列和回调函数ram_queue_process关联起来⑥对gendisk中的数据初始化⑦设置gendisk块大小，并将其添加到内核中。

/*4.8日 块设备驱动*/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/i2c.h>
#include <linux/genhd.h>
#include <linux/blkdev.h>
#include <linux/hdreg.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#define RAM_BLOCK_NAME  "mydisk11"
#define RAM_BLOCK_BYTE_SIZE  2*1024*1024   //2MB 字节数
#define RAM_BLOCK_SIZE  2*1024*1024/512   //2MB 即多少个块

struct disk_device{
    int  major;//块设备号
    struct gendisk  *ram_gendisk;
    spinlock_t my_spinlock;
    struct request_queue *queue; //请求队列
    unsigned char *ram_buf;
};
struct disk_device ram;

static int ram_open(struct block_device *dev, fmode_t mode)
{
    printk("ram_open \r\n");
    return 0;
}
static void ram_release(struct gendisk *disk, fmode_t mode)
{
    printk("ram_release \r\n");
}
int ram_getgeo(struct block_device *dev,struct hd_geometry *geo)
{
    return 0;
}
static struct block_device_operations ram_ops ={
    .owner = THIS_MODULE,
    .open = ram_open,
    .release = ram_release,
    .getgeo = ram_getgeo,
};

static void  ram_queue_process(struct request_queue *q,struct bio *bio)
{
    int offset = 0;
    unsigned long len = 0;//长度
    struct bio_vec ram_vec;//表示ram中的内存地址
    struct bvec_iter sd_emmc_iter;//连接的设备,比如emmc sd卡
    offset = (bio->bi_iter.bi_sector)*512; //磁盘的偏移地址
    bio_for_each_segment(ram_vec,bio,sd_emmc_iter)//遍历每一个bio
    {
        char *ptr = page_address(ram_vec.bv_page)+ram_vec.bv_offset;
        len = ram_vec.bv_len;
        if(bio_data_dir(bio)==READ)
        {
            memcpy(ptr,ram.ram_buf+offset,len);
        }else if(bio_data_dir(bio)==WRITE)
        {
            memcpy(ram.ram_buf+offset,ptr,len);
        }
        offset = offset + len;
    }
    set_bit(BIO_UPTODATE,&bio->bi_flags);
    bio_endio(bio,0);
    
}    
static int __init disk_init(void)
{
    int ret=0;
    /*1.申请ram内存*/
    ram.ram_buf = kzalloc(RAM_BLOCK_BYTE_SIZE,GFP_KERNEL);//申请字节大小
    if(ram.ram_buf ==NULL)
    {
        printk("kzalloc  error \r\n");
        ret = -1;
        goto kzalloc_ram_error;
    }
    printk("before ram.major = %d \r\n",ram.major);
    /*2.注册块设备*/
    ram.major = register_blkdev(0,RAM_BLOCK_NAME);
    if(ram.major < 0)
    {
        printk("register error \r\n");
        ret = -1;
        goto register_blkdev_error;
    }
    /*3.申请gendisk*/
    ram.ram_gendisk = alloc_disk(3);
    if(ram.ram_gendisk == NULL)
    {
        ret = -1;
        goto RAM_BLOCK_SIZE_error;
    }
    /*4.自旋锁*/
    spin_lock_init(&ram.my_spinlock);
    /*5.初始化请求队列*/
    ram.queue = blk_alloc_queue(GFP_KERNEL);
    if(ram.queue == NULL)
    {
        ret = -1;
        goto blk_queue_error;
    }
    /*制造设置请求函数*/
    blk_queue_make_request(ram.queue,ram_queue_process);
    /*6.给gendisk内值,初始化*/
    ram.ram_gendisk->major = ram.major; //主设备号
    ram.ram_gendisk->first_minor = 0;//次设备号开始
    ram.ram_gendisk->fops = &ram_ops;//操作函数
    ram.ram_gendisk->private_data = &ram; //私有数据
    ram.ram_gendisk->queue = ram.queue;//请求队列
    //memcpy(&ram.ram_gendisk->disk_name,&RAM_BLOCK_NAME,sizeof(RAM_BLOCK_NAME));
    //sprintf(ram.ram_gendisk->disk_name, RAM_BLOCK_NAME);
    snprintf(ram.ram_gendisk->disk_name, 32, "%s",RAM_BLOCK_NAME);
    set_capacity(ram.ram_gendisk,RAM_BLOCK_SIZE);//设置大小,即多少块
    add_disk(ram.ram_gendisk);//添加gendisk到内核
     printk("major = %d \r\n",ram.major);
    return ret;
blk_queue_error:   
    del_gendisk(ram.ram_gendisk);
RAM_BLOCK_SIZE_error:
    unregister_blkdev(ram.major,RAM_BLOCK_NAME);
register_blkdev_error:
    kfree(ram.ram_buf);
kzalloc_ram_error:
    return ret;

}
void __exit disk_exit(void)
{
    /*对gendisk进行操作*/
    del_gendisk(ram.ram_gendisk);
    //put_gendisk(ram.ram_gendisk);
    /*对ram.queue进行操作*/
    blk_cleanup_queue(ram.queue);
    /*对块设备进行操作*/
    unregister_blkdev(ram.major,RAM_BLOCK_NAME);
    /*释放开辟的空间*/
    kfree(ram.ram_buf);

}

module_init(disk_init);
module_exit(disk_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("WYT");

三，请求队列情况（磁盘等带有I/O调度的设备）

/*4.8日 块设备驱动*/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/i2c.h>
#include <linux/genhd.h>
#include <linux/blkdev.h>
#include <linux/hdreg.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#define RAM_BLOCK_NAME  "mydisk11"
#define RAM_BLOCK_BYTE_SIZE  2*1024*1024   //2MB 字节数
#define RAM_BLOCK_SIZE  2*1024*1024/512   //2MB 即多少个块

struct disk_device{
    int  major;//块设备号
    struct gendisk  *ram_gendisk;
    spinlock_t my_spinlock;
    struct request_queue *queue; //请求队列
    unsigned char *ram_buf;
};
struct disk_device ram;

static int ram_open(struct block_device *dev, fmode_t mode)
{
    printk("ram_open \r\n");
    return 0;
}
static void ram_release(struct gendisk *disk, fmode_t mode)
{
    printk("ram_release \r\n");
}
int ram_getgeo(struct block_device *dev,struct hd_geometry *geo)
{
    return 0;
}
static struct block_device_operations ram_ops ={
    .owner = THIS_MODULE,
    .open = ram_open,
    .release = ram_release,
    .getgeo = ram_getgeo,
};

void  ram_queue_process(struct request_queue *q)
{
    int err = 0;
    unsigned long start = 0;
    unsigned long len = 0;
    void *buff = NULL;
    struct request *req;
    req = blk_fetch_request(q);//获取第一个请求,并把它移出
    while(req != NULL)
    {
        /*进行数据操作*/
        start = blk_rq_pos(req)*512;//起始地址
        len = blk_rq_cur_bytes(req);//大小,字节单位
        buff = bio_data(req->bio);//目的让bio中的数据和buff指针执指向一个位置
        if(rq_data_dir(req) == READ)//读操作
        {
            memcpy(buff,ram.ram_buf+start,len);//正常用磁盘的情况,
                                                //应该是将ram.ram.ram_buf+start用bio中的物理存储地址
        }else if(rq_data_dir(req) == WRITE){
            memcpy(ram.ram_buf+start,buff,len);
        }
        /*判断是不是最后一个*/
        if(!__blk_end_request_cur(req,err))//完成当前部分请求,返回0,否则返回其他数值
        {
            req = blk_fetch_request(q);//if判断当前请求完成后,会继续申请下一个请求,直到申请到NULL
        }
    }
}    
static int __init disk_init(void)
{
    int ret=0;
    /*1.申请ram内存*/
    ram.ram_buf = kzalloc(RAM_BLOCK_BYTE_SIZE,GFP_KERNEL);//申请字节大小
    if(ram.ram_buf ==NULL)
    {
        printk("kzalloc  error \r\n");
        ret = -1;
        goto kzalloc_ram_error;
    }
    printk("before ram.major = %d \r\n",ram.major);
    /*2.注册块设备*/
    ram.major = register_blkdev(0,RAM_BLOCK_NAME);
    if(ram.major < 0)
    {
        printk("register error \r\n");
        ret = -1;
        goto register_blkdev_error;
    }
    /*3.申请gendisk*/
    ram.ram_gendisk = alloc_disk(3);
    if(ram.ram_gendisk == NULL)
    {
        ret = -1;
        goto RAM_BLOCK_SIZE_error;
    }
    /*4.自旋锁*/
    spin_lock_init(&ram.my_spinlock);
    /*5.初始化请求队列*/
    ram.queue = blk_init_queue(ram_queue_process,&ram.my_spinlock);
    if(ram.queue == NULL)
    {
        ret = -1;
        goto blk_queue_error;
    }
    /*6.给gendisk内值,初始化*/
    ram.ram_gendisk->major = ram.major; //主设备号
    ram.ram_gendisk->first_minor = 0;//次设备号开始
    ram.ram_gendisk->fops = &ram_ops;//操作函数
    ram.ram_gendisk->private_data = &ram; //私有数据
    ram.ram_gendisk->queue = ram.queue;//请求队列
    //memcpy(&ram.ram_gendisk->disk_name,&RAM_BLOCK_NAME,sizeof(RAM_BLOCK_NAME));
    //sprintf(ram.ram_gendisk->disk_name, RAM_BLOCK_NAME);
    snprintf(ram.ram_gendisk->disk_name, 32, "%s",RAM_BLOCK_NAME);
    set_capacity(ram.ram_gendisk,RAM_BLOCK_SIZE);//设置大小,即多少块
    add_disk(ram.ram_gendisk);//添加gendisk到内核
     printk("major = %d \r\n",ram.major);
    return ret;
blk_queue_error:   
    del_gendisk(ram.ram_gendisk);
RAM_BLOCK_SIZE_error:
    unregister_blkdev(ram.major,RAM_BLOCK_NAME);
register_blkdev_error:
    kfree(ram.ram_buf);
kzalloc_ram_error:
    return ret;

}
void __exit disk_exit(void)
{
    /*对gendisk进行操作*/
    del_gendisk(ram.ram_gendisk);
    //put_gendisk(ram.ram_gendisk);
    /*对ram.queue进行操作*/
    blk_cleanup_queue(ram.queue);
    /*对块设备进行操作*/
    unregister_blkdev(ram.major,RAM_BLOCK_NAME);
    /*释放开辟的空间*/
    kfree(ram.ram_buf);

}

module_init(disk_init);
module_exit(disk_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("WYT");

四，两者在驱动上区别

  无I/O调度设备，虽然在申请了请求队列（blk_alloc_queue），但是没有用到，最终调用的是它的ram_queue_process-1，这个函数主要处理bio中的数据。有I/O调度的设备，在请求队列申请时候，调用函数ram_queue_process-2，这个函数在处理时候，是对请求队列中request中的bio进行操作。

	/*无I/O调度（不使用请求队列）*/
    ram.queue = blk_alloc_queue(GFP_KERNEL);
    /*制造设置请求函数*/
    blk_queue_make_request(ram.queue,ram_queue_process-1);
	
	/*有I/O调度（使用请求队列）*/
	  ram.queue = blk_init_queue(ram_queue_process-2,&ram.my_spinlock);
http://www.dtcms.com/a/122298.html

相关文章：

  • 前端快速入门——JavaScript变量、控制语句
  • 依靠视频设备轨迹回放平台EasyCVR构建视频监控，为幼教连锁园区安全护航
  • java设计模式-原型模式
  • DeepSeek 都开源了哪些技术？
  • 15. git push
  • 数据结构与算法分析：哈希表简述（一）
  • vue3项目跨域请求
  • 【C语言加油站】文件存储形式全解析：文本文件与二进制文件的本质区别
  • 【创新实训个人博客】prompt嵌入
  • linux shell looop循环写法
  • 回溯——固定套路 | 面试算法12道
  • 研究嵌入式软件架构时遇到的初始化堆栈溢出问题
  • 用Python爬虫抓取数据并保存为JSON的完整指南
  • GitHub 克隆/下载失败的解决方案
  • NOIP2011提高组.玛雅游戏
  • 【AAOS】【源码分析】CarAudioService（二）-- 功能介绍
  • 单旋翼无人机(直升机)和四旋翼无人机优势对比
  • 2.BGP水平分割
  • VS Code Markdown渲染配置
  • vue+d3js+fastapi实现天气柱状图折线图饼图
  • XXE漏洞深度解析：原理、利用与防御
  • 详细解读react框架中的hooks
  • 从零推导飞机小扰动运动线性方程——0. 学习目录
  • Git版本管理系列：(二)多分支操作
  • 数据结构与算法-图论-复习2（差分约束，强连通分量，二分图，LCA，拓扑排序，欧拉路径和欧拉回路）
  • 使用stream的Collectors.toMap()方法常见问题
  • 数字电子技术基础（四十一）——数据选择器
  • 【Python教程】Python爬虫代码实现Java核心数据整理
  • python 如何安装wxpython
  • Meta 最新 AI 模型系列 ——Llama 4