linux系统下块设备驱动程序

顾名思义，块设备驱动程序就是支持以块的方式进行读写的设备。块设备和字符设备最大的区别在于读写数据的基本单元不同。块设备读写数据的基本单元为块，例 如磁盘通常为一个sector，而字符设备的基本单元为字节。从实现角度来看，字符设备的实现比较简单，内核例程和用户态API一一对应，这种映射关系由 字符设备的file_operations维护。块设备接口则相对复杂，读写API没有直接到块设备层，而是直接到文件系统 层，然后再由文件系统层发起读写请求。

源代码(ramdisk.c)

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>

#include <linux/fs.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/vmalloc.h>
#include <linux/blkdev.h>
#include <linux/hdreg.h>

#define RAMHD_NAME "ramhd"
#define RAMHD_MAX_DEVICE 2
#define RAMHD_MAX_PARTITIONS 4

#define RAMHD_SECTOR_SIZE 512
#define RAMHD_SECTORS 16
#define RAMHD_HEADS 4
#define RAMHD_CYLINDERS 256

#define RAMHD_SECTOR_TOTAL (RAMHD_SECTORS * RAMHD_HEADS *RAMHD_CYLINDERS)
#define RAMHD_SIZE (RAMHD_SECTOR_SIZE * RAMHD_SECTOR_TOTAL) //8mb

typedef struct {
    unsigned char* data;
    struct request_queue* queue;
    struct gendisk* gd;
}RAMHD_DEV;

static char* sdisk[RAMHD_MAX_DEVICE] = {NULL};
static RAMHD_DEV* rdev[RAMHD_MAX_DEVICE] = {NULL};

static dev_t ramhd_major;

static int ramhd_space_init(void)
{
    int i;
    int err = ;
    for(i = ; i < RAMHD_MAX_DEVICE; i++){
        sdisk[i] = vmalloc(RAMHD_SIZE);
        if(!sdisk[i]){
            err = -ENOMEM;
            return err;
        }

        memset(sdisk[i], , RAMHD_SIZE);
    }

    return err;
}

static void ramhd_space_clean(void)
{
    int i;
    for(i = ; i < RAMHD_MAX_DEVICE; i++){
        vfree(sdisk[i]);
    }
}

static int ramhd_open(struct block_device* bdev, fmode_t mode)
{
    return ;
}

static int ramhd_release(struct gendisk*gd, fmode_t mode)
{
    return ;
}

static int ramhd_ioctl(struct block_device* bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
{
    int err;
    struct hd_geometry geo;

    switch(cmd)
    {
        case HDIO_GETGEO:
            err = !access_ok(VERIFY_WRITE, arg, sizeof(geo));
            if(err)
                return -EFAULT;

            geo.cylinders = RAMHD_CYLINDERS;
            geo.heads = RAMHD_HEADS;
            geo.sectors = RAMHD_SECTORS;
            geo.start = get_start_sect(bdev);

            if(copy_to_user((void*)arg, &geo, sizeof(geo)))
                return -EFAULT;

            return ;
    }

    return -ENOTTY;
}

static struct block_device_operations ramhd_fops = {
    .owner = THIS_MODULE,
    .open = ramhd_open,
    .release = ramhd_release,
    .ioctl = ramhd_ioctl,
};

static int ramhd_make_request(struct request_queue* q, struct bio* bio)
{
    char* pRHdata;
    char* pBuffer;
    struct bio_vec* bvec;
    int i;
    int err = ;

    struct block_device* bdev = bio->bi_bdev;
    RAMHD_DEV* pdev = bdev->bd_disk->private_data;

    if(((bio->bi_sector * RAMHD_SECTOR_SIZE) + bio->bi_size) > RAMHD_SIZE){
        err = -EIO;
        return err;
    }

    pRHdata = pdev->data + (bio->bi_sector * RAMHD_SECTOR_SIZE);
    bio_for_each_segment(bvec, bio, i){
        pBuffer = kmap(bvec->bv_page) + bvec->bv_offset;
        switch(bio_data_dir(bio)){
            case READ:
                memcpy(pBuffer, pRHdata, bvec->bv_len);
                flush_dcache_page(bvec->bv_page);
                break;

            case WRITE:
                flush_dcache_page(bvec->bv_page);
                memcpy(pRHdata, pBuffer, bvec->bv_len);
                break;

            default:
                kunmap(bvec->bv_page);
                goto out;
        }

        kunmap(bvec->bv_page);
        pRHdata += bvec->bv_len;
    }

out:
    bio_endio(bio, err);
    return ;
}

static int alloc_ramdev(void)
{
    int i;
    for(i = ; i < RAMHD_MAX_DEVICE; i++){
        rdev[i] = kzalloc(sizeof(RAMHD_DEV), GFP_KERNEL);
        if(!rdev[i]){
            return -ENOMEM;
        }
    }

    return ;
}

static void clean_ramdev(void)
{
    int i;

    for(i = ; i < RAMHD_MAX_DEVICE; i++){
        if(rdev[i])
            kfree(rdev[i]);
    }
}

static int __init ramhd_init(void)
{
    int i;

    ramhd_space_init();
    alloc_ramdev();

    ramhd_major = register_blkdev(, RAMHD_NAME);

    for(i = ; i < RAMHD_MAX_DEVICE; i++){
        rdev[i]->data = sdisk[i];
        rdev[i]->queue = blk_alloc_queue(GFP_KERNEL);
        blk_queue_make_request(rdev[i]->queue, ramhd_make_request);

        rdev[i]->gd = alloc_disk(RAMHD_MAX_PARTITIONS);
        rdev[i]->gd->major = ramhd_major;
        rdev[i]->gd->first_minor = i * RAMHD_MAX_PARTITIONS;
        rdev[i]->gd->fops = &ramhd_fops;
        rdev[i]->gd->queue = rdev[i]->queue;
        rdev[i]->gd->private_data = rdev[i];
        sprintf(rdev[i]->gd->disk_name, "ramhd%c", 'a' +i);
        rdev[i]->gd->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
        set_capacity(rdev[i]->gd, RAMHD_SECTOR_TOTAL);
        add_disk(rdev[i]->gd);
    }

    return ;
}

static void __exit ramhd_exit(void)
{
    int i;
    for(i = ; i < RAMHD_MAX_DEVICE; i++){
        del_gendisk(rdev[i]->gd);
        put_disk(rdev[i]->gd);
        blk_cleanup_queue(rdev[i]->queue);
    }

    clean_ramdev();
    ramhd_space_clean();
    unregister_blkdev(ramhd_major, RAMHD_NAME);
}

module_init(ramhd_init);
module_exit(ramhd_exit);

MODULE_AUTHOR("dennis__chen@ AMDLinuxFGL");
MODULE_DESCRIPTION("The ramdisk implementation with request function");
MODULE_LICENSE("GPL");

Makefile文件

ifneq ($(KERNELRELEASE),)
obj-m := ramdisk.o

else
PWD  := $(shell pwd)
KVER := $(shell uname -r)
KDIR := /lib/modules/$(KVER)/build
all:
    $(MAKE) -C $(KDIR) M=$(PWD) modules
clean:
    rm -rf .*.cmd *.o *.mod.c *.ko .tmp_versions modules.*  Module.*
endif

操作步骤

先把Makefile 和ramdisk.c放在同一个文件夹下，然后make,

用ls命令看是否生成ramdisk.ko驱动模块

insmod ramdisk.ko //动态挂载驱动模块
lsmod  //查看是否多了个ramdisk 模块
ls /dev  //查看一下/dev目录下是否多了个block_dev节点(节点会自动创建)
mkfs.ext3 /dev/block_dev  //在虚拟磁盘上建立ext3文件系统
mount /dev/block_dev /mnt/test   //挂载到/mnt/test目录下，然后去看看mnt/test下面是不是多了lost+found文件夹
终端敲入mount，看一下mount的记录，是不是ext3格式
对它进行读写:
#cp *.c /mnt/test
#ls /mnt/test  看内容是否写过去了
#cp su.c /
#ls /su.c 看是否读OK

操作完之后就清除掉
umount /mnt/test
rmmod ramdisk.ko