summaryrefslogtreecommitdiffstats
path: root/sbull/sbull.c
diff options
context:
space:
mode:
Diffstat (limited to 'sbull/sbull.c')
-rw-r--r--sbull/sbull.c456
1 files changed, 456 insertions, 0 deletions
diff --git a/sbull/sbull.c b/sbull/sbull.c
new file mode 100644
index 0000000..1a040c3
--- /dev/null
+++ b/sbull/sbull.c
@@ -0,0 +1,456 @@
+/*
+ * Sample disk driver, from the beginning.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+
+#include <linux/sched.h>
+#include <linux/kernel.h> /* printk() */
+#include <linux/slab.h> /* kmalloc() */
+#include <linux/fs.h> /* everything... */
+#include <linux/errno.h> /* error codes */
+#include <linux/timer.h>
+#include <linux/types.h> /* size_t */
+#include <linux/fcntl.h> /* O_ACCMODE */
+#include <linux/hdreg.h> /* HDIO_GETGEO */
+#include <linux/kdev_t.h>
+#include <linux/vmalloc.h>
+#include <linux/genhd.h>
+#include <linux/blkdev.h>
+#include <linux/buffer_head.h> /* invalidate_bdev */
+#include <linux/bio.h>
+
+MODULE_LICENSE("Dual BSD/GPL");
+
+static int sbull_major = 0;
+module_param(sbull_major, int, 0);
+static int hardsect_size = 512;
+module_param(hardsect_size, int, 0);
+static int nsectors = 1024; /* How big the drive is */
+module_param(nsectors, int, 0);
+static int ndevices = 4;
+module_param(ndevices, int, 0);
+
+/*
+ * The different "request modes" we can use.
+ */
+enum {
+ RM_SIMPLE = 0, /* The extra-simple request function */
+ RM_FULL = 1, /* The full-blown version */
+ RM_NOQUEUE = 2, /* Use make_request */
+};
+static int request_mode = RM_SIMPLE;
+module_param(request_mode, int, 0);
+
+/*
+ * Minor number and partition management.
+ */
+#define SBULL_MINORS 16
+#define MINOR_SHIFT 4
+#define DEVNUM(kdevnum) (MINOR(kdev_t_to_nr(kdevnum)) >> MINOR_SHIFT
+
+/*
+ * We can tweak our hardware sector size, but the kernel talks to us
+ * in terms of small sectors, always.
+ */
+#define KERNEL_SECTOR_SIZE 512
+
+/*
+ * After this much idle time, the driver will simulate a media change.
+ */
+#define INVALIDATE_DELAY 30*HZ
+
+/*
+ * The internal representation of our device.
+ */
+struct sbull_dev {
+ int size; /* Device size in sectors */
+ u8 *data; /* The data array */
+ short users; /* How many users */
+ short media_change; /* Flag a media change? */
+ spinlock_t lock; /* For mutual exclusion */
+ struct request_queue *queue; /* The device request queue */
+ struct gendisk *gd; /* The gendisk structure */
+ struct timer_list timer; /* For simulated media changes */
+};
+
+static struct sbull_dev *Devices = NULL;
+
+/*
+ * Handle an I/O request.
+ */
+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) {
+ printk (KERN_NOTICE "Beyond-end write (%ld %ld)\n", offset, nbytes);
+ return;
+ }
+ if (write)
+ memcpy(dev->data + offset, buffer, nbytes);
+ else
+ memcpy(buffer, dev->data + offset, nbytes);
+}
+
+/*
+ * The simple form of the request function.
+ */
+static void sbull_request(request_queue_t *q)
+{
+ struct request *req;
+
+ while ((req = elv_next_request(q)) != NULL) {
+ struct sbull_dev *dev = req->rq_disk->private_data;
+ if (! blk_fs_request(req)) {
+ printk (KERN_NOTICE "Skip non-fs request\n");
+ end_request(req, 0);
+ continue;
+ }
+ // printk (KERN_NOTICE "Req dev %d dir %ld sec %ld, nr %d f %lx\n",
+ // dev - Devices, rq_data_dir(req),
+ // req->sector, req->current_nr_sectors,
+ // req->flags);
+ sbull_transfer(dev, req->sector, req->current_nr_sectors,
+ req->buffer, rq_data_dir(req));
+ end_request(req, 1);
+ }
+}
+
+
+/*
+ * Transfer a single BIO.
+ */
+static int sbull_xfer_bio(struct sbull_dev *dev, struct bio *bio)
+{
+ int i;
+ struct bio_vec *bvec;
+ sector_t sector = bio->bi_sector;
+
+ /* Do each segment independently. */
+ bio_for_each_segment(bvec, bio, i) {
+ char *buffer = __bio_kmap_atomic(bio, i, KM_USER0);
+ sbull_transfer(dev, sector, bio_cur_sectors(bio),
+ buffer, bio_data_dir(bio) == WRITE);
+ sector += bio_cur_sectors(bio);
+ __bio_kunmap_atomic(bio, KM_USER0);
+ }
+ return 0; /* Always "succeed" */
+}
+
+/*
+ * Transfer a full request.
+ */
+static int sbull_xfer_request(struct sbull_dev *dev, struct request *req)
+{
+ struct bio *bio;
+ int nsect = 0;
+
+ rq_for_each_bio(bio, req) {
+ sbull_xfer_bio(dev, bio);
+ nsect += bio->bi_size/KERNEL_SECTOR_SIZE;
+ }
+ return nsect;
+}
+
+
+
+/*
+ * Smarter request function that "handles clustering".
+ */
+static void sbull_full_request(request_queue_t *q)
+{
+ struct request *req;
+ int sectors_xferred;
+ struct sbull_dev *dev = q->queuedata;
+
+ while ((req = elv_next_request(q)) != NULL) {
+ if (! blk_fs_request(req)) {
+ printk (KERN_NOTICE "Skip non-fs request\n");
+ end_request(req, 0);
+ continue;
+ }
+ sectors_xferred = sbull_xfer_request(dev, req);
+ if (! end_that_request_first(req, 1, sectors_xferred)) {
+ blkdev_dequeue_request(req);
+ end_that_request_last(req);
+ }
+ }
+}
+
+
+
+/*
+ * The direct make request version.
+ */
+static int sbull_make_request(request_queue_t *q, struct bio *bio)
+{
+ struct sbull_dev *dev = q->queuedata;
+ int status;
+
+ status = sbull_xfer_bio(dev, bio);
+ bio_endio(bio, bio->bi_size, status);
+ return 0;
+}
+
+
+/*
+ * Open and close.
+ */
+
+static int sbull_open(struct inode *inode, struct file *filp)
+{
+ struct sbull_dev *dev = inode->i_bdev->bd_disk->private_data;
+
+ del_timer_sync(&dev->timer);
+ filp->private_data = dev;
+ spin_lock(&dev->lock);
+ if (! dev->users)
+ check_disk_change(inode->i_bdev);
+ dev->users++;
+ spin_unlock(&dev->lock);
+ return 0;
+}
+
+static int sbull_release(struct inode *inode, struct file *filp)
+{
+ struct sbull_dev *dev = inode->i_bdev->bd_disk->private_data;
+
+ spin_lock(&dev->lock);
+ dev->users--;
+
+ if (!dev->users) {
+ dev->timer.expires = jiffies + INVALIDATE_DELAY;
+ add_timer(&dev->timer);
+ }
+ spin_unlock(&dev->lock);
+
+ return 0;
+}
+
+/*
+ * Look for a (simulated) media change.
+ */
+int sbull_media_changed(struct gendisk *gd)
+{
+ struct sbull_dev *dev = gd->private_data;
+
+ return dev->media_change;
+}
+
+/*
+ * Revalidate. WE DO NOT TAKE THE LOCK HERE, for fear of deadlocking
+ * with open. That needs to be reevaluated.
+ */
+int sbull_revalidate(struct gendisk *gd)
+{
+ struct sbull_dev *dev = gd->private_data;
+
+ if (dev->media_change) {
+ dev->media_change = 0;
+ memset (dev->data, 0, dev->size);
+ }
+ return 0;
+}
+
+/*
+ * The "invalidate" function runs out of the device timer; it sets
+ * a flag to simulate the removal of the media.
+ */
+void sbull_invalidate(unsigned long ldev)
+{
+ struct sbull_dev *dev = (struct sbull_dev *) ldev;
+
+ spin_lock(&dev->lock);
+ if (dev->users || !dev->data)
+ printk (KERN_WARNING "sbull: timer sanity check failed\n");
+ else
+ dev->media_change = 1;
+ spin_unlock(&dev->lock);
+}
+
+/*
+ * The ioctl() implementation
+ */
+
+int sbull_ioctl (struct inode *inode, struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ long size;
+ struct hd_geometry geo;
+ struct sbull_dev *dev = filp->private_data;
+
+ switch(cmd) {
+ case HDIO_GETGEO:
+ /*
+ * Get geometry: since we are a virtual device, we have to make
+ * up something plausible. So we claim 16 sectors, four heads,
+ * and calculate the corresponding number of cylinders. We set the
+ * start of data at sector four.
+ */
+ size = dev->size*(hardsect_size/KERNEL_SECTOR_SIZE);
+ geo.cylinders = (size & ~0x3f) >> 6;
+ geo.heads = 4;
+ geo.sectors = 16;
+ geo.start = 4;
+ if (copy_to_user((void __user *) arg, &geo, sizeof(geo)))
+ return -EFAULT;
+ return 0;
+ }
+
+ return -ENOTTY; /* unknown command */
+}
+
+
+
+/*
+ * The device operations structure.
+ */
+static struct block_device_operations sbull_ops = {
+ .owner = THIS_MODULE,
+ .open = sbull_open,
+ .release = sbull_release,
+ .media_changed = sbull_media_changed,
+ .revalidate_disk = sbull_revalidate,
+ .ioctl = sbull_ioctl
+};
+
+
+/*
+ * Set up our internal device.
+ */
+static void setup_device(struct sbull_dev *dev, int which)
+{
+ /*
+ * Get some memory.
+ */
+ memset (dev, 0, sizeof (struct sbull_dev));
+ dev->size = nsectors*hardsect_size;
+ dev->data = vmalloc(dev->size);
+ if (dev->data == NULL) {
+ printk (KERN_NOTICE "vmalloc failure.\n");
+ return;
+ }
+ spin_lock_init(&dev->lock);
+
+ /*
+ * The timer which "invalidates" the device.
+ */
+ init_timer(&dev->timer);
+ dev->timer.data = (unsigned long) dev;
+ dev->timer.function = sbull_invalidate;
+
+ /*
+ * The I/O queue, depending on whether we are using our own
+ * make_request function or not.
+ */
+ switch (request_mode) {
+ case RM_NOQUEUE:
+ dev->queue = blk_alloc_queue(GFP_KERNEL);
+ if (dev->queue == NULL)
+ goto out_vfree;
+ blk_queue_make_request(dev->queue, sbull_make_request);
+ break;
+
+ case RM_FULL:
+ dev->queue = blk_init_queue(sbull_full_request, &dev->lock);
+ if (dev->queue == NULL)
+ goto out_vfree;
+ break;
+
+ default:
+ printk(KERN_NOTICE "Bad request mode %d, using simple\n", request_mode);
+ /* fall into.. */
+
+ case RM_SIMPLE:
+ dev->queue = blk_init_queue(sbull_request, &dev->lock);
+ if (dev->queue == NULL)
+ goto out_vfree;
+ break;
+ }
+ blk_queue_hardsect_size(dev->queue, hardsect_size);
+ dev->queue->queuedata = dev;
+ /*
+ * And the gendisk structure.
+ */
+ dev->gd = alloc_disk(SBULL_MINORS);
+ if (! dev->gd) {
+ printk (KERN_NOTICE "alloc_disk failure\n");
+ goto out_vfree;
+ }
+ dev->gd->major = sbull_major;
+ dev->gd->first_minor = which*SBULL_MINORS;
+ dev->gd->fops = &sbull_ops;
+ dev->gd->queue = dev->queue;
+ dev->gd->private_data = dev;
+ snprintf (dev->gd->disk_name, 32, "sbull%c", which + 'a');
+ 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)
+{
+ int i;
+ /*
+ * Get registered.
+ */
+ sbull_major = register_blkdev(sbull_major, "sbull");
+ if (sbull_major <= 0) {
+ printk(KERN_WARNING "sbull: unable to get major number\n");
+ return -EBUSY;
+ }
+ /*
+ * Allocate the device array, and initialize each one.
+ */
+ Devices = kmalloc(ndevices*sizeof (struct sbull_dev), GFP_KERNEL);
+ if (Devices == NULL)
+ goto out_unregister;
+ for (i = 0; i < ndevices; i++)
+ setup_device(Devices + i, i);
+
+ return 0;
+
+ out_unregister:
+ unregister_blkdev(sbull_major, "sbd");
+ return -ENOMEM;
+}
+
+static void sbull_exit(void)
+{
+ int i;
+
+ for (i = 0; i < ndevices; i++) {
+ struct sbull_dev *dev = Devices + i;
+
+ del_timer_sync(&dev->timer);
+ if (dev->gd) {
+ del_gendisk(dev->gd);
+ put_disk(dev->gd);
+ }
+ if (dev->queue) {
+ if (request_mode == RM_NOQUEUE)
+ blk_put_queue(dev->queue);
+ else
+ blk_cleanup_queue(dev->queue);
+ }
+ if (dev->data)
+ vfree(dev->data);
+ }
+ unregister_blkdev(sbull_major, "sbull");
+ kfree(Devices);
+}
+
+module_init(sbull_init);
+module_exit(sbull_exit);
generated by cgit v1.2.1-18-gbd029 (git 2.20.0) at 2025-06-15 12:49:55 +0000