2 #define MAJOR_NR COW_MAJOR
4 #include <linux/stddef.h>
5 #include <linux/kernel.h>
6 #include <linux/ctype.h>
7 #include <linux/stat.h>
8 #include <linux/vmalloc.h>
9 #include <linux/blkdev.h>
10 #include <linux/blk.h>
12 #include <linux/genhd.h>
13 #include <linux/devfs_fs.h>
14 #include <asm/uaccess.h>
15 #include "2_5compat.h"
25 struct block_device *cow_bdev;
28 struct block_device *backing_bdev;
30 unsigned long *bitmap;
31 unsigned long bitmap_len;
36 struct semaphore io_sem;
39 struct buffer_head *bh;
40 struct buffer_head *bhtail;
44 #define DEFAULT_COW { \
48 .backing_path = NULL, \
55 .working = ATOMIC_INIT(0), \
56 .io_lock = SPIN_LOCK_UNLOCKED, \
60 #define MAX_MINOR (MAX_DEV << COW_SHIFT)
62 struct cow cow_dev[MAX_DEV] = { [ 0 ... MAX_DEV - 1 ] = DEFAULT_COW };
64 /* Not modified by this driver */
65 static int blk_sizes[MAX_MINOR] = { [ 0 ... MAX_MINOR - 1 ] = BLOCK_SIZE };
66 static int hardsect_sizes[MAX_MINOR] = { [ 0 ... MAX_MINOR - 1 ] = 512 };
68 /* Protected by cow_lock */
69 static int sizes[MAX_MINOR] = { [ 0 ... MAX_MINOR - 1 ] = 0 };
71 static struct hd_struct cow_part[MAX_MINOR] =
72 { [ 0 ... MAX_MINOR - 1 ] = { 0, 0, 0 } };
74 /* Protected by io_request_lock */
75 static request_queue_t *cow_queue;
77 static int cow_open(struct inode *inode, struct file *filp);
78 static int cow_release(struct inode * inode, struct file * file);
79 static int cow_ioctl(struct inode * inode, struct file * file,
80 unsigned int cmd, unsigned long arg);
81 static int cow_revalidate(kdev_t rdev);
83 static struct block_device_operations cow_blops = {
85 .release = cow_release,
87 .revalidate = cow_revalidate,
90 /* Initialized in an initcall, and unchanged thereafter */
91 devfs_handle_t cow_dir_handle;
93 #define INIT_GENDISK(maj, name, parts, shift, bsizes, max, blops) \
97 .minor_shift = shift, \
98 .max_p = 1 << shift, \
102 .real_devices = NULL, \
109 static spinlock_t cow_lock = SPIN_LOCK_UNLOCKED;
111 static struct gendisk cow_gendisk = INIT_GENDISK(MAJOR_NR, "cow", cow_part,
112 COW_SHIFT, sizes, MAX_DEV,
115 static int cow_add(int n)
117 struct cow *dev = &cow_dev[n];
118 char name[sizeof("nnnnnn\0")];
121 if(dev->cow_path == NULL)
124 sprintf(name, "%d", n);
125 dev->devfs = devfs_register(cow_dir_handle, name, DEVFS_FL_REMOVABLE,
126 MAJOR_NR, n << COW_SHIFT, S_IFBLK |
127 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
130 init_MUTEX_LOCKED(&dev->sem);
131 init_MUTEX(&dev->io_sem);
140 * Add buffer_head to back of pending list
142 static void cow_add_bh(struct cow *cow, struct buffer_head *bh)
146 spin_lock_irqsave(&cow->io_lock, flags);
147 if(cow->bhtail != NULL){
148 cow->bhtail->b_reqnext = bh;
155 spin_unlock_irqrestore(&cow->io_lock, flags);
159 * Grab first pending buffer
161 static struct buffer_head *cow_get_bh(struct cow *cow)
163 struct buffer_head *bh;
165 spin_lock_irq(&cow->io_lock);
168 if(bh == cow->bhtail)
170 cow->bh = bh->b_reqnext;
171 bh->b_reqnext = NULL;
173 spin_unlock_irq(&cow->io_lock);
178 static void cow_handle_bh(struct cow *cow, struct buffer_head *bh,
179 struct buffer_head **cow_bh, int ncow_bh)
184 ll_rw_block(WRITE, ncow_bh, cow_bh);
186 for(i = 0; i < ncow_bh ; i++){
187 wait_on_buffer(cow_bh[i]);
191 ll_rw_block(WRITE, 1, &bh);
195 static struct buffer_head *cow_new_bh(struct cow *dev, int sector)
197 struct buffer_head *bh;
199 sector = (dev->bitmap_offset + sector / 8) / dev->sectorsize;
200 bh = getblk(dev->cow_dev, sector, dev->sectorsize);
201 memcpy(bh->b_data, dev->bitmap + sector / (8 * sizeof(dev->bitmap[0])),
206 /* Copied from loop.c, needed to avoid deadlocking in make_request. */
208 static int cow_thread(void *data)
210 struct cow *dev = data;
211 struct buffer_head *bh;
216 sprintf(current->comm, "cow%d", dev - cow_dev);
218 spin_lock_irq(¤t->sigmask_lock);
219 sigfillset(¤t->blocked);
220 flush_signals(current);
221 spin_unlock_irq(¤t->sigmask_lock);
223 atomic_inc(&dev->working);
225 current->policy = SCHED_OTHER;
228 current->flags |= PF_NOIO;
231 * up sem, we are running
236 int start, len, nbh, i, update_bitmap = 0;
237 struct buffer_head *cow_bh[2];
239 down_interruptible(&dev->io_sem);
241 * could be upped because of tear-down, not because of
244 if(!atomic_read(&dev->working))
247 bh = cow_get_bh(dev);
249 printk(KERN_ERR "cow: missing bh\n");
253 start = bh->b_blocknr * bh->b_size / dev->sectorsize;
254 len = bh->b_size / dev->sectorsize;
255 for(i = 0; i < len ; i++){
256 if(ubd_test_bit(start + i,
257 (unsigned char *) dev->bitmap))
261 ubd_set_bit(start + i, (unsigned char *) dev->bitmap);
268 cow_bh[0] = cow_new_bh(dev, start);
270 if(start / dev->sectorsize !=
271 (start + len) / dev->sectorsize){
272 cow_bh[1] = cow_new_bh(dev, start + len);
277 bh->b_dev = dev->cow_dev;
278 bh->b_blocknr += dev->data_offset / dev->sectorsize;
280 cow_handle_bh(dev, bh, cow_bh, nbh);
283 * upped both for pending work and tear-down, lo_pending
286 if(atomic_dec_and_test(&dev->working))
294 static int cow_make_request(request_queue_t *q, int rw, struct buffer_head *bh)
299 minor = MINOR(bh->b_rdev);
300 n = minor >> COW_SHIFT;
304 if(ubd_test_bit(bh->b_rsector, (unsigned char *) dev->bitmap)){
305 bh->b_rdev = dev->cow_dev;
306 bh->b_rsector += dev->data_offset / dev->sectorsize;
308 else if(rw == WRITE){
309 bh->b_dev = dev->cow_dev;
310 bh->b_blocknr += dev->data_offset / dev->sectorsize;
317 bh->b_rdev = dev->backing_dev;
327 cow_dir_handle = devfs_mk_dir (NULL, "cow", NULL);
328 if (devfs_register_blkdev(MAJOR_NR, "cow", &cow_blops)) {
329 printk(KERN_ERR "cow: unable to get major %d\n", MAJOR_NR);
332 read_ahead[MAJOR_NR] = 8; /* 8 sector (4kB) read-ahead */
333 blksize_size[MAJOR_NR] = blk_sizes;
334 blk_size[MAJOR_NR] = sizes;
335 INIT_HARDSECT(hardsect_size, MAJOR_NR, hardsect_sizes);
337 cow_queue = BLK_DEFAULT_QUEUE(MAJOR_NR);
338 blk_init_queue(cow_queue, NULL);
339 INIT_ELV(cow_queue, &cow_queue->elevator);
340 blk_queue_make_request(cow_queue, cow_make_request);
342 add_gendisk(&cow_gendisk);
344 for(i=0;i<MAX_DEV;i++)
350 __initcall(cow_init);
352 static int reader(__u64 start, char *buf, int count, void *arg)
354 dev_t dev = *((dev_t *) arg);
355 struct buffer_head *bh;
357 int cur, offset, left, n, blocksize = get_hardsect_size(dev);
360 panic("Zero blocksize");
362 block = start / blocksize;
363 offset = start % blocksize;
367 n = (left > blocksize) ? blocksize : left;
369 bh = bread(dev, block, (n < 512) ? 512 : n);
374 memcpy(&buf[cur], bh->b_data + offset, n);
385 static int cow_open(struct inode *inode, struct file *filp)
387 int (*dev_ioctl)(struct inode *, struct file *, unsigned int,
392 __u32 version, align;
395 int n, offset, err = 0;
397 n = DEVICE_NR(inode->i_rdev);
401 offset = n << COW_SHIFT;
403 spin_lock(&cow_lock);
406 dev->cow_dev = name_to_kdev_t(dev->cow_path);
407 if(dev->cow_dev == 0){
408 printk(KERN_ERR "cow_open - name_to_kdev_t(\"%s\") "
409 "failed\n", dev->cow_path);
413 dev->backing_dev = name_to_kdev_t(dev->backing_path);
414 if(dev->backing_dev == 0){
415 printk(KERN_ERR "cow_open - name_to_kdev_t(\"%s\") "
416 "failed\n", dev->backing_path);
423 dev->cow_bdev = bdget(dev->cow_dev);
424 if(dev->cow_bdev == NULL){
425 printk(KERN_ERR "cow_open - bdget(\"%s\") failed\n",
429 dev->backing_bdev = bdget(dev->backing_dev);
430 if(dev->backing_bdev == NULL){
431 printk(KERN_ERR "cow_open - bdget(\"%s\") failed\n",
439 err = blkdev_get(dev->cow_bdev, FMODE_READ|FMODE_WRITE, 0,
442 printk("cow_open - blkdev_get of COW device failed, "
443 "error = %d\n", err);
447 err = blkdev_get(dev->backing_bdev, FMODE_READ, 0, BDEV_RAW);
449 printk("cow_open - blkdev_get of backing device "
450 "failed, error = %d\n", err);
454 err = read_cow_header(reader, &dev->cow_dev, &version,
455 &backing_file, &mtime, &size,
456 &dev->sectorsize, &align,
457 &dev->bitmap_offset);
459 printk(KERN_ERR "cow_open - read_cow_header failed, "
464 cow_sizes(version, size, dev->sectorsize, align,
465 dev->bitmap_offset, &dev->bitmap_len,
467 dev->bitmap = (void *) vmalloc(dev->bitmap_len);
468 if(dev->bitmap == NULL){
470 printk(KERN_ERR "Failed to vmalloc COW bitmap\n");
473 flush_tlb_kernel_vm();
475 err = reader(dev->bitmap_offset, (char *) dev->bitmap,
476 dev->bitmap_len, &dev->cow_dev);
478 printk(KERN_ERR "Failed to read COW bitmap\n");
483 dev_ioctl = dev->backing_bdev->bd_op->ioctl;
486 err = (*dev_ioctl)(inode, filp, BLKGETSIZE,
487 (unsigned long) &sizes[offset]);
490 printk(KERN_ERR "cow_open - BLKGETSIZE failed, "
491 "error = %d\n", err);
495 kernel_thread(cow_thread, dev,
496 CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
501 spin_unlock(&cow_lock);
505 static int cow_release(struct inode * inode, struct file * file)
510 n = DEVICE_NR(inode->i_rdev);
515 spin_lock(&cow_lock);
520 err = blkdev_put(dev->cow_bdev, BDEV_RAW);
522 printk("cow_release - blkdev_put of cow device failed, "
523 "error = %d\n", err);
524 bdput(dev->cow_bdev);
527 err = blkdev_put(dev->backing_bdev, BDEV_RAW);
529 printk("cow_release - blkdev_put of backing device failed, "
530 "error = %d\n", err);
531 bdput(dev->backing_bdev);
532 dev->backing_bdev = 0;
535 spin_unlock(&cow_lock);
539 static int cow_ioctl(struct inode * inode, struct file * file,
540 unsigned int cmd, unsigned long arg)
543 int (*dev_ioctl)(struct inode *, struct file *, unsigned int,
547 n = DEVICE_NR(inode->i_rdev);
552 dev_ioctl = dev->backing_bdev->bd_op->ioctl;
553 return((*dev_ioctl)(inode, file, cmd, arg));
556 static int cow_revalidate(kdev_t rdev)
558 printk(KERN_ERR "Need to implement cow_revalidate\n");
562 static int parse_unit(char **ptr)
564 char *str = *ptr, *end;
568 n = simple_strtoul(str, &end, 0);
573 else if (('a' <= *str) && (*str <= 'h')) {
581 static int cow_setup(char *str)
584 char *cow_name, *backing_name;
587 unit = parse_unit(&str);
589 printk(KERN_ERR "cow_setup - Couldn't parse unit number\n");
594 printk(KERN_ERR "cow_setup - Missing '=' after unit "
601 backing_name = strchr(str, ',');
602 if(backing_name == NULL){
603 printk(KERN_ERR "cow_setup - missing backing device name\n");
606 *backing_name = '\0';
609 spin_lock(&cow_lock);
611 dev = &cow_dev[unit];
612 dev->cow_path = cow_name;
613 dev->backing_path = backing_name;
615 spin_unlock(&cow_lock);
619 __setup("cow", cow_setup);
622 * Overrides for Emacs so that we follow Linus's tabbing style.
623 * Emacs will notice this stuff at the end of the file and automatically
624 * adjust the settings for this buffer only. This must remain at the end
626 * ---------------------------------------------------------------------------
628 * c-file-style: "linux"