lustre/kernel_patches/patches/raid5-stats.patch

   1 Add RAID statistics counters to /proc/mdstat
   2
   3 Index: linux-2.6.9/include/linux/raid/raid5.h
   4 ===================================================================
   5 --- linux-2.6.9.orig/include/linux/raid/raid5.h 2004-10-19 01:54:55.000000000 +0400
   6 +++ linux-2.6.9/include/linux/raid/raid5.h      2006-05-17 14:10:53.000000000 +0400
   7 @@ -222,6 +222,22 @@ struct raid5_private_data {
   8         int                     inactive_blocked;       /* release of inactive stripes blocked,
   9                                                          * waiting for 25% to be free
  10                                                          */
  11 +       /*
  12 +        * Stats
  13 +        */
  14 +       atomic_t                reads_in;
  15 +       atomic_t                writes_in;
  16 +       atomic_t                reads_out;
  17 +       atomic_t                writes_out;
  18 +       atomic_t                handled_in_raid5d;
  19 +       atomic_t                out_of_stripes;
  20 +       atomic_t                reads_for_rmw;
  21 +       atomic_t                reads_for_rcw;
  22 +       atomic_t                handle_called;
  23 +       atomic_t                delayed;
  24 +       atomic_t                in_reqs_in_queue;
  25 +       atomic_t                out_reqs_in_queue;
  26 +
  27         spinlock_t              device_lock;
  28         struct disk_info        disks[0];
  29  };
  30 Index: linux-2.6.9/drivers/md/raid5.c
  31 ===================================================================
  32 --- linux-2.6.9.orig/drivers/md/raid5.c 2006-03-10 18:20:48.000000000 +0300
  33 +++ linux-2.6.9/drivers/md/raid5.c      2006-05-17 14:10:53.000000000 +0400
  34 @@ -77,9 +77,10 @@ static inline void __release_stripe(raid
  35                 if (atomic_read(&conf->active_stripes)==0)
  36                         BUG();
  37                 if (test_bit(STRIPE_HANDLE, &sh->state)) {
  38 -                       if (test_bit(STRIPE_DELAYED, &sh->state))
  39 +                       if (test_bit(STRIPE_DELAYED, &sh->state)) {
  40                                 list_add_tail(&sh->lru, &conf->delayed_list);
  41 -                       else
  42 +                               atomic_inc(&conf->delayed);
  43 +                       } else
  44                                 list_add_tail(&sh->lru, &conf->handle_list);
  45                         md_wakeup_thread(conf->mddev->thread);
  46                 } else {
  47 @@ -250,6 +251,7 @@ static struct stripe_head *get_active_st
  48                         if (noblock && sh == NULL)
  49                                 break;
  50                         if (!sh) {
  51 +                               atomic_inc(&conf->out_of_stripes);
  52                                 conf->inactive_blocked = 1;
  53                                 wait_event_lock_irq(conf->wait_for_stripe,
  54                                                     !list_empty(&conf->inactive_list) &&
  55 @@ -271,6 +273,8 @@ static struct stripe_head *get_active_st
  56                                 if (list_empty(&sh->lru))
  57                                         BUG();
  58                                 list_del_init(&sh->lru);
  59 +                               if (test_bit(STRIPE_DELAYED, &sh->state))
  60 +                                       atomic_dec(&conf->delayed);
  61                         }
  62                 }
  63         } while (sh == NULL);
  64 @@ -349,6 +353,8 @@ static int raid5_end_read_request (struc
  65         if (bi->bi_size)
  66                 return 1;
  67
  68 +       atomic_dec(&conf->out_reqs_in_queue);
  69 +
  70         for (i=0 ; i<disks; i++)
  71                 if (bi == &sh->dev[i].req)
  72                         break;
  73 @@ -422,6 +428,8 @@ static int raid5_end_write_request (stru
  74         if (bi->bi_size)
  75                 return 1;
  76
  77 +       atomic_dec(&conf->out_reqs_in_queue);
  78 +
  79         for (i=0 ; i<disks; i++)
  80                 if (bi == &sh->dev[i].req)
  81                         break;
  82 @@ -882,6 +890,7 @@ static void handle_stripe(struct stripe_
  83         spin_lock(&sh->lock);
  84         clear_bit(STRIPE_HANDLE, &sh->state);
  85         clear_bit(STRIPE_DELAYED, &sh->state);
  86 +       atomic_inc(&conf->handle_called);
  87
  88         syncing = test_bit(STRIPE_SYNCING, &sh->state);
  89         /* Now to look around and see what can be done */
  90 @@ -1127,6 +1136,7 @@ static void handle_stripe(struct stripe_
  91                                                 set_bit(R5_LOCKED, &dev->flags);
  92                                                 set_bit(R5_Wantread, &dev->flags);
  93                                                 locked++;
  94 +                                               atomic_inc(&conf->reads_for_rmw);
  95                                         } else {
  96                                                 set_bit(STRIPE_DELAYED, &sh->state);
  97                                                 set_bit(STRIPE_HANDLE, &sh->state);
  98 @@ -1146,6 +1156,7 @@ static void handle_stripe(struct stripe_
  99                                                 set_bit(R5_LOCKED, &dev->flags);
 100                                                 set_bit(R5_Wantread, &dev->flags);
 101                                                 locked++;
 102 +                                               atomic_inc(&conf->reads_for_rcw);
 103                                         } else {
 104                                                 set_bit(STRIPE_DELAYED, &sh->state);
 105                                                 set_bit(STRIPE_HANDLE, &sh->state);
 106 @@ -1228,6 +1239,7 @@ static void handle_stripe(struct stripe_
 107                 bi->bi_next = NULL;
 108                 bi->bi_size = 0;
 109                 bi->bi_end_io(bi, bytes, 0);
 110 +               atomic_dec(&conf->in_reqs_in_queue);
 111         }
 112         for (i=disks; i-- ;) {
 113                 int rw;
 114 @@ -1243,10 +1255,13 @@ static void handle_stripe(struct stripe_
 115                 bi = &sh->dev[i].req;
 116
 117                 bi->bi_rw = rw;
 118 -               if (rw)
 119 +               if (rw) {
 120 +                       atomic_inc(&conf->writes_out);
 121                         bi->bi_end_io = raid5_end_write_request;
 122 -               else
 123 +               } else {
 124 +                       atomic_inc(&conf->reads_out);
 125                         bi->bi_end_io = raid5_end_read_request;
 126 +               }
 127
 128                 spin_lock_irq(&conf->device_lock);
 129                 rdev = conf->disks[i].rdev;
 130 @@ -1274,6 +1289,7 @@ static void handle_stripe(struct stripe_
 131                         bi->bi_io_vec[0].bv_offset = 0;
 132                         bi->bi_size = STRIPE_SIZE;
 133                         bi->bi_next = NULL;
 134 +                       atomic_inc(&conf->out_reqs_in_queue);
 135                         generic_make_request(bi);
 136                 } else {
 137                         PRINTK("skip op %ld on disc %d for sector %llu\n",
 138 @@ -1296,6 +1312,7 @@ static inline void raid5_activate_delaye
 139                         if (!test_and_set_bit(STRIPE_PREREAD_ACTIVE, &sh->state))
 140                                 atomic_inc(&conf->preread_active_stripes);
 141                         list_add_tail(&sh->lru, &conf->handle_list);
 142 +                       atomic_dec(&conf->delayed);
 143                 }
 144         }
 145  }
 146 @@ -1395,12 +1412,16 @@ static int make_request (request_queue_t
 147         sector_t logical_sector, last_sector;
 148         struct stripe_head *sh;
 149
 150 +       atomic_inc(&conf->in_reqs_in_queue);
 151 +
 152         if (bio_data_dir(bi)==WRITE) {
 153                 disk_stat_inc(mddev->gendisk, writes);
 154                 disk_stat_add(mddev->gendisk, write_sectors, bio_sectors(bi));
 155 +               atomic_inc(&conf->writes_in);
 156         } else {
 157                 disk_stat_inc(mddev->gendisk, reads);
 158                 disk_stat_add(mddev->gendisk, read_sectors, bio_sectors(bi));
 159 +               atomic_inc(&conf->reads_in);
 160         }
 161
 162         logical_sector = bi->bi_sector & ~((sector_t)STRIPE_SECTORS-1);
 163 @@ -1439,6 +1460,7 @@ static int make_request (request_queue_t
 164
 165                 if ( bio_data_dir(bi) == WRITE )
 166                         md_write_end(mddev);
 167 +               atomic_dec(&conf->in_reqs_in_queue);
 168                 bi->bi_size = 0;
 169                 bi->bi_end_io(bi, bytes, 0);
 170         }
 171 @@ -1535,6 +1557,7 @@ static void raid5d (mddev_t *mddev)
 172                 spin_unlock_irq(&conf->device_lock);
 173
 174                 handled++;
 175 +               atomic_inc(&conf->handled_in_raid5d);
 176                 handle_stripe(sh);
 177                 release_stripe(sh);
 178
 179 @@ -1767,6 +1790,21 @@ static void status (struct seq_file *seq
 180                                conf->disks[i].rdev &&
 181                                conf->disks[i].rdev->in_sync ? "U" : "_");
 182         seq_printf (seq, "]");
 183 +       seq_printf (seq, "\n\t\tin: %u reads, %u writes; out: %u reads, %u writes",
 184 +                       atomic_read(&conf->reads_in), atomic_read(&conf->writes_in),
 185 +                       atomic_read(&conf->reads_out), atomic_read(&conf->writes_out));
 186 +       seq_printf (seq, "\n\t\t%u in raid5d, %u out of stripes, %u handle called",
 187 +                       atomic_read(&conf->handled_in_raid5d),
 188 +                       atomic_read(&conf->out_of_stripes),
 189 +                       atomic_read(&conf->handle_called));
 190 +       seq_printf (seq, "\n\t\treads: %u for rmw, %u for rcw",
 191 +                       atomic_read(&conf->reads_for_rmw),
 192 +                       atomic_read(&conf->reads_for_rcw));
 193 +       seq_printf (seq, "\n\t\t%u delayed, %u active, queues: %u in, %u out\n",
 194 +                       atomic_read(&conf->delayed),
 195 +                       atomic_read(&conf->active_stripes),
 196 +                       atomic_read(&conf->in_reqs_in_queue),
 197 +                       atomic_read(&conf->out_reqs_in_queue));
 198  #if RAID5_DEBUG
 199  #define D(x) \
 200         seq_printf (seq, "<"#x":%d>", atomic_read(&conf->x))