Index: linux-2.6.10/drivers/block/ll_rw_blk.c
===================================================================
--- linux-2.6.10.orig/drivers/block/ll_rw_blk.c	2004-12-25 05:33:59.000000000 +0800
+++ linux-2.6.10/drivers/block/ll_rw_blk.c	2005-04-07 00:37:34.299974720 +0800
@@ -2598,6 +2598,8 @@
 	set_bit(BIO_EOF, &bio->bi_flags);
 }
 
+int dev_check_rdonly(struct block_device *bdev);
+
 /**
  * generic_make_request: hand a buffer to its device driver for I/O
  * @bio:  The bio describing the location in memory and on the device.
@@ -2681,6 +2683,13 @@
 
 		block_wait_queue_running(q);
 
+		/* this is cfs's dev_rdonly check */
+		if (bio->bi_rw == WRITE &&
+		                dev_check_rdonly(bio->bi_bdev)) {
+		        bio_endio(bio, bio->bi_size, 0);
+		        break;
+		}
+
 		/*
 		 * If this device has partitions, remap block n
 		 * of partition p to block n+start(p) of the disk.
@@ -3156,6 +3165,91 @@
 EXPORT_SYMBOL(swap_io_context);
 
 /*
+ * Debug code for turning block devices "read-only" (will discard writes
+ * silently).  This is for filesystem crash/recovery testing.
+ */
+struct deventry {
+        dev_t dev;
+        struct deventry *next;
+};
+
+static struct deventry *devlist = NULL;
+static spinlock_t devlock = SPIN_LOCK_UNLOCKED; 
+
+int dev_check_rdonly(struct block_device *bdev) 
+{
+        struct deventry *cur;
+        if (!bdev) return 0;
+        spin_lock(&devlock);
+        cur = devlist;
+        while(cur) {
+                if (bdev->bd_dev == cur->dev) {
+                        spin_unlock(&devlock);
+                        return 1;
+                }
+                cur = cur->next;
+        }
+        spin_unlock(&devlock);
+        return 0;
+}
+
+void dev_set_rdonly(struct block_device *bdev)
+{
+        struct deventry *newdev, *cur;
+
+        if (!bdev) 
+	        return;
+        newdev = kmalloc(sizeof(struct deventry), GFP_KERNEL);
+        if (!newdev) 
+	        return;
+
+        spin_lock(&devlock);
+        cur = devlist;
+        while(cur) {
+                if (bdev->bd_dev == cur->dev) {
+                        spin_unlock(&devlock);
+                        kfree(newdev);
+                        return;
+                }
+                cur = cur->next;
+        }
+        newdev->dev = bdev->bd_dev;
+        newdev->next = devlist;
+        devlist = newdev;
+        spin_unlock(&devlock);
+        printk(KERN_WARNING "Turning device %s read-only\n",
+               bdev->bd_disk ? bdev->bd_disk->disk_name : "?");
+}
+
+void dev_clear_rdonly(struct block_device *bdev) 
+{
+        struct deventry *cur, *last = NULL;
+        if (!bdev) return;
+        spin_lock(&devlock);
+        cur = devlist;
+        while(cur) {
+                if (bdev->bd_dev == cur->dev) {
+                        if (last) 
+                                last->next = cur->next;
+                        else
+                                devlist = cur->next;
+                        spin_unlock(&devlock);
+                        kfree(cur);
+                        printk(KERN_WARNING "Removing read-only on %s\n",
+			       bdev->bd_disk ? bdev->bd_disk->disk_name : "?");
+			return;
+                }
+                last = cur;
+                cur = cur->next;
+        }
+        spin_unlock(&devlock);
+}
+
+EXPORT_SYMBOL(dev_set_rdonly);
+EXPORT_SYMBOL(dev_clear_rdonly);
+EXPORT_SYMBOL(dev_check_rdonly);
+
+/*
  * sysfs parts below
  */
 struct queue_sysfs_entry {