md_k.h 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372
  1. /*
  2. md_k.h : kernel internal structure of the Linux MD driver
  3. Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
  4. This program is free software; you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation; either version 2, or (at your option)
  7. any later version.
  8. You should have received a copy of the GNU General Public License
  9. (for example /usr/src/linux/COPYING); if not, write to the Free
  10. Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  11. */
  12. #ifndef _MD_K_H
  13. #define _MD_K_H
  14. /* and dm-bio-list.h is not under include/linux because.... ??? */
  15. #include "../../../drivers/md/dm-bio-list.h"
  16. #define MD_RESERVED 0UL
  17. #define LINEAR 1UL
  18. #define RAID0 2UL
  19. #define RAID1 3UL
  20. #define RAID5 4UL
  21. #define TRANSLUCENT 5UL
  22. #define HSM 6UL
  23. #define MULTIPATH 7UL
  24. #define RAID6 8UL
  25. #define RAID10 9UL
  26. #define FAULTY 10UL
  27. #define MAX_PERSONALITY 11UL
  28. #define LEVEL_MULTIPATH (-4)
  29. #define LEVEL_LINEAR (-1)
  30. #define LEVEL_FAULTY (-5)
  31. #define MaxSector (~(sector_t)0)
  32. #define MD_THREAD_NAME_MAX 14
  33. static inline int pers_to_level (int pers)
  34. {
  35. switch (pers) {
  36. case FAULTY: return LEVEL_FAULTY;
  37. case MULTIPATH: return LEVEL_MULTIPATH;
  38. case HSM: return -3;
  39. case TRANSLUCENT: return -2;
  40. case LINEAR: return LEVEL_LINEAR;
  41. case RAID0: return 0;
  42. case RAID1: return 1;
  43. case RAID5: return 5;
  44. case RAID6: return 6;
  45. case RAID10: return 10;
  46. }
  47. BUG();
  48. return MD_RESERVED;
  49. }
  50. static inline int level_to_pers (int level)
  51. {
  52. switch (level) {
  53. case LEVEL_FAULTY: return FAULTY;
  54. case LEVEL_MULTIPATH: return MULTIPATH;
  55. case -3: return HSM;
  56. case -2: return TRANSLUCENT;
  57. case LEVEL_LINEAR: return LINEAR;
  58. case 0: return RAID0;
  59. case 1: return RAID1;
  60. case 4:
  61. case 5: return RAID5;
  62. case 6: return RAID6;
  63. case 10: return RAID10;
  64. }
  65. return MD_RESERVED;
  66. }
  67. typedef struct mddev_s mddev_t;
  68. typedef struct mdk_rdev_s mdk_rdev_t;
  69. #define MAX_MD_DEVS 256 /* Max number of md dev */
  70. /*
  71. * options passed in raidrun:
  72. */
  73. #define MAX_CHUNK_SIZE (4096*1024)
  74. /*
  75. * MD's 'extended' device
  76. */
  77. struct mdk_rdev_s
  78. {
  79. struct list_head same_set; /* RAID devices within the same set */
  80. sector_t size; /* Device size (in blocks) */
  81. mddev_t *mddev; /* RAID array if running */
  82. unsigned long last_events; /* IO event timestamp */
  83. struct block_device *bdev; /* block device handle */
  84. struct page *sb_page;
  85. int sb_loaded;
  86. sector_t data_offset; /* start of data in array */
  87. sector_t sb_offset;
  88. int sb_size; /* bytes in the superblock */
  89. int preferred_minor; /* autorun support */
  90. struct kobject kobj;
  91. /* A device can be in one of three states based on two flags:
  92. * Not working: faulty==1 in_sync==0
  93. * Fully working: faulty==0 in_sync==1
  94. * Working, but not
  95. * in sync with array
  96. * faulty==0 in_sync==0
  97. *
  98. * It can never have faulty==1, in_sync==1
  99. * This reduces the burden of testing multiple flags in many cases
  100. */
  101. unsigned long flags;
  102. #define Faulty 1 /* device is known to have a fault */
  103. #define In_sync 2 /* device is in_sync with rest of array */
  104. #define WriteMostly 4 /* Avoid reading if at all possible */
  105. #define BarriersNotsupp 5 /* BIO_RW_BARRIER is not supported */
  106. int desc_nr; /* descriptor index in the superblock */
  107. int raid_disk; /* role of device in array */
  108. int saved_raid_disk; /* role that device used to have in the
  109. * array and could again if we did a partial
  110. * resync from the bitmap
  111. */
  112. atomic_t nr_pending; /* number of pending requests.
  113. * only maintained for arrays that
  114. * support hot removal
  115. */
  116. atomic_t read_errors; /* number of consecutive read errors that
  117. * we have tried to ignore.
  118. */
  119. };
  120. typedef struct mdk_personality_s mdk_personality_t;
  121. struct mddev_s
  122. {
  123. void *private;
  124. mdk_personality_t *pers;
  125. dev_t unit;
  126. int md_minor;
  127. struct list_head disks;
  128. int sb_dirty;
  129. int ro;
  130. struct gendisk *gendisk;
  131. struct kobject kobj;
  132. /* Superblock information */
  133. int major_version,
  134. minor_version,
  135. patch_version;
  136. int persistent;
  137. int chunk_size;
  138. time_t ctime, utime;
  139. int level, layout;
  140. int raid_disks;
  141. int max_disks;
  142. sector_t size; /* used size of component devices */
  143. sector_t array_size; /* exported array size */
  144. __u64 events;
  145. char uuid[16];
  146. struct mdk_thread_s *thread; /* management thread */
  147. struct mdk_thread_s *sync_thread; /* doing resync or reconstruct */
  148. sector_t curr_resync; /* blocks scheduled */
  149. unsigned long resync_mark; /* a recent timestamp */
  150. sector_t resync_mark_cnt;/* blocks written at resync_mark */
  151. sector_t resync_max_sectors; /* may be set by personality */
  152. sector_t resync_mismatches; /* count of sectors where
  153. * parity/replica mismatch found
  154. */
  155. /* recovery/resync flags
  156. * NEEDED: we might need to start a resync/recover
  157. * RUNNING: a thread is running, or about to be started
  158. * SYNC: actually doing a resync, not a recovery
  159. * ERR: and IO error was detected - abort the resync/recovery
  160. * INTR: someone requested a (clean) early abort.
  161. * DONE: thread is done and is waiting to be reaped
  162. * REQUEST: user-space has requested a sync (used with SYNC)
  163. * CHECK: user-space request for for check-only, no repair
  164. */
  165. #define MD_RECOVERY_RUNNING 0
  166. #define MD_RECOVERY_SYNC 1
  167. #define MD_RECOVERY_ERR 2
  168. #define MD_RECOVERY_INTR 3
  169. #define MD_RECOVERY_DONE 4
  170. #define MD_RECOVERY_NEEDED 5
  171. #define MD_RECOVERY_REQUESTED 6
  172. #define MD_RECOVERY_CHECK 7
  173. unsigned long recovery;
  174. int in_sync; /* know to not need resync */
  175. struct semaphore reconfig_sem;
  176. atomic_t active;
  177. int changed; /* true if we might need to reread partition info */
  178. int degraded; /* whether md should consider
  179. * adding a spare
  180. */
  181. int barriers_work; /* initialised to true, cleared as soon
  182. * as a barrier request to slave
  183. * fails. Only supported
  184. */
  185. struct bio *biolist; /* bios that need to be retried
  186. * because BIO_RW_BARRIER is not supported
  187. */
  188. atomic_t recovery_active; /* blocks scheduled, but not written */
  189. wait_queue_head_t recovery_wait;
  190. sector_t recovery_cp;
  191. spinlock_t write_lock;
  192. wait_queue_head_t sb_wait; /* for waiting on superblock updates */
  193. atomic_t pending_writes; /* number of active superblock writes */
  194. unsigned int safemode; /* if set, update "clean" superblock
  195. * when no writes pending.
  196. */
  197. unsigned int safemode_delay;
  198. struct timer_list safemode_timer;
  199. atomic_t writes_pending;
  200. request_queue_t *queue; /* for plugging ... */
  201. atomic_t write_behind; /* outstanding async IO */
  202. unsigned int max_write_behind; /* 0 = sync */
  203. struct bitmap *bitmap; /* the bitmap for the device */
  204. struct file *bitmap_file; /* the bitmap file */
  205. long bitmap_offset; /* offset from superblock of
  206. * start of bitmap. May be
  207. * negative, but not '0'
  208. */
  209. long default_bitmap_offset; /* this is the offset to use when
  210. * hot-adding a bitmap. It should
  211. * eventually be settable by sysfs.
  212. */
  213. struct list_head all_mddevs;
  214. };
  215. static inline void rdev_dec_pending(mdk_rdev_t *rdev, mddev_t *mddev)
  216. {
  217. int faulty = test_bit(Faulty, &rdev->flags);
  218. if (atomic_dec_and_test(&rdev->nr_pending) && faulty)
  219. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  220. }
  221. static inline void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors)
  222. {
  223. atomic_add(nr_sectors, &bdev->bd_contains->bd_disk->sync_io);
  224. }
  225. struct mdk_personality_s
  226. {
  227. char *name;
  228. struct module *owner;
  229. int (*make_request)(request_queue_t *q, struct bio *bio);
  230. int (*run)(mddev_t *mddev);
  231. int (*stop)(mddev_t *mddev);
  232. void (*status)(struct seq_file *seq, mddev_t *mddev);
  233. /* error_handler must set ->faulty and clear ->in_sync
  234. * if appropriate, and should abort recovery if needed
  235. */
  236. void (*error_handler)(mddev_t *mddev, mdk_rdev_t *rdev);
  237. int (*hot_add_disk) (mddev_t *mddev, mdk_rdev_t *rdev);
  238. int (*hot_remove_disk) (mddev_t *mddev, int number);
  239. int (*spare_active) (mddev_t *mddev);
  240. sector_t (*sync_request)(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster);
  241. int (*resize) (mddev_t *mddev, sector_t sectors);
  242. int (*reshape) (mddev_t *mddev, int raid_disks);
  243. int (*reconfig) (mddev_t *mddev, int layout, int chunk_size);
  244. /* quiesce moves between quiescence states
  245. * 0 - fully active
  246. * 1 - no new requests allowed
  247. * others - reserved
  248. */
  249. void (*quiesce) (mddev_t *mddev, int state);
  250. };
  251. struct md_sysfs_entry {
  252. struct attribute attr;
  253. ssize_t (*show)(mddev_t *, char *);
  254. ssize_t (*store)(mddev_t *, const char *, size_t);
  255. };
  256. static inline char * mdname (mddev_t * mddev)
  257. {
  258. return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
  259. }
  260. extern mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr);
  261. /*
  262. * iterates through some rdev ringlist. It's safe to remove the
  263. * current 'rdev'. Dont touch 'tmp' though.
  264. */
  265. #define ITERATE_RDEV_GENERIC(head,rdev,tmp) \
  266. \
  267. for ((tmp) = (head).next; \
  268. (rdev) = (list_entry((tmp), mdk_rdev_t, same_set)), \
  269. (tmp) = (tmp)->next, (tmp)->prev != &(head) \
  270. ; )
  271. /*
  272. * iterates through the 'same array disks' ringlist
  273. */
  274. #define ITERATE_RDEV(mddev,rdev,tmp) \
  275. ITERATE_RDEV_GENERIC((mddev)->disks,rdev,tmp)
  276. /*
  277. * Iterates through 'pending RAID disks'
  278. */
  279. #define ITERATE_RDEV_PENDING(rdev,tmp) \
  280. ITERATE_RDEV_GENERIC(pending_raid_disks,rdev,tmp)
  281. typedef struct mdk_thread_s {
  282. void (*run) (mddev_t *mddev);
  283. mddev_t *mddev;
  284. wait_queue_head_t wqueue;
  285. unsigned long flags;
  286. struct completion *event;
  287. struct task_struct *tsk;
  288. unsigned long timeout;
  289. const char *name;
  290. } mdk_thread_t;
  291. #define THREAD_WAKEUP 0
  292. #define __wait_event_lock_irq(wq, condition, lock, cmd) \
  293. do { \
  294. wait_queue_t __wait; \
  295. init_waitqueue_entry(&__wait, current); \
  296. \
  297. add_wait_queue(&wq, &__wait); \
  298. for (;;) { \
  299. set_current_state(TASK_UNINTERRUPTIBLE); \
  300. if (condition) \
  301. break; \
  302. spin_unlock_irq(&lock); \
  303. cmd; \
  304. schedule(); \
  305. spin_lock_irq(&lock); \
  306. } \
  307. current->state = TASK_RUNNING; \
  308. remove_wait_queue(&wq, &__wait); \
  309. } while (0)
  310. #define wait_event_lock_irq(wq, condition, lock, cmd) \
  311. do { \
  312. if (condition) \
  313. break; \
  314. __wait_event_lock_irq(wq, condition, lock, cmd); \
  315. } while (0)
  316. #endif