blob: e559fb701aa1c727934191e7135e688be5dee7e2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
NeilBrown06d91a52005-06-21 17:17:12 -070018/* and dm-bio-list.h is not under include/linux because.... ??? */
19#include "../../../drivers/md/dm-bio-list.h"
20
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#define LEVEL_MULTIPATH (-4)
22#define LEVEL_LINEAR (-1)
23#define LEVEL_FAULTY (-5)
24
NeilBrown2604b702006-01-06 00:20:36 -080025/* 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 Torvalds1da177e2005-04-16 15:20:36 -070031#define MaxSector (~(sector_t)0)
32#define MD_THREAD_NAME_MAX 14
33
Linus Torvalds1da177e2005-04-16 15:20:36 -070034typedef struct mddev_s mddev_t;
35typedef 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 Torvalds1da177e2005-04-16 15:20:36 -070046 * 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 */
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;
NeilBrown0002b272005-09-09 16:23:53 -070062 int sb_size; /* bytes in the superblock */
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 int preferred_minor; /* autorun support */
64
NeilBrown86e6ffd2005-11-08 21:39:24 -080065 struct kobject kobj;
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 /* 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 Torvalds1da177e2005-04-16 15:20:36 -070077
NeilBrownb2d444d2005-11-08 21:39:31 -080078 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 */
NeilBrown8ddf9ef2005-09-09 16:23:45 -070081#define WriteMostly 4 /* Avoid reading if at all possible */
NeilBrowna9701a32005-11-08 21:39:34 -080082#define BarriersNotsupp 5 /* BIO_RW_BARRIER is not supported */
NeilBrown8ddf9ef2005-09-09 16:23:45 -070083
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 int desc_nr; /* descriptor index in the superblock */
85 int raid_disk; /* role of device in array */
NeilBrown41158c72005-06-21 17:17:25 -070086 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 Torvalds1da177e2005-04-16 15:20:36 -070090
91 atomic_t nr_pending; /* number of pending requests.
92 * only maintained for arrays that
93 * support hot removal
94 */
NeilBrownba22dcb2005-11-08 21:39:31 -080095 atomic_t read_errors; /* number of consecutive read errors that
96 * we have tried to ignore.
97 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070098};
99
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100struct mddev_s
101{
102 void *private;
NeilBrown2604b702006-01-06 00:20:36 -0800103 struct mdk_personality *pers;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 dev_t unit;
105 int md_minor;
106 struct list_head disks;
107 int sb_dirty;
108 int ro;
109
110 struct gendisk *gendisk;
111
NeilBrowneae17012005-11-08 21:39:23 -0800112 struct kobject kobj;
113
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 /* Superblock information */
115 int major_version,
116 minor_version,
117 patch_version;
118 int persistent;
119 int chunk_size;
120 time_t ctime, utime;
121 int level, layout;
122 int raid_disks;
123 int max_disks;
124 sector_t size; /* used size of component devices */
125 sector_t array_size; /* exported array size */
126 __u64 events;
127
128 char uuid[16];
129
130 struct mdk_thread_s *thread; /* management thread */
131 struct mdk_thread_s *sync_thread; /* doing resync or reconstruct */
132 sector_t curr_resync; /* blocks scheduled */
133 unsigned long resync_mark; /* a recent timestamp */
134 sector_t resync_mark_cnt;/* blocks written at resync_mark */
135
136 sector_t resync_max_sectors; /* may be set by personality */
NeilBrown9d888832005-11-08 21:39:26 -0800137
138 sector_t resync_mismatches; /* count of sectors where
139 * parity/replica mismatch found
140 */
NeilBrown6ff8d8e2006-01-06 00:20:15 -0800141 int ok_start_degraded;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 /* recovery/resync flags
143 * NEEDED: we might need to start a resync/recover
144 * RUNNING: a thread is running, or about to be started
145 * SYNC: actually doing a resync, not a recovery
146 * ERR: and IO error was detected - abort the resync/recovery
147 * INTR: someone requested a (clean) early abort.
148 * DONE: thread is done and is waiting to be reaped
NeilBrown24dd4692005-11-08 21:39:26 -0800149 * REQUEST: user-space has requested a sync (used with SYNC)
150 * CHECK: user-space request for for check-only, no repair
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 */
152#define MD_RECOVERY_RUNNING 0
153#define MD_RECOVERY_SYNC 1
154#define MD_RECOVERY_ERR 2
155#define MD_RECOVERY_INTR 3
156#define MD_RECOVERY_DONE 4
157#define MD_RECOVERY_NEEDED 5
NeilBrown24dd4692005-11-08 21:39:26 -0800158#define MD_RECOVERY_REQUESTED 6
159#define MD_RECOVERY_CHECK 7
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 unsigned long recovery;
161
162 int in_sync; /* know to not need resync */
163 struct semaphore reconfig_sem;
164 atomic_t active;
165
166 int changed; /* true if we might need to reread partition info */
167 int degraded; /* whether md should consider
168 * adding a spare
169 */
NeilBrowna9701a32005-11-08 21:39:34 -0800170 int barriers_work; /* initialised to true, cleared as soon
171 * as a barrier request to slave
172 * fails. Only supported
173 */
174 struct bio *biolist; /* bios that need to be retried
175 * because BIO_RW_BARRIER is not supported
176 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
178 atomic_t recovery_active; /* blocks scheduled, but not written */
179 wait_queue_head_t recovery_wait;
180 sector_t recovery_cp;
NeilBrown06d91a52005-06-21 17:17:12 -0700181
182 spinlock_t write_lock;
NeilBrown3d310eb2005-06-21 17:17:26 -0700183 wait_queue_head_t sb_wait; /* for waiting on superblock updates */
NeilBrown7bfa19f2005-06-21 17:17:28 -0700184 atomic_t pending_writes; /* number of active superblock writes */
NeilBrown06d91a52005-06-21 17:17:12 -0700185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 unsigned int safemode; /* if set, update "clean" superblock
187 * when no writes pending.
188 */
189 unsigned int safemode_delay;
190 struct timer_list safemode_timer;
191 atomic_t writes_pending;
192 request_queue_t *queue; /* for plugging ... */
193
NeilBrown4b6d2872005-09-09 16:23:47 -0700194 atomic_t write_behind; /* outstanding async IO */
195 unsigned int max_write_behind; /* 0 = sync */
196
NeilBrown32a76272005-06-21 17:17:14 -0700197 struct bitmap *bitmap; /* the bitmap for the device */
198 struct file *bitmap_file; /* the bitmap file */
NeilBrowna654b9d82005-06-21 17:17:27 -0700199 long bitmap_offset; /* offset from superblock of
200 * start of bitmap. May be
201 * negative, but not '0'
202 */
NeilBrown36fa3062005-09-09 16:23:45 -0700203 long default_bitmap_offset; /* this is the offset to use when
204 * hot-adding a bitmap. It should
205 * eventually be settable by sysfs.
206 */
NeilBrown32a76272005-06-21 17:17:14 -0700207
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 struct list_head all_mddevs;
209};
210
211
212static inline void rdev_dec_pending(mdk_rdev_t *rdev, mddev_t *mddev)
213{
NeilBrownb2d444d2005-11-08 21:39:31 -0800214 int faulty = test_bit(Faulty, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 if (atomic_dec_and_test(&rdev->nr_pending) && faulty)
216 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
217}
218
219static inline void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors)
220{
221 atomic_add(nr_sectors, &bdev->bd_contains->bd_disk->sync_io);
222}
223
NeilBrown2604b702006-01-06 00:20:36 -0800224struct mdk_personality
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225{
226 char *name;
NeilBrown2604b702006-01-06 00:20:36 -0800227 int level;
228 struct list_head list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 struct module *owner;
230 int (*make_request)(request_queue_t *q, struct bio *bio);
231 int (*run)(mddev_t *mddev);
232 int (*stop)(mddev_t *mddev);
233 void (*status)(struct seq_file *seq, mddev_t *mddev);
234 /* error_handler must set ->faulty and clear ->in_sync
235 * if appropriate, and should abort recovery if needed
236 */
237 void (*error_handler)(mddev_t *mddev, mdk_rdev_t *rdev);
238 int (*hot_add_disk) (mddev_t *mddev, mdk_rdev_t *rdev);
239 int (*hot_remove_disk) (mddev_t *mddev, int number);
240 int (*spare_active) (mddev_t *mddev);
NeilBrown57afd892005-06-21 17:17:13 -0700241 sector_t (*sync_request)(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 int (*resize) (mddev_t *mddev, sector_t sectors);
243 int (*reshape) (mddev_t *mddev, int raid_disks);
244 int (*reconfig) (mddev_t *mddev, int layout, int chunk_size);
NeilBrown36fa3062005-09-09 16:23:45 -0700245 /* quiesce moves between quiescence states
246 * 0 - fully active
247 * 1 - no new requests allowed
248 * others - reserved
249 */
250 void (*quiesce) (mddev_t *mddev, int state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251};
252
253
NeilBrown007583c2005-11-08 21:39:30 -0800254struct md_sysfs_entry {
255 struct attribute attr;
256 ssize_t (*show)(mddev_t *, char *);
257 ssize_t (*store)(mddev_t *, const char *, size_t);
258};
259
260
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261static inline char * mdname (mddev_t * mddev)
262{
263 return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
264}
265
266extern mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr);
267
268/*
269 * iterates through some rdev ringlist. It's safe to remove the
270 * current 'rdev'. Dont touch 'tmp' though.
271 */
272#define ITERATE_RDEV_GENERIC(head,rdev,tmp) \
273 \
274 for ((tmp) = (head).next; \
275 (rdev) = (list_entry((tmp), mdk_rdev_t, same_set)), \
276 (tmp) = (tmp)->next, (tmp)->prev != &(head) \
277 ; )
278/*
279 * iterates through the 'same array disks' ringlist
280 */
281#define ITERATE_RDEV(mddev,rdev,tmp) \
282 ITERATE_RDEV_GENERIC((mddev)->disks,rdev,tmp)
283
284/*
285 * Iterates through 'pending RAID disks'
286 */
287#define ITERATE_RDEV_PENDING(rdev,tmp) \
288 ITERATE_RDEV_GENERIC(pending_raid_disks,rdev,tmp)
289
290typedef struct mdk_thread_s {
291 void (*run) (mddev_t *mddev);
292 mddev_t *mddev;
293 wait_queue_head_t wqueue;
294 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 struct task_struct *tsk;
NeilBrown32a76272005-06-21 17:17:14 -0700296 unsigned long timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297} mdk_thread_t;
298
299#define THREAD_WAKEUP 0
300
301#define __wait_event_lock_irq(wq, condition, lock, cmd) \
302do { \
303 wait_queue_t __wait; \
304 init_waitqueue_entry(&__wait, current); \
305 \
306 add_wait_queue(&wq, &__wait); \
307 for (;;) { \
308 set_current_state(TASK_UNINTERRUPTIBLE); \
309 if (condition) \
310 break; \
311 spin_unlock_irq(&lock); \
312 cmd; \
313 schedule(); \
314 spin_lock_irq(&lock); \
315 } \
316 current->state = TASK_RUNNING; \
317 remove_wait_queue(&wq, &__wait); \
318} while (0)
319
320#define wait_event_lock_irq(wq, condition, lock, cmd) \
321do { \
322 if (condition) \
323 break; \
324 __wait_event_lock_irq(wq, condition, lock, cmd); \
325} while (0)
326
327#endif
328