]> git.proxmox.com Git - mirror_ubuntu-kernels.git/blame - include/linux/raid/md_k.h
Merge branches 'release', 'ejd', 'sony' and 'wmi' into release
[mirror_ubuntu-kernels.git] / include / linux / raid / md_k.h
CommitLineData
1da177e4
LT
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
06d91a5f
N
18/* and dm-bio-list.h is not under include/linux because.... ??? */
19#include "../../../drivers/md/dm-bio-list.h"
20
9361401e
DH
21#ifdef CONFIG_BLOCK
22
1da177e4
LT
23#define LEVEL_MULTIPATH (-4)
24#define LEVEL_LINEAR (-1)
25#define LEVEL_FAULTY (-5)
26
2604b703
N
27/* we need a value for 'no level specified' and 0
28 * means 'raid0', so we need something else. This is
29 * for internal use only
30 */
31#define LEVEL_NONE (-1000000)
32
1da177e4 33#define MaxSector (~(sector_t)0)
1da177e4 34
1da177e4
LT
35typedef struct mddev_s mddev_t;
36typedef struct mdk_rdev_s mdk_rdev_t;
37
1da177e4
LT
38/*
39 * options passed in raidrun:
40 */
41
e8703fe1 42/* Currently this must fit in an 'int' */
8932c2e0 43#define MAX_CHUNK_SIZE (1<<30)
1da177e4 44
1da177e4
LT
45/*
46 * MD's 'extended' device
47 */
48struct 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 */
713f6ab1 54 long last_events; /* IO event timestamp */
1da177e4
LT
55
56 struct block_device *bdev; /* block device handle */
57
58 struct page *sb_page;
59 int sb_loaded;
42543769 60 __u64 sb_events;
1da177e4
LT
61 sector_t data_offset; /* start of data in array */
62 sector_t sb_offset;
0002b271 63 int sb_size; /* bytes in the superblock */
1da177e4
LT
64 int preferred_minor; /* autorun support */
65
86e6ffdd
N
66 struct kobject kobj;
67
1da177e4
LT
68 /* A device can be in one of three states based on two flags:
69 * Not working: faulty==1 in_sync==0
70 * Fully working: faulty==0 in_sync==1
71 * Working, but not
72 * in sync with array
73 * faulty==0 in_sync==0
74 *
75 * It can never have faulty==1, in_sync==1
76 * This reduces the burden of testing multiple flags in many cases
77 */
1da177e4 78
b2d444d7
N
79 unsigned long flags;
80#define Faulty 1 /* device is known to have a fault */
81#define In_sync 2 /* device is in_sync with rest of array */
8ddf9efe 82#define WriteMostly 4 /* Avoid reading if at all possible */
a9701a30 83#define BarriersNotsupp 5 /* BIO_RW_BARRIER is not supported */
c5d79adb
N
84#define AllReserved 6 /* If whole device is reserved for
85 * one array */
d0fae18f 86#define AutoDetected 7 /* added by auto-detect */
8ddf9efe 87
1da177e4
LT
88 int desc_nr; /* descriptor index in the superblock */
89 int raid_disk; /* role of device in array */
41158c7e
N
90 int saved_raid_disk; /* role that device used to have in the
91 * array and could again if we did a partial
92 * resync from the bitmap
93 */
5fd6c1dc
N
94 sector_t recovery_offset;/* If this device has been partially
95 * recovered, this is where we were
96 * up to.
97 */
1da177e4
LT
98
99 atomic_t nr_pending; /* number of pending requests.
100 * only maintained for arrays that
101 * support hot removal
102 */
ba22dcbf
N
103 atomic_t read_errors; /* number of consecutive read errors that
104 * we have tried to ignore.
105 */
4dbcdc75
N
106 atomic_t corrected_errors; /* number of corrected read errors,
107 * for reporting to userspace and storing
108 * in superblock.
109 */
5792a285 110 struct work_struct del_work; /* used for delayed sysfs removal */
1da177e4
LT
111};
112
1da177e4
LT
113struct mddev_s
114{
115 void *private;
2604b703 116 struct mdk_personality *pers;
1da177e4
LT
117 dev_t unit;
118 int md_minor;
119 struct list_head disks;
850b2b42
N
120 unsigned long flags;
121#define MD_CHANGE_DEVS 0 /* Some device status has changed */
122#define MD_CHANGE_CLEAN 1 /* transition to or from 'clean' */
123#define MD_CHANGE_PENDING 2 /* superblock update in progress */
124
1da177e4
LT
125 int ro;
126
127 struct gendisk *gendisk;
128
eae1701f
N
129 struct kobject kobj;
130
1da177e4
LT
131 /* Superblock information */
132 int major_version,
133 minor_version,
134 patch_version;
135 int persistent;
e691063a
N
136 int external; /* metadata is
137 * managed externally */
138 char metadata_type[17]; /* externally set*/
1da177e4
LT
139 int chunk_size;
140 time_t ctime, utime;
141 int level, layout;
d9d166c2 142 char clevel[16];
1da177e4
LT
143 int raid_disks;
144 int max_disks;
145 sector_t size; /* used size of component devices */
146 sector_t array_size; /* exported array size */
147 __u64 events;
148
149 char uuid[16];
150
f6705578
N
151 /* If the array is being reshaped, we need to record the
152 * new shape and an indication of where we are up to.
153 * This is written to the superblock.
154 * If reshape_position is MaxSector, then no reshape is happening (yet).
155 */
156 sector_t reshape_position;
157 int delta_disks, new_level, new_layout, new_chunk;
158
1da177e4
LT
159 struct mdk_thread_s *thread; /* management thread */
160 struct mdk_thread_s *sync_thread; /* doing resync or reconstruct */
ff4e8d9a 161 sector_t curr_resync; /* last block scheduled */
1da177e4
LT
162 unsigned long resync_mark; /* a recent timestamp */
163 sector_t resync_mark_cnt;/* blocks written at resync_mark */
ff4e8d9a 164 sector_t curr_mark_cnt; /* blocks scheduled now */
1da177e4
LT
165
166 sector_t resync_max_sectors; /* may be set by personality */
9d88883e
N
167
168 sector_t resync_mismatches; /* count of sectors where
169 * parity/replica mismatch found
170 */
e464eafd
N
171
172 /* allow user-space to request suspension of IO to regions of the array */
173 sector_t suspend_lo;
174 sector_t suspend_hi;
88202a0c
N
175 /* if zero, use the system-wide default */
176 int sync_speed_min;
177 int sync_speed_max;
178
6ff8d8ec 179 int ok_start_degraded;
1da177e4
LT
180 /* recovery/resync flags
181 * NEEDED: we might need to start a resync/recover
182 * RUNNING: a thread is running, or about to be started
183 * SYNC: actually doing a resync, not a recovery
184 * ERR: and IO error was detected - abort the resync/recovery
185 * INTR: someone requested a (clean) early abort.
186 * DONE: thread is done and is waiting to be reaped
24dd469d
N
187 * REQUEST: user-space has requested a sync (used with SYNC)
188 * CHECK: user-space request for for check-only, no repair
ccfcc3c1
N
189 * RESHAPE: A reshape is happening
190 *
191 * If neither SYNC or RESHAPE are set, then it is a recovery.
1da177e4
LT
192 */
193#define MD_RECOVERY_RUNNING 0
194#define MD_RECOVERY_SYNC 1
195#define MD_RECOVERY_ERR 2
196#define MD_RECOVERY_INTR 3
197#define MD_RECOVERY_DONE 4
198#define MD_RECOVERY_NEEDED 5
24dd469d
N
199#define MD_RECOVERY_REQUESTED 6
200#define MD_RECOVERY_CHECK 7
ccfcc3c1 201#define MD_RECOVERY_RESHAPE 8
5fd6c1dc
N
202#define MD_RECOVERY_FROZEN 9
203
1da177e4
LT
204 unsigned long recovery;
205
206 int in_sync; /* know to not need resync */
df5b89b3 207 struct mutex reconfig_mutex;
1da177e4
LT
208 atomic_t active;
209
44ce6294 210 int changed; /* true if we might need to reread partition info */
1da177e4
LT
211 int degraded; /* whether md should consider
212 * adding a spare
213 */
a9701a30
N
214 int barriers_work; /* initialised to true, cleared as soon
215 * as a barrier request to slave
216 * fails. Only supported
217 */
218 struct bio *biolist; /* bios that need to be retried
219 * because BIO_RW_BARRIER is not supported
220 */
1da177e4
LT
221
222 atomic_t recovery_active; /* blocks scheduled, but not written */
223 wait_queue_head_t recovery_wait;
224 sector_t recovery_cp;
c6207277
N
225 sector_t resync_max; /* resync should pause
226 * when it gets here */
06d91a5f
N
227
228 spinlock_t write_lock;
3d310eb7 229 wait_queue_head_t sb_wait; /* for waiting on superblock updates */
7bfa19f2 230 atomic_t pending_writes; /* number of active superblock writes */
06d91a5f 231
1da177e4
LT
232 unsigned int safemode; /* if set, update "clean" superblock
233 * when no writes pending.
234 */
235 unsigned int safemode_delay;
236 struct timer_list safemode_timer;
237 atomic_t writes_pending;
165125e1 238 struct request_queue *queue; /* for plugging ... */
1da177e4 239
4b6d287f
N
240 atomic_t write_behind; /* outstanding async IO */
241 unsigned int max_write_behind; /* 0 = sync */
242
32a7627c
N
243 struct bitmap *bitmap; /* the bitmap for the device */
244 struct file *bitmap_file; /* the bitmap file */
a654b9d8
N
245 long bitmap_offset; /* offset from superblock of
246 * start of bitmap. May be
247 * negative, but not '0'
248 */
36fa3063
N
249 long default_bitmap_offset; /* this is the offset to use when
250 * hot-adding a bitmap. It should
251 * eventually be settable by sysfs.
252 */
32a7627c 253
1da177e4
LT
254 struct list_head all_mddevs;
255};
256
257
258static inline void rdev_dec_pending(mdk_rdev_t *rdev, mddev_t *mddev)
259{
b2d444d7 260 int faulty = test_bit(Faulty, &rdev->flags);
1da177e4
LT
261 if (atomic_dec_and_test(&rdev->nr_pending) && faulty)
262 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
263}
264
265static inline void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors)
266{
267 atomic_add(nr_sectors, &bdev->bd_contains->bd_disk->sync_io);
268}
269
2604b703 270struct mdk_personality
1da177e4
LT
271{
272 char *name;
2604b703
N
273 int level;
274 struct list_head list;
1da177e4 275 struct module *owner;
165125e1 276 int (*make_request)(struct request_queue *q, struct bio *bio);
1da177e4
LT
277 int (*run)(mddev_t *mddev);
278 int (*stop)(mddev_t *mddev);
279 void (*status)(struct seq_file *seq, mddev_t *mddev);
280 /* error_handler must set ->faulty and clear ->in_sync
281 * if appropriate, and should abort recovery if needed
282 */
283 void (*error_handler)(mddev_t *mddev, mdk_rdev_t *rdev);
284 int (*hot_add_disk) (mddev_t *mddev, mdk_rdev_t *rdev);
285 int (*hot_remove_disk) (mddev_t *mddev, int number);
286 int (*spare_active) (mddev_t *mddev);
57afd89f 287 sector_t (*sync_request)(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster);
1da177e4 288 int (*resize) (mddev_t *mddev, sector_t sectors);
63c70c4f
N
289 int (*check_reshape) (mddev_t *mddev);
290 int (*start_reshape) (mddev_t *mddev);
1da177e4 291 int (*reconfig) (mddev_t *mddev, int layout, int chunk_size);
36fa3063
N
292 /* quiesce moves between quiescence states
293 * 0 - fully active
294 * 1 - no new requests allowed
295 * others - reserved
296 */
297 void (*quiesce) (mddev_t *mddev, int state);
1da177e4
LT
298};
299
300
007583c9
N
301struct md_sysfs_entry {
302 struct attribute attr;
303 ssize_t (*show)(mddev_t *, char *);
304 ssize_t (*store)(mddev_t *, const char *, size_t);
305};
306
307
1da177e4
LT
308static inline char * mdname (mddev_t * mddev)
309{
310 return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
311}
312
1da177e4
LT
313/*
314 * iterates through some rdev ringlist. It's safe to remove the
315 * current 'rdev'. Dont touch 'tmp' though.
316 */
73c34431 317#define rdev_for_each_list(rdev, tmp, list) \
1da177e4 318 \
73c34431 319 for ((tmp) = (list).next; \
1da177e4 320 (rdev) = (list_entry((tmp), mdk_rdev_t, same_set)), \
73c34431 321 (tmp) = (tmp)->next, (tmp)->prev != &(list) \
1da177e4
LT
322 ; )
323/*
324 * iterates through the 'same array disks' ringlist
325 */
d089c6af 326#define rdev_for_each(rdev, tmp, mddev) \
73c34431 327 rdev_for_each_list(rdev, tmp, (mddev)->disks)
1da177e4
LT
328
329typedef struct mdk_thread_s {
330 void (*run) (mddev_t *mddev);
331 mddev_t *mddev;
332 wait_queue_head_t wqueue;
333 unsigned long flags;
1da177e4 334 struct task_struct *tsk;
32a7627c 335 unsigned long timeout;
1da177e4
LT
336} mdk_thread_t;
337
338#define THREAD_WAKEUP 0
339
340#define __wait_event_lock_irq(wq, condition, lock, cmd) \
341do { \
342 wait_queue_t __wait; \
343 init_waitqueue_entry(&__wait, current); \
344 \
345 add_wait_queue(&wq, &__wait); \
346 for (;;) { \
347 set_current_state(TASK_UNINTERRUPTIBLE); \
348 if (condition) \
349 break; \
350 spin_unlock_irq(&lock); \
351 cmd; \
352 schedule(); \
353 spin_lock_irq(&lock); \
354 } \
355 current->state = TASK_RUNNING; \
356 remove_wait_queue(&wq, &__wait); \
357} while (0)
358
359#define wait_event_lock_irq(wq, condition, lock, cmd) \
360do { \
361 if (condition) \
362 break; \
363 __wait_event_lock_irq(wq, condition, lock, cmd); \
364} while (0)
365
1345b1d8
N
366static inline void safe_put_page(struct page *p)
367{
368 if (p) put_page(p);
369}
370
9361401e 371#endif /* CONFIG_BLOCK */
1da177e4
LT
372#endif
373