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