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