lustre/kernel_patches/patches/dev_read_only-2.6.10-fc3.patch

   1 Index: linux-2.6.10/drivers/block/ll_rw_blk.c
   2 ===================================================================
   3 --- linux-2.6.10.orig/drivers/block/ll_rw_blk.c 2004-12-25 05:33:59.000000000 +0800
   4 +++ linux-2.6.10/drivers/block/ll_rw_blk.c      2005-04-07 00:37:34.299974720 +0800
   5 @@ -2598,6 +2598,8 @@
   6         set_bit(BIO_EOF, &bio->bi_flags);
   7  }
   8
   9 +int dev_check_rdonly(struct block_device *bdev);
  10 +
  11  /**
  12   * generic_make_request: hand a buffer to its device driver for I/O
  13   * @bio:  The bio describing the location in memory and on the device.
  14 @@ -2681,6 +2683,13 @@
  15
  16                 block_wait_queue_running(q);
  17
  18 +               /* this is cfs's dev_rdonly check */
  19 +               if (bio->bi_rw == WRITE &&
  20 +                               dev_check_rdonly(bio->bi_bdev)) {
  21 +                       bio_endio(bio, bio->bi_size, 0);
  22 +                       break;
  23 +               }
  24 +
  25                 /*
  26                  * If this device has partitions, remap block n
  27                  * of partition p to block n+start(p) of the disk.
  28 @@ -3156,6 +3165,91 @@
  29  EXPORT_SYMBOL(swap_io_context);
  30
  31  /*
  32 + * Debug code for turning block devices "read-only" (will discard writes
  33 + * silently).  This is for filesystem crash/recovery testing.
  34 + */
  35 +struct deventry {
  36 +        dev_t dev;
  37 +        struct deventry *next;
  38 +};
  39 +
  40 +static struct deventry *devlist = NULL;
  41 +static spinlock_t devlock = SPIN_LOCK_UNLOCKED;
  42 +
  43 +int dev_check_rdonly(struct block_device *bdev)
  44 +{
  45 +        struct deventry *cur;
  46 +        if (!bdev) return 0;
  47 +        spin_lock(&devlock);
  48 +        cur = devlist;
  49 +        while(cur) {
  50 +                if (bdev->bd_dev == cur->dev) {
  51 +                        spin_unlock(&devlock);
  52 +                        return 1;
  53 +                }
  54 +                cur = cur->next;
  55 +        }
  56 +        spin_unlock(&devlock);
  57 +        return 0;
  58 +}
  59 +
  60 +void dev_set_rdonly(struct block_device *bdev)
  61 +{
  62 +        struct deventry *newdev, *cur;
  63 +
  64 +        if (!bdev)
  65 +               return;
  66 +        newdev = kmalloc(sizeof(struct deventry), GFP_KERNEL);
  67 +        if (!newdev)
  68 +               return;
  69 +
  70 +        spin_lock(&devlock);
  71 +        cur = devlist;
  72 +        while(cur) {
  73 +                if (bdev->bd_dev == cur->dev) {
  74 +                        spin_unlock(&devlock);
  75 +                        kfree(newdev);
  76 +                        return;
  77 +                }
  78 +                cur = cur->next;
  79 +        }
  80 +        newdev->dev = bdev->bd_dev;
  81 +        newdev->next = devlist;
  82 +        devlist = newdev;
  83 +        spin_unlock(&devlock);
  84 +        printk(KERN_WARNING "Turning device %s read-only\n",
  85 +               bdev->bd_disk ? bdev->bd_disk->disk_name : "?");
  86 +}
  87 +
  88 +void dev_clear_rdonly(struct block_device *bdev)
  89 +{
  90 +        struct deventry *cur, *last = NULL;
  91 +        if (!bdev) return;
  92 +        spin_lock(&devlock);
  93 +        cur = devlist;
  94 +        while(cur) {
  95 +                if (bdev->bd_dev == cur->dev) {
  96 +                        if (last)
  97 +                                last->next = cur->next;
  98 +                        else
  99 +                                devlist = cur->next;
 100 +                        spin_unlock(&devlock);
 101 +                        kfree(cur);
 102 +                        printk(KERN_WARNING "Removing read-only on %s\n",
 103 +                              bdev->bd_disk ? bdev->bd_disk->disk_name : "?");
 104 +                       return;
 105 +                }
 106 +                last = cur;
 107 +                cur = cur->next;
 108 +        }
 109 +        spin_unlock(&devlock);
 110 +}
 111 +
 112 +EXPORT_SYMBOL(dev_set_rdonly);
 113 +EXPORT_SYMBOL(dev_clear_rdonly);
 114 +EXPORT_SYMBOL(dev_check_rdonly);
 115 +
 116 +/*
 117   * sysfs parts below
 118   */
 119  struct queue_sysfs_entry {