lustre/kernel_patches/patches/dev_read_only_2.4.21-chaos.patch

   1 --- linux-2.4.24.orig/drivers/block/ll_rw_blk.c 2005-04-07 17:30:58.978035892 -0700
   2 +++ linux-2.4.24/drivers/block/ll_rw_blk.c      2005-04-07 17:22:04.354867801 -0700
   3 @@ -691,6 +691,86 @@ void set_device_ro(kdev_t dev,int flag)
   4         else ro_bits[major][minor >> 5] &= ~(1 << (minor & 31));
   5  }
   6
   7 +
   8 +/*
   9 + * Debug code for turning block devices read-only *silently* (will
  10 + * discard writes silently).  This is only for filesystem crash/recovery
  11 + * testing.
  12 + */
  13 +struct deventry {
  14 +        kdev_t dev;
  15 +        struct deventry *next;
  16 +};
  17 +
  18 +static struct deventry *devlist = NULL;
  19 +static spinlock_t devlock = SPIN_LOCK_UNLOCKED;
  20 +
  21 +int dev_check_rdonly(kdev_t dev) {
  22 +        struct deventry *cur;
  23 +        spin_lock(&devlock);
  24 +        cur = devlist;
  25 +        while(cur) {
  26 +                if (dev == cur->dev) {
  27 +                        spin_unlock(&devlock);
  28 +                        return 1;
  29 +                }
  30 +                cur = cur->next;
  31 +        }
  32 +        spin_unlock(&devlock);
  33 +        return 0;
  34 +}
  35 +
  36 +void dev_set_rdonly(kdev_t dev)
  37 +{
  38 +        struct deventry *newdev, *cur;
  39 +        newdev = kmalloc(sizeof(struct deventry), GFP_KERNEL);
  40 +        if (!newdev) return;
  41 +
  42 +        spin_lock(&devlock);
  43 +        cur = devlist;
  44 +        while(cur) {
  45 +                if (dev == cur->dev) {
  46 +                        spin_unlock(&devlock);
  47 +                        kfree(newdev);
  48 +                        return;
  49 +                }
  50 +                cur = cur->next;
  51 +        }
  52 +        newdev->dev = dev;
  53 +        newdev->next = devlist;
  54 +        devlist = newdev;
  55 +        spin_unlock(&devlock);
  56 +        printk(KERN_WARNING "Turning device %s read-only\n",
  57 +               bdevname(dev));
  58 +}
  59 +
  60 +void dev_clear_rdonly(kdev_t dev) {
  61 +        struct deventry *cur, *last = NULL;
  62 +        spin_lock(&devlock);
  63 +        cur = devlist;
  64 +        while(cur) {
  65 +                if (dev == cur->dev) {
  66 +                        if (last)
  67 +                                last->next = cur->next;
  68 +                        else
  69 +                                devlist = cur->next;
  70 +                        spin_unlock(&devlock);
  71 +                        kfree(cur);
  72 +                        printk(KERN_WARNING "Removing read-only on %s\n",
  73 +                               bdevname(dev));
  74 +                        return;
  75 +                }
  76 +                last = cur;
  77 +                cur = cur->next;
  78 +        }
  79 +        spin_unlock(&devlock);
  80 +}
  81 +
  82 +EXPORT_SYMBOL(dev_set_rdonly);
  83 +EXPORT_SYMBOL(dev_check_rdonly);
  84 +EXPORT_SYMBOL(dev_clear_rdonly);
  85 +
  86 +
  87  inline void drive_stat_acct (kdev_t dev, int rw,
  88                                 unsigned long nr_sectors, int new_io)
  89  {
  90 @@ -1256,6 +1336,10 @@ void generic_make_request (int rw, struc
  91                         break;
  92                 }
  93
  94 +                if ((rw & WRITE)&&(dev_check_rdonly(bh->b_rdev))) {
  95 +                        bh->b_end_io(bh, 0);
  96 +                        break;
  97 +                }
  98         } while (q->make_request_fn(q, rw, bh));
  99  }
 100
 101 --- linux-2.4.24.orig/include/linux/fs.h        2003-11-28 10:26:21.000000000 -0800
 102 +++ linux-2.4.24/include/linux/fs.h     2005-04-07 17:03:36.810595409 -0700
 103 @@ -1418,6 +1418,10 @@ extern struct buffer_head * getblk(kdev_
 104  extern void ll_rw_block(int, int, struct buffer_head * bh[]);
 105  extern void submit_bh(int, struct buffer_head *);
 106  extern int is_read_only(kdev_t);
 107 +#define HAVE_CLEAR_RDONLY_ON_PUT
 108 +void dev_set_rdonly(kdev_t dev);
 109 +int dev_check_rdonly(kdev_t dev);
 110 +void dev_clear_rdonly(kdev_t dev);
 111  extern void __brelse(struct buffer_head *);
 112  static inline void brelse(struct buffer_head *buf)
 113  {
 114 --- linux-2.4.24.orig/fs/block_dev.c    2003-06-13 07:51:37.000000000 -0700
 115 +++ linux-2.4.24/fs/block_dev.c 2005-04-07 14:01:49.000000000 -0700
 116 @@ -645,6 +645,7 @@ int blkdev_put(struct block_device *bdev
 117                 bdev->bd_op = NULL;
 118         unlock_kernel();
 119         up(&bdev->bd_sem);
 120 +        dev_clear_rdonly(to_kdev_t(bdev->bd_dev));
 121         bdput(bdev);
 122         return ret;
 123  }