Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef _RAID5_H |
| 2 | #define _RAID5_H |
| 3 | |
| 4 | #include <linux/raid/md.h> |
| 5 | #include <linux/raid/xor.h> |
| 6 | |
| 7 | /* |
| 8 | * |
| 9 | * Each stripe contains one buffer per disc. Each buffer can be in |
| 10 | * one of a number of states stored in "flags". Changes between |
| 11 | * these states happen *almost* exclusively under a per-stripe |
| 12 | * spinlock. Some very specific changes can happen in bi_end_io, and |
| 13 | * these are not protected by the spin lock. |
| 14 | * |
| 15 | * The flag bits that are used to represent these states are: |
| 16 | * R5_UPTODATE and R5_LOCKED |
| 17 | * |
| 18 | * State Empty == !UPTODATE, !LOCK |
| 19 | * We have no data, and there is no active request |
| 20 | * State Want == !UPTODATE, LOCK |
| 21 | * A read request is being submitted for this block |
| 22 | * State Dirty == UPTODATE, LOCK |
| 23 | * Some new data is in this buffer, and it is being written out |
| 24 | * State Clean == UPTODATE, !LOCK |
| 25 | * We have valid data which is the same as on disc |
| 26 | * |
| 27 | * The possible state transitions are: |
| 28 | * |
| 29 | * Empty -> Want - on read or write to get old data for parity calc |
| 30 | * Empty -> Dirty - on compute_parity to satisfy write/sync request.(RECONSTRUCT_WRITE) |
| 31 | * Empty -> Clean - on compute_block when computing a block for failed drive |
| 32 | * Want -> Empty - on failed read |
| 33 | * Want -> Clean - on successful completion of read request |
| 34 | * Dirty -> Clean - on successful completion of write request |
| 35 | * Dirty -> Clean - on failed write |
| 36 | * Clean -> Dirty - on compute_parity to satisfy write/sync (RECONSTRUCT or RMW) |
| 37 | * |
| 38 | * The Want->Empty, Want->Clean, Dirty->Clean, transitions |
| 39 | * all happen in b_end_io at interrupt time. |
| 40 | * Each sets the Uptodate bit before releasing the Lock bit. |
| 41 | * This leaves one multi-stage transition: |
| 42 | * Want->Dirty->Clean |
| 43 | * This is safe because thinking that a Clean buffer is actually dirty |
| 44 | * will at worst delay some action, and the stripe will be scheduled |
| 45 | * for attention after the transition is complete. |
| 46 | * |
| 47 | * There is one possibility that is not covered by these states. That |
| 48 | * is if one drive has failed and there is a spare being rebuilt. We |
| 49 | * can't distinguish between a clean block that has been generated |
| 50 | * from parity calculations, and a clean block that has been |
| 51 | * successfully written to the spare ( or to parity when resyncing). |
| 52 | * To distingush these states we have a stripe bit STRIPE_INSYNC that |
| 53 | * is set whenever a write is scheduled to the spare, or to the parity |
| 54 | * disc if there is no spare. A sync request clears this bit, and |
| 55 | * when we find it set with no buffers locked, we know the sync is |
| 56 | * complete. |
| 57 | * |
| 58 | * Buffers for the md device that arrive via make_request are attached |
| 59 | * to the appropriate stripe in one of two lists linked on b_reqnext. |
| 60 | * One list (bh_read) for read requests, one (bh_write) for write. |
| 61 | * There should never be more than one buffer on the two lists |
| 62 | * together, but we are not guaranteed of that so we allow for more. |
| 63 | * |
| 64 | * If a buffer is on the read list when the associated cache buffer is |
| 65 | * Uptodate, the data is copied into the read buffer and it's b_end_io |
| 66 | * routine is called. This may happen in the end_request routine only |
| 67 | * if the buffer has just successfully been read. end_request should |
| 68 | * remove the buffers from the list and then set the Uptodate bit on |
| 69 | * the buffer. Other threads may do this only if they first check |
| 70 | * that the Uptodate bit is set. Once they have checked that they may |
| 71 | * take buffers off the read queue. |
| 72 | * |
| 73 | * When a buffer on the write list is committed for write it is copied |
| 74 | * into the cache buffer, which is then marked dirty, and moved onto a |
| 75 | * third list, the written list (bh_written). Once both the parity |
| 76 | * block and the cached buffer are successfully written, any buffer on |
| 77 | * a written list can be returned with b_end_io. |
| 78 | * |
| 79 | * The write list and read list both act as fifos. The read list is |
| 80 | * protected by the device_lock. The write and written lists are |
| 81 | * protected by the stripe lock. The device_lock, which can be |
| 82 | * claimed while the stipe lock is held, is only for list |
| 83 | * manipulations and will only be held for a very short time. It can |
| 84 | * be claimed from interrupts. |
| 85 | * |
| 86 | * |
| 87 | * Stripes in the stripe cache can be on one of two lists (or on |
| 88 | * neither). The "inactive_list" contains stripes which are not |
| 89 | * currently being used for any request. They can freely be reused |
| 90 | * for another stripe. The "handle_list" contains stripes that need |
| 91 | * to be handled in some way. Both of these are fifo queues. Each |
| 92 | * stripe is also (potentially) linked to a hash bucket in the hash |
| 93 | * table so that it can be found by sector number. Stripes that are |
| 94 | * not hashed must be on the inactive_list, and will normally be at |
| 95 | * the front. All stripes start life this way. |
| 96 | * |
| 97 | * The inactive_list, handle_list and hash bucket lists are all protected by the |
| 98 | * device_lock. |
| 99 | * - stripes on the inactive_list never have their stripe_lock held. |
| 100 | * - stripes have a reference counter. If count==0, they are on a list. |
| 101 | * - If a stripe might need handling, STRIPE_HANDLE is set. |
| 102 | * - When refcount reaches zero, then if STRIPE_HANDLE it is put on |
| 103 | * handle_list else inactive_list |
| 104 | * |
| 105 | * This, combined with the fact that STRIPE_HANDLE is only ever |
| 106 | * cleared while a stripe has a non-zero count means that if the |
| 107 | * refcount is 0 and STRIPE_HANDLE is set, then it is on the |
| 108 | * handle_list and if recount is 0 and STRIPE_HANDLE is not set, then |
| 109 | * the stripe is on inactive_list. |
| 110 | * |
| 111 | * The possible transitions are: |
| 112 | * activate an unhashed/inactive stripe (get_active_stripe()) |
| 113 | * lockdev check-hash unlink-stripe cnt++ clean-stripe hash-stripe unlockdev |
| 114 | * activate a hashed, possibly active stripe (get_active_stripe()) |
| 115 | * lockdev check-hash if(!cnt++)unlink-stripe unlockdev |
| 116 | * attach a request to an active stripe (add_stripe_bh()) |
| 117 | * lockdev attach-buffer unlockdev |
| 118 | * handle a stripe (handle_stripe()) |
| 119 | * lockstripe clrSTRIPE_HANDLE ... (lockdev check-buffers unlockdev) .. change-state .. record io needed unlockstripe schedule io |
| 120 | * release an active stripe (release_stripe()) |
| 121 | * lockdev if (!--cnt) { if STRIPE_HANDLE, add to handle_list else add to inactive-list } unlockdev |
| 122 | * |
| 123 | * The refcount counts each thread that have activated the stripe, |
| 124 | * plus raid5d if it is handling it, plus one for each active request |
| 125 | * on a cached buffer. |
| 126 | */ |
| 127 | |
| 128 | struct stripe_head { |
NeilBrown | fccddba | 2006-01-06 00:20:33 -0800 | [diff] [blame] | 129 | struct hlist_node hash; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | struct list_head lru; /* inactive_list or handle_list */ |
| 131 | struct raid5_private_data *raid_conf; |
| 132 | sector_t sector; /* sector of this row */ |
| 133 | int pd_idx; /* parity disk index */ |
| 134 | unsigned long state; /* state flags */ |
| 135 | atomic_t count; /* nr of active thread/requests */ |
| 136 | spinlock_t lock; |
NeilBrown | 7262668 | 2005-09-09 16:23:54 -0700 | [diff] [blame] | 137 | int bm_seq; /* sequence number for bitmap flushes */ |
NeilBrown | 7ecaa1e | 2006-03-27 01:18:08 -0800 | [diff] [blame] | 138 | int disks; /* disks in stripe */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | struct r5dev { |
| 140 | struct bio req; |
| 141 | struct bio_vec vec; |
| 142 | struct page *page; |
| 143 | struct bio *toread, *towrite, *written; |
| 144 | sector_t sector; /* sector of this page */ |
| 145 | unsigned long flags; |
| 146 | } dev[1]; /* allocated with extra space depending of RAID geometry */ |
| 147 | }; |
| 148 | /* Flags */ |
| 149 | #define R5_UPTODATE 0 /* page contains current data */ |
| 150 | #define R5_LOCKED 1 /* IO has been submitted on "req" */ |
| 151 | #define R5_OVERWRITE 2 /* towrite covers whole page */ |
| 152 | /* and some that are internal to handle_stripe */ |
| 153 | #define R5_Insync 3 /* rdev && rdev->in_sync at start */ |
| 154 | #define R5_Wantread 4 /* want to schedule a read */ |
| 155 | #define R5_Wantwrite 5 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 156 | #define R5_Overlap 7 /* There is a pending overlapping request on this block */ |
NeilBrown | 4e5314b | 2005-11-08 21:39:22 -0800 | [diff] [blame] | 157 | #define R5_ReadError 8 /* seen a read error here recently */ |
| 158 | #define R5_ReWrite 9 /* have tried to over-write the readerror */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | |
NeilBrown | ccfcc3c | 2006-03-27 01:18:09 -0800 | [diff] [blame] | 160 | #define R5_Expanded 10 /* This block now has post-expand data */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | /* |
| 162 | * Write method |
| 163 | */ |
| 164 | #define RECONSTRUCT_WRITE 1 |
| 165 | #define READ_MODIFY_WRITE 2 |
| 166 | /* not a write method, but a compute_parity mode */ |
| 167 | #define CHECK_PARITY 3 |
| 168 | |
| 169 | /* |
| 170 | * Stripe state |
| 171 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 172 | #define STRIPE_HANDLE 2 |
| 173 | #define STRIPE_SYNCING 3 |
| 174 | #define STRIPE_INSYNC 4 |
| 175 | #define STRIPE_PREREAD_ACTIVE 5 |
| 176 | #define STRIPE_DELAYED 6 |
NeilBrown | 7262668 | 2005-09-09 16:23:54 -0700 | [diff] [blame] | 177 | #define STRIPE_DEGRADED 7 |
| 178 | #define STRIPE_BIT_DELAY 8 |
NeilBrown | 7ecaa1e | 2006-03-27 01:18:08 -0800 | [diff] [blame] | 179 | #define STRIPE_EXPANDING 9 |
NeilBrown | ccfcc3c | 2006-03-27 01:18:09 -0800 | [diff] [blame] | 180 | #define STRIPE_EXPAND_SOURCE 10 |
| 181 | #define STRIPE_EXPAND_READY 11 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | /* |
| 183 | * Plugging: |
| 184 | * |
| 185 | * To improve write throughput, we need to delay the handling of some |
| 186 | * stripes until there has been a chance that several write requests |
| 187 | * for the one stripe have all been collected. |
| 188 | * In particular, any write request that would require pre-reading |
| 189 | * is put on a "delayed" queue until there are no stripes currently |
| 190 | * in a pre-read phase. Further, if the "delayed" queue is empty when |
| 191 | * a stripe is put on it then we "plug" the queue and do not process it |
| 192 | * until an unplug call is made. (the unplug_io_fn() is called). |
| 193 | * |
| 194 | * When preread is initiated on a stripe, we set PREREAD_ACTIVE and add |
| 195 | * it to the count of prereading stripes. |
| 196 | * When write is initiated, or the stripe refcnt == 0 (just in case) we |
| 197 | * clear the PREREAD_ACTIVE flag and decrement the count |
| 198 | * Whenever the delayed queue is empty and the device is not plugged, we |
| 199 | * move any strips from delayed to handle and clear the DELAYED flag and set PREREAD_ACTIVE. |
| 200 | * In stripe_handle, if we find pre-reading is necessary, we do it if |
| 201 | * PREREAD_ACTIVE is set, else we set DELAYED which will send it to the delayed queue. |
| 202 | * HANDLE gets cleared if stripe_handle leave nothing locked. |
| 203 | */ |
| 204 | |
| 205 | |
| 206 | struct disk_info { |
| 207 | mdk_rdev_t *rdev; |
| 208 | }; |
| 209 | |
| 210 | struct raid5_private_data { |
NeilBrown | fccddba | 2006-01-06 00:20:33 -0800 | [diff] [blame] | 211 | struct hlist_head *stripe_hashtbl; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | mddev_t *mddev; |
| 213 | struct disk_info *spare; |
| 214 | int chunk_size, level, algorithm; |
| 215 | int raid_disks, working_disks, failed_disks; |
| 216 | int max_nr_stripes; |
| 217 | |
NeilBrown | 7ecaa1e | 2006-03-27 01:18:08 -0800 | [diff] [blame] | 218 | /* used during an expand */ |
| 219 | sector_t expand_progress; /* MaxSector when no expand happening */ |
| 220 | int previous_raid_disks; |
| 221 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 222 | struct list_head handle_list; /* stripes needing handling */ |
| 223 | struct list_head delayed_list; /* stripes that have plugged requests */ |
NeilBrown | 7262668 | 2005-09-09 16:23:54 -0700 | [diff] [blame] | 224 | struct list_head bitmap_list; /* stripes delaying awaiting bitmap update */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | atomic_t preread_active_stripes; /* stripes with scheduled io */ |
| 226 | |
NeilBrown | ad01c9e | 2006-03-27 01:18:07 -0800 | [diff] [blame] | 227 | /* unfortunately we need two cache names as we temporarily have |
| 228 | * two caches. |
| 229 | */ |
| 230 | int active_name; |
| 231 | char cache_name[2][20]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | kmem_cache_t *slab_cache; /* for allocating stripes */ |
NeilBrown | 7262668 | 2005-09-09 16:23:54 -0700 | [diff] [blame] | 233 | |
| 234 | int seq_flush, seq_write; |
| 235 | int quiesce; |
| 236 | |
| 237 | int fullsync; /* set to 1 if a full sync is needed, |
| 238 | * (fresh device added). |
| 239 | * Cleared when a sync completes. |
| 240 | */ |
| 241 | |
NeilBrown | ca65b73 | 2006-01-06 00:20:17 -0800 | [diff] [blame] | 242 | struct page *spare_page; /* Used when checking P/Q in raid6 */ |
| 243 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | /* |
| 245 | * Free stripes pool |
| 246 | */ |
| 247 | atomic_t active_stripes; |
| 248 | struct list_head inactive_list; |
| 249 | wait_queue_head_t wait_for_stripe; |
| 250 | wait_queue_head_t wait_for_overlap; |
| 251 | int inactive_blocked; /* release of inactive stripes blocked, |
| 252 | * waiting for 25% to be free |
NeilBrown | ad01c9e | 2006-03-27 01:18:07 -0800 | [diff] [blame] | 253 | */ |
| 254 | int pool_size; /* number of disks in stripeheads in pool */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | spinlock_t device_lock; |
NeilBrown | b55e6bf | 2006-03-27 01:18:06 -0800 | [diff] [blame] | 256 | struct disk_info *disks; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | }; |
| 258 | |
| 259 | typedef struct raid5_private_data raid5_conf_t; |
| 260 | |
| 261 | #define mddev_to_conf(mddev) ((raid5_conf_t *) mddev->private) |
| 262 | |
| 263 | /* |
| 264 | * Our supported algorithms |
| 265 | */ |
| 266 | #define ALGORITHM_LEFT_ASYMMETRIC 0 |
| 267 | #define ALGORITHM_RIGHT_ASYMMETRIC 1 |
| 268 | #define ALGORITHM_LEFT_SYMMETRIC 2 |
| 269 | #define ALGORITHM_RIGHT_SYMMETRIC 3 |
| 270 | |
| 271 | #endif |