按照ldd的说法，linux的设备驱动包括了char，block，net三种设备。char设备是比较简单的，只要分配了major、minor号，就可以进行读写处理了。相对而言，block和net要稍微复杂些。net设备姑且按下不谈，我们在以后的博文中会有涉及。今天，我们可以看看一个简单的block是怎么设计的。
为了将block和fs分开，kernel的设计者定义了request queue这一种形式。换一句话说，所有fs对block设备的请求，最终都会转变为request的形式。所以，对于block设备驱动开发的朋友来说，处理好了request queue就掌握了block设备的一半。当然，block设备很多，hd、floppy、ram都可以这么来定义，有兴趣的朋友可以在drivers/block寻找相关的代码来阅读。兴趣没有那么强的同学，可以看看我们这篇博文，基本上也能学个大概。有个基本的概念，再加上一个简单浅显的范例，对于一般的朋友来说，已经足够了。
闲话不多说，我们看看一个ramdisk代码驱动是怎么写的，代码来自《深入linux 设备驱动程序内核机制》，
我要评论
#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 = 0;
for(i = 0; i < ramhd_max_device; i++){
sdisk[i] = vmalloc(ramhd_size);
if(!sdisk[i]){
err = -enomem;
return err;
}
memset(sdisk[i], 0, ramhd_size);
}
return err;
}
static void ramhd_space_clean(void)
{
int i;
for(i = 0; i < ramhd_max_device; i++){
vfree(sdisk[i]);
}
}
static int ramhd_open(struct block_device* bdev, fmode_t mode)
{
return 0;
}
static int ramhd_release(struct gendisk*gd, fmode_t mode)
{
return 0;
}
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 0;
}
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 = 0;
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 0;
}
static int alloc_ramdev(void)
{
int i;
for(i = 0; i < ramhd_max_device; i++){
rdev[i] = kzalloc(sizeof(ramhd_dev), gfp_kernel);
if(!rdev[i]){
return -enomem;
}
}
return 0;
}
static void clean_ramdev(void)
{
int i;
for(i = 0; 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(0, ramhd_name);
for(i = 0; 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 0;
}
static void __exit ramhd_exit(void)
{
int i;
for(i = 0; 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放出来，看过前面blog的朋友都知道，这其实很简单，
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
这段代码究竟有没有用呢？可以按照下面的步骤来做，
a）make 一下，生成ramdisk.ko；
b）编译好了之后，就可以安装驱动了，在linux下是这么做的，sudo insmod ramdisk.ko；
c）安装好了，利用ls /dev/ramhd*， 就会发现在/dev下新增两个结点，即/dev/ramhda和/dev/ramhdb；
d）不妨选择其中一个节点进行分区处理， sudo fdisk /dev/ramhda，简单处理的话就建立一个分区， 生成/dev/ramhda1；
e）创建文件系统，sudo mkfs.ext3 /dev/ramhda1；
f）有了上面的文件系统，就可以进行mount处理，不妨sudo mount /dev/ramhda1 /mnt；
g）上面都弄好了，大家就可以copy、delete文件试试了，是不是很简单。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持移动技术网。
如对本文有疑问， 点击进行留言回复！！
网友评论