raid5.h 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371
  1. #ifndef _RAID5_H
  2. #define _RAID5_H
  3. #include <linux/raid/md.h>
  4. #include <linux/raid/xor.h>
  5. /*
  6. *
  7. * Each stripe contains one buffer per disc. Each buffer can be in
  8. * one of a number of states stored in "flags". Changes between
  9. * these states happen *almost* exclusively under a per-stripe
  10. * spinlock. Some very specific changes can happen in bi_end_io, and
  11. * these are not protected by the spin lock.
  12. *
  13. * The flag bits that are used to represent these states are:
  14. * R5_UPTODATE and R5_LOCKED
  15. *
  16. * State Empty == !UPTODATE, !LOCK
  17. * We have no data, and there is no active request
  18. * State Want == !UPTODATE, LOCK
  19. * A read request is being submitted for this block
  20. * State Dirty == UPTODATE, LOCK
  21. * Some new data is in this buffer, and it is being written out
  22. * State Clean == UPTODATE, !LOCK
  23. * We have valid data which is the same as on disc
  24. *
  25. * The possible state transitions are:
  26. *
  27. * Empty -> Want - on read or write to get old data for parity calc
  28. * Empty -> Dirty - on compute_parity to satisfy write/sync request.(RECONSTRUCT_WRITE)
  29. * Empty -> Clean - on compute_block when computing a block for failed drive
  30. * Want -> Empty - on failed read
  31. * Want -> Clean - on successful completion of read request
  32. * Dirty -> Clean - on successful completion of write request
  33. * Dirty -> Clean - on failed write
  34. * Clean -> Dirty - on compute_parity to satisfy write/sync (RECONSTRUCT or RMW)
  35. *
  36. * The Want->Empty, Want->Clean, Dirty->Clean, transitions
  37. * all happen in b_end_io at interrupt time.
  38. * Each sets the Uptodate bit before releasing the Lock bit.
  39. * This leaves one multi-stage transition:
  40. * Want->Dirty->Clean
  41. * This is safe because thinking that a Clean buffer is actually dirty
  42. * will at worst delay some action, and the stripe will be scheduled
  43. * for attention after the transition is complete.
  44. *
  45. * There is one possibility that is not covered by these states. That
  46. * is if one drive has failed and there is a spare being rebuilt. We
  47. * can't distinguish between a clean block that has been generated
  48. * from parity calculations, and a clean block that has been
  49. * successfully written to the spare ( or to parity when resyncing).
  50. * To distingush these states we have a stripe bit STRIPE_INSYNC that
  51. * is set whenever a write is scheduled to the spare, or to the parity
  52. * disc if there is no spare. A sync request clears this bit, and
  53. * when we find it set with no buffers locked, we know the sync is
  54. * complete.
  55. *
  56. * Buffers for the md device that arrive via make_request are attached
  57. * to the appropriate stripe in one of two lists linked on b_reqnext.
  58. * One list (bh_read) for read requests, one (bh_write) for write.
  59. * There should never be more than one buffer on the two lists
  60. * together, but we are not guaranteed of that so we allow for more.
  61. *
  62. * If a buffer is on the read list when the associated cache buffer is
  63. * Uptodate, the data is copied into the read buffer and it's b_end_io
  64. * routine is called. This may happen in the end_request routine only
  65. * if the buffer has just successfully been read. end_request should
  66. * remove the buffers from the list and then set the Uptodate bit on
  67. * the buffer. Other threads may do this only if they first check
  68. * that the Uptodate bit is set. Once they have checked that they may
  69. * take buffers off the read queue.
  70. *
  71. * When a buffer on the write list is committed for write it is copied
  72. * into the cache buffer, which is then marked dirty, and moved onto a
  73. * third list, the written list (bh_written). Once both the parity
  74. * block and the cached buffer are successfully written, any buffer on
  75. * a written list can be returned with b_end_io.
  76. *
  77. * The write list and read list both act as fifos. The read list is
  78. * protected by the device_lock. The write and written lists are
  79. * protected by the stripe lock. The device_lock, which can be
  80. * claimed while the stipe lock is held, is only for list
  81. * manipulations and will only be held for a very short time. It can
  82. * be claimed from interrupts.
  83. *
  84. *
  85. * Stripes in the stripe cache can be on one of two lists (or on
  86. * neither). The "inactive_list" contains stripes which are not
  87. * currently being used for any request. They can freely be reused
  88. * for another stripe. The "handle_list" contains stripes that need
  89. * to be handled in some way. Both of these are fifo queues. Each
  90. * stripe is also (potentially) linked to a hash bucket in the hash
  91. * table so that it can be found by sector number. Stripes that are
  92. * not hashed must be on the inactive_list, and will normally be at
  93. * the front. All stripes start life this way.
  94. *
  95. * The inactive_list, handle_list and hash bucket lists are all protected by the
  96. * device_lock.
  97. * - stripes on the inactive_list never have their stripe_lock held.
  98. * - stripes have a reference counter. If count==0, they are on a list.
  99. * - If a stripe might need handling, STRIPE_HANDLE is set.
  100. * - When refcount reaches zero, then if STRIPE_HANDLE it is put on
  101. * handle_list else inactive_list
  102. *
  103. * This, combined with the fact that STRIPE_HANDLE is only ever
  104. * cleared while a stripe has a non-zero count means that if the
  105. * refcount is 0 and STRIPE_HANDLE is set, then it is on the
  106. * handle_list and if recount is 0 and STRIPE_HANDLE is not set, then
  107. * the stripe is on inactive_list.
  108. *
  109. * The possible transitions are:
  110. * activate an unhashed/inactive stripe (get_active_stripe())
  111. * lockdev check-hash unlink-stripe cnt++ clean-stripe hash-stripe unlockdev
  112. * activate a hashed, possibly active stripe (get_active_stripe())
  113. * lockdev check-hash if(!cnt++)unlink-stripe unlockdev
  114. * attach a request to an active stripe (add_stripe_bh())
  115. * lockdev attach-buffer unlockdev
  116. * handle a stripe (handle_stripe())
  117. * lockstripe clrSTRIPE_HANDLE ...
  118. * (lockdev check-buffers unlockdev) ..
  119. * change-state ..
  120. * record io/ops needed unlockstripe schedule io/ops
  121. * release an active stripe (release_stripe())
  122. * lockdev if (!--cnt) { if STRIPE_HANDLE, add to handle_list else add to inactive-list } unlockdev
  123. *
  124. * The refcount counts each thread that have activated the stripe,
  125. * plus raid5d if it is handling it, plus one for each active request
  126. * on a cached buffer, and plus one if the stripe is undergoing stripe
  127. * operations.
  128. *
  129. * Stripe operations are performed outside the stripe lock,
  130. * the stripe operations are:
  131. * -copying data between the stripe cache and user application buffers
  132. * -computing blocks to save a disk access, or to recover a missing block
  133. * -updating the parity on a write operation (reconstruct write and
  134. * read-modify-write)
  135. * -checking parity correctness
  136. * -running i/o to disk
  137. * These operations are carried out by raid5_run_ops which uses the async_tx
  138. * api to (optionally) offload operations to dedicated hardware engines.
  139. * When requesting an operation handle_stripe sets the pending bit for the
  140. * operation and increments the count. raid5_run_ops is then run whenever
  141. * the count is non-zero.
  142. * There are some critical dependencies between the operations that prevent some
  143. * from being requested while another is in flight.
  144. * 1/ Parity check operations destroy the in cache version of the parity block,
  145. * so we prevent parity dependent operations like writes and compute_blocks
  146. * from starting while a check is in progress. Some dma engines can perform
  147. * the check without damaging the parity block, in these cases the parity
  148. * block is re-marked up to date (assuming the check was successful) and is
  149. * not re-read from disk.
  150. * 2/ When a write operation is requested we immediately lock the affected
  151. * blocks, and mark them as not up to date. This causes new read requests
  152. * to be held off, as well as parity checks and compute block operations.
  153. * 3/ Once a compute block operation has been requested handle_stripe treats
  154. * that block as if it is up to date. raid5_run_ops guaruntees that any
  155. * operation that is dependent on the compute block result is initiated after
  156. * the compute block completes.
  157. */
  158. struct stripe_head {
  159. struct hlist_node hash;
  160. struct list_head lru; /* inactive_list or handle_list */
  161. struct raid5_private_data *raid_conf;
  162. sector_t sector; /* sector of this row */
  163. int pd_idx; /* parity disk index */
  164. unsigned long state; /* state flags */
  165. atomic_t count; /* nr of active thread/requests */
  166. spinlock_t lock;
  167. int bm_seq; /* sequence number for bitmap flushes */
  168. int disks; /* disks in stripe */
  169. /* stripe_operations
  170. * @pending - pending ops flags (set for request->issue->complete)
  171. * @ack - submitted ops flags (set for issue->complete)
  172. * @complete - completed ops flags (set for complete)
  173. * @target - STRIPE_OP_COMPUTE_BLK target
  174. * @count - raid5_runs_ops is set to run when this is non-zero
  175. */
  176. struct stripe_operations {
  177. unsigned long pending;
  178. unsigned long ack;
  179. unsigned long complete;
  180. int target;
  181. int count;
  182. u32 zero_sum_result;
  183. } ops;
  184. struct r5dev {
  185. struct bio req;
  186. struct bio_vec vec;
  187. struct page *page;
  188. struct bio *toread, *read, *towrite, *written;
  189. sector_t sector; /* sector of this page */
  190. unsigned long flags;
  191. } dev[1]; /* allocated with extra space depending of RAID geometry */
  192. };
  193. /* stripe_head_state - collects and tracks the dynamic state of a stripe_head
  194. * for handle_stripe. It is only valid under spin_lock(sh->lock);
  195. */
  196. struct stripe_head_state {
  197. int syncing, expanding, expanded;
  198. int locked, uptodate, to_read, to_write, failed, written;
  199. int to_fill, compute, req_compute, non_overwrite;
  200. int failed_num;
  201. };
  202. /* r6_state - extra state data only relevant to r6 */
  203. struct r6_state {
  204. int p_failed, q_failed, qd_idx, failed_num[2];
  205. };
  206. /* Flags */
  207. #define R5_UPTODATE 0 /* page contains current data */
  208. #define R5_LOCKED 1 /* IO has been submitted on "req" */
  209. #define R5_OVERWRITE 2 /* towrite covers whole page */
  210. /* and some that are internal to handle_stripe */
  211. #define R5_Insync 3 /* rdev && rdev->in_sync at start */
  212. #define R5_Wantread 4 /* want to schedule a read */
  213. #define R5_Wantwrite 5
  214. #define R5_Overlap 7 /* There is a pending overlapping request on this block */
  215. #define R5_ReadError 8 /* seen a read error here recently */
  216. #define R5_ReWrite 9 /* have tried to over-write the readerror */
  217. #define R5_Expanded 10 /* This block now has post-expand data */
  218. #define R5_Wantcompute 11 /* compute_block in progress treat as
  219. * uptodate
  220. */
  221. #define R5_Wantfill 12 /* dev->toread contains a bio that needs
  222. * filling
  223. */
  224. #define R5_Wantprexor 13 /* distinguish blocks ready for rmw from
  225. * other "towrites"
  226. */
  227. /*
  228. * Write method
  229. */
  230. #define RECONSTRUCT_WRITE 1
  231. #define READ_MODIFY_WRITE 2
  232. /* not a write method, but a compute_parity mode */
  233. #define CHECK_PARITY 3
  234. /*
  235. * Stripe state
  236. */
  237. #define STRIPE_HANDLE 2
  238. #define STRIPE_SYNCING 3
  239. #define STRIPE_INSYNC 4
  240. #define STRIPE_PREREAD_ACTIVE 5
  241. #define STRIPE_DELAYED 6
  242. #define STRIPE_DEGRADED 7
  243. #define STRIPE_BIT_DELAY 8
  244. #define STRIPE_EXPANDING 9
  245. #define STRIPE_EXPAND_SOURCE 10
  246. #define STRIPE_EXPAND_READY 11
  247. /*
  248. * Operations flags (in issue order)
  249. */
  250. #define STRIPE_OP_BIOFILL 0
  251. #define STRIPE_OP_COMPUTE_BLK 1
  252. #define STRIPE_OP_PREXOR 2
  253. #define STRIPE_OP_BIODRAIN 3
  254. #define STRIPE_OP_POSTXOR 4
  255. #define STRIPE_OP_CHECK 5
  256. #define STRIPE_OP_IO 6
  257. /* modifiers to the base operations
  258. * STRIPE_OP_MOD_REPAIR_PD - compute the parity block and write it back
  259. * STRIPE_OP_MOD_DMA_CHECK - parity is not corrupted by the check
  260. */
  261. #define STRIPE_OP_MOD_REPAIR_PD 7
  262. #define STRIPE_OP_MOD_DMA_CHECK 8
  263. /*
  264. * Plugging:
  265. *
  266. * To improve write throughput, we need to delay the handling of some
  267. * stripes until there has been a chance that several write requests
  268. * for the one stripe have all been collected.
  269. * In particular, any write request that would require pre-reading
  270. * is put on a "delayed" queue until there are no stripes currently
  271. * in a pre-read phase. Further, if the "delayed" queue is empty when
  272. * a stripe is put on it then we "plug" the queue and do not process it
  273. * until an unplug call is made. (the unplug_io_fn() is called).
  274. *
  275. * When preread is initiated on a stripe, we set PREREAD_ACTIVE and add
  276. * it to the count of prereading stripes.
  277. * When write is initiated, or the stripe refcnt == 0 (just in case) we
  278. * clear the PREREAD_ACTIVE flag and decrement the count
  279. * Whenever the 'handle' queue is empty and the device is not plugged, we
  280. * move any strips from delayed to handle and clear the DELAYED flag and set
  281. * PREREAD_ACTIVE.
  282. * In stripe_handle, if we find pre-reading is necessary, we do it if
  283. * PREREAD_ACTIVE is set, else we set DELAYED which will send it to the delayed queue.
  284. * HANDLE gets cleared if stripe_handle leave nothing locked.
  285. */
  286. struct disk_info {
  287. mdk_rdev_t *rdev;
  288. };
  289. struct raid5_private_data {
  290. struct hlist_head *stripe_hashtbl;
  291. mddev_t *mddev;
  292. struct disk_info *spare;
  293. int chunk_size, level, algorithm;
  294. int max_degraded;
  295. int raid_disks;
  296. int max_nr_stripes;
  297. /* used during an expand */
  298. sector_t expand_progress; /* MaxSector when no expand happening */
  299. sector_t expand_lo; /* from here up to expand_progress it out-of-bounds
  300. * as we haven't flushed the metadata yet
  301. */
  302. int previous_raid_disks;
  303. struct list_head handle_list; /* stripes needing handling */
  304. struct list_head delayed_list; /* stripes that have plugged requests */
  305. struct list_head bitmap_list; /* stripes delaying awaiting bitmap update */
  306. struct bio *retry_read_aligned; /* currently retrying aligned bios */
  307. struct bio *retry_read_aligned_list; /* aligned bios retry list */
  308. atomic_t preread_active_stripes; /* stripes with scheduled io */
  309. atomic_t active_aligned_reads;
  310. atomic_t reshape_stripes; /* stripes with pending writes for reshape */
  311. /* unfortunately we need two cache names as we temporarily have
  312. * two caches.
  313. */
  314. int active_name;
  315. char cache_name[2][20];
  316. struct kmem_cache *slab_cache; /* for allocating stripes */
  317. int seq_flush, seq_write;
  318. int quiesce;
  319. int fullsync; /* set to 1 if a full sync is needed,
  320. * (fresh device added).
  321. * Cleared when a sync completes.
  322. */
  323. struct page *spare_page; /* Used when checking P/Q in raid6 */
  324. /*
  325. * Free stripes pool
  326. */
  327. atomic_t active_stripes;
  328. struct list_head inactive_list;
  329. wait_queue_head_t wait_for_stripe;
  330. wait_queue_head_t wait_for_overlap;
  331. int inactive_blocked; /* release of inactive stripes blocked,
  332. * waiting for 25% to be free
  333. */
  334. int pool_size; /* number of disks in stripeheads in pool */
  335. spinlock_t device_lock;
  336. struct disk_info *disks;
  337. };
  338. typedef struct raid5_private_data raid5_conf_t;
  339. #define mddev_to_conf(mddev) ((raid5_conf_t *) mddev->private)
  340. /*
  341. * Our supported algorithms
  342. */
  343. #define ALGORITHM_LEFT_ASYMMETRIC 0
  344. #define ALGORITHM_RIGHT_ASYMMETRIC 1
  345. #define ALGORITHM_LEFT_SYMMETRIC 2
  346. #define ALGORITHM_RIGHT_SYMMETRIC 3
  347. #endif