本文代码参考《LINUX设备驱动程序》第十六章 块设备驱动程序
本文中的“块设备”是一段大小为PAGE_SIZE的内存空间（两个扇区，每个扇区512字节）
功能：向块设备中输入内容，从块设备中读出内容
注：ldd自带块设备驱动源码在2.6.32内核的发行版上编译时会提示很多API未定义，原因是kernel 2.6中block layer API已经变更了很多，本文的程序参考了http://hi.baidu.com/casualfish/item/7931bbb58925fb951846977d，感谢！
代码：
1. sbull.c
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h> #include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/timer.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/hdreg.h>
#include <linux/kdev_t.h>
#include <linux/vmalloc.h>
#include <linux/genhd.h>
#include <linux/blkdev.h>
#include <linux/buffer_head.h>
#include <linux/bio.h> #include "sbull.h" static int sbull_major = SBULL_MAJOR;
static int hardsect_size = SBULL_HARDSECT;
static int nsectors = ;
module_param(sbull_major, int, );
module_param(hardsect_size, int, );
module_param(nsectors, int, ); struct sbull_dev {
int size;
u8 *data;
short users;
spinlock_t lock;
struct request_queue *queue;
struct gendisk *gd;
}; static struct sbull_dev *device = NULL; static void sbull_transfer(struct sbull_dev *dev, unsigned long sector, unsigned long nsect, char *buffer, int write)
{
unsigned long offset = sector*KERNEL_SECTOR_SIZE;
unsigned long nbytes = nsect*KERNEL_SECTOR_SIZE; if ((offset+nbytes) > dev->size)
{
return;
} if (write)
{
memcpy(dev->data+offset, buffer, nbytes);
}
else
{
memcpy(buffer, dev->data+offset, nbytes);
}
} static int sbull_xfer_bio(struct sbull_dev *dev, struct bio *bio)
{
int i;
struct bio_vec *bvec;
sector_t sector = bio->bi_sector; bio_for_each_segment(bvec, bio, i)
{
char *buffer = __bio_kmap_atomic(bio, i, KM_USER0);
sbull_transfer(dev, sector, bio_cur_bytes(bio)>>, buffer, bio_data_dir(bio) == WRITE);
sector += bio_cur_bytes(bio)>>;
__bio_kunmap_atomic(bio, KM_USER0);
}
return ;
} static int sbull_xfer_request(struct sbull_dev *dev, struct request *req)
{
struct bio *bio;
int nsect = ; __rq_for_each_bio(bio, req) {
sbull_xfer_bio(dev, bio);
nsect += bio->bi_size/KERNEL_SECTOR_SIZE;
}
return nsect;
} static void sbull_full_request(struct request_queue *q)
{
struct request *req;
int sectors_xferred;
struct sbull_dev *dev = q->queuedata; while((req = blk_fetch_request(q)) != NULL)
{
if (req->cmd_type != REQ_TYPE_FS)
{
__blk_end_request_all(req, -EIO);
continue;
} sectors_xferred = sbull_xfer_request(dev, req); __blk_end_request_cur(req, );
}
} static int sbull_open(struct block_device *device, fmode_t mode)
{
struct sbull_dev *dev = device->bd_disk->private_data; spin_lock(&dev->lock);
dev->users++;
spin_unlock(&dev->lock);
return ;
} static int sbull_release(struct gendisk *disk, fmode_t mode)
{
struct sbull_dev *dev = disk->private_data; spin_lock(&dev->lock);
dev->users--;
spin_unlock(&dev->lock); return ;
} static struct block_device_operations sbull_ops = {
.owner = THIS_MODULE,
.open = sbull_open,
.release = sbull_release,
}; static void setup_device(struct sbull_dev *dev)
{
memset(dev, , sizeof(struct sbull_dev));
dev->size = nsectors*hardsect_size;
dev->data = vmalloc(dev->size);
if (dev->data == NULL)
{
return;
} spin_lock_init(&dev->lock); dev->queue = blk_init_queue(sbull_full_request, &dev->lock);
if (dev->queue == NULL)
{
goto out_vfree;
} blk_queue_logical_block_size(dev->queue, hardsect_size);
dev->queue->queuedata = dev; dev->gd = alloc_disk();
if (!dev->gd)
{
goto out_vfree;
} dev->gd->major = sbull_major;
dev->gd->first_minor = ;
dev->gd->fops = &sbull_ops;
dev->gd->queue = dev->queue;
dev->gd->private_data = dev;
snprintf(dev->gd->disk_name, , "sbull");
set_capacity(dev->gd, nsectors*(hardsect_size/KERNEL_SECTOR_SIZE));
add_disk(dev->gd); return; out_vfree:
if (dev->data)
{
vfree(dev->data);
}
} static int __init sbull_init(void)
{
sbull_major = register_blkdev(sbull_major, "sbull");
if (sbull_major <= )
{
return -EBUSY;
} device = kmalloc(sizeof(struct sbull_dev), GFP_KERNEL);
if (device == NULL)
{
goto out_unregister;
} setup_device(device); return ; out_unregister:
unregister_blkdev(sbull_major, "sbull");
return -ENOMEM;
} static void sbull_exit(void)
{
struct sbull_dev *dev = device; if (dev->gd)
{
del_gendisk(dev->gd);
put_disk(dev->gd);
} if (dev->queue)
{
blk_cleanup_queue(dev->queue);
} if (dev->data)
{
vfree(dev->data);
} unregister_blkdev(sbull_major, "sbull");
kfree(device);
} module_init(sbull_init);
module_exit(sbull_exit);
MODULE_LICENSE("GPL");
2. sbull.h
#ifndef _SBULL_H
#define _SBULL_H #define SBULL_MAJOR 0
#define SBULL_HARDSECT 512 #define KERNEL_SECTOR_SIZE 512 #endif
3. Makefile
obj-m += sbull.o CURRENT_PATH:=$(shell pwd)
LINUX_KERNEL:=$(shell uname -r)
LINUX_KERNEL_PATH:=/usr/src/kernels/$(LINUX_KERNEL) all:
make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules
clean:
make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) clean
4. 验证效果
1）#make
2）#insmod sbull.ko
3）#ls /dev/ //会显示sbull
4）#ls -lh /tmp/test1
-rw-r--r--. 1 root root 4.3k Dec 2 20:47 test1
5）#dd if=/tmp/test1 of=/dev/sbull bs=512 count=2 //将test1中两个扇区的内容输入到块设备sbull中
6）#dd if=/dev/sbull of=/tmp/test2 bs=512 count=2 //将块设备sbull中两个扇区的内容输入到临时文件test2中
7）#ls -lh /tmp/test2
-rw-r--r--. 1 root root 1.0k Dec 2 21:19 test2
8）#vim test2 //test2中的内容跟test1前1024个字节的内容相同