1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#ifndef _MD_MD_H
16#define _MD_MD_H
17
18#include <linux/blkdev.h>
19#include <linux/kobject.h>
20#include <linux/list.h>
21#include <linux/mm.h>
22#include <linux/mutex.h>
23#include <linux/timer.h>
24#include <linux/wait.h>
25#include <linux/workqueue.h>
26
27#define MaxSector (~(sector_t)0)
28
29
30
31
32
33
34#define MD_MAX_BADBLOCKS (PAGE_SIZE/8)
35
36
37
38
39struct md_rdev {
40 struct list_head same_set;
41
42 sector_t sectors;
43 struct mddev *mddev;
44 int last_events;
45
46
47
48
49
50
51 struct block_device *meta_bdev;
52 struct block_device *bdev;
53
54 struct page *sb_page, *bb_page;
55 int sb_loaded;
56 __u64 sb_events;
57 sector_t data_offset;
58 sector_t new_data_offset;
59 sector_t sb_start;
60 int sb_size;
61 int preferred_minor;
62
63 struct kobject kobj;
64
65
66
67
68
69
70
71
72
73
74
75
76 unsigned long flags;
77 wait_queue_head_t blocked_wait;
78
79 int desc_nr;
80 int raid_disk;
81 int new_raid_disk;
82
83
84 int saved_raid_disk;
85
86
87
88 sector_t recovery_offset;
89
90
91
92
93 atomic_t nr_pending;
94
95
96
97 atomic_t read_errors;
98
99
100 struct timespec last_read_error;
101
102
103 atomic_t corrected_errors;
104
105
106
107 struct work_struct del_work;
108
109 struct sysfs_dirent *sysfs_state;
110
111
112 struct badblocks {
113 int count;
114 int unacked_exist;
115
116
117
118 int shift;
119
120
121 u64 *page;
122 int changed;
123 seqlock_t lock;
124
125 sector_t sector;
126 sector_t size;
127 } badblocks;
128};
129enum flag_bits {
130 Faulty,
131 In_sync,
132 Unmerged,
133
134
135
136 WriteMostly,
137 AutoDetected,
138 Blocked,
139
140
141
142 WriteErrorSeen,
143
144
145 FaultRecorded,
146
147
148
149
150
151 BlockedBadBlocks,
152
153
154
155
156
157
158
159
160
161 WantReplacement,
162
163
164
165
166 Replacement,
167
168
169
170};
171
172#define BB_LEN_MASK (0x00000000000001FFULL)
173#define BB_OFFSET_MASK (0x7FFFFFFFFFFFFE00ULL)
174#define BB_ACK_MASK (0x8000000000000000ULL)
175#define BB_MAX_LEN 512
176#define BB_OFFSET(x) (((x) & BB_OFFSET_MASK) >> 9)
177#define BB_LEN(x) (((x) & BB_LEN_MASK) + 1)
178#define BB_ACK(x) (!!((x) & BB_ACK_MASK))
179#define BB_MAKE(a, l, ack) (((a)<<9) | ((l)-1) | ((u64)(!!(ack)) << 63))
180
181extern int md_is_badblock(struct badblocks *bb, sector_t s, int sectors,
182 sector_t *first_bad, int *bad_sectors);
183static inline int is_badblock(struct md_rdev *rdev, sector_t s, int sectors,
184 sector_t *first_bad, int *bad_sectors)
185{
186 if (unlikely(rdev->badblocks.count)) {
187 int rv = md_is_badblock(&rdev->badblocks, rdev->data_offset + s,
188 sectors,
189 first_bad, bad_sectors);
190 if (rv)
191 *first_bad -= rdev->data_offset;
192 return rv;
193 }
194 return 0;
195}
196extern int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
197 int is_new);
198extern int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
199 int is_new);
200extern void md_ack_all_badblocks(struct badblocks *bb);
201
202struct mddev {
203 void *private;
204 struct md_personality *pers;
205 dev_t unit;
206 int md_minor;
207 struct list_head disks;
208 unsigned long flags;
209#define MD_CHANGE_DEVS 0
210#define MD_CHANGE_CLEAN 1
211#define MD_CHANGE_PENDING 2
212#define MD_ARRAY_FIRST_USE 3
213
214 int suspended;
215 atomic_t active_io;
216 int ro;
217 int sysfs_active;
218
219
220
221 int ready;
222
223 struct gendisk *gendisk;
224
225 struct kobject kobj;
226 int hold_active;
227#define UNTIL_IOCTL 1
228#define UNTIL_STOP 2
229
230
231 int major_version,
232 minor_version,
233 patch_version;
234 int persistent;
235 int external;
236
237 char metadata_type[17];
238 int chunk_sectors;
239 time_t ctime, utime;
240 int level, layout;
241 char clevel[16];
242 int raid_disks;
243 int max_disks;
244 sector_t dev_sectors;
245
246 sector_t array_sectors;
247 int external_size;
248
249 __u64 events;
250
251
252
253
254
255 int can_decrease_events;
256
257 char uuid[16];
258
259
260
261
262
263
264 sector_t reshape_position;
265 int delta_disks, new_level, new_layout;
266 int new_chunk_sectors;
267 int reshape_backwards;
268
269 struct md_thread *thread;
270 struct md_thread *sync_thread;
271 sector_t curr_resync;
272
273
274
275
276
277
278 sector_t curr_resync_completed;
279 unsigned long resync_mark;
280 sector_t resync_mark_cnt;
281 sector_t curr_mark_cnt;
282
283 sector_t resync_max_sectors;
284
285 atomic64_t resync_mismatches;
286
287
288
289
290 sector_t suspend_lo;
291 sector_t suspend_hi;
292
293 int sync_speed_min;
294 int sync_speed_max;
295
296
297 int parallel_resync;
298
299 int ok_start_degraded;
300
301
302
303
304
305
306
307
308
309
310
311
312
313#define MD_RECOVERY_RUNNING 0
314#define MD_RECOVERY_SYNC 1
315#define MD_RECOVERY_RECOVER 2
316#define MD_RECOVERY_INTR 3
317#define MD_RECOVERY_DONE 4
318#define MD_RECOVERY_NEEDED 5
319#define MD_RECOVERY_REQUESTED 6
320#define MD_RECOVERY_CHECK 7
321#define MD_RECOVERY_RESHAPE 8
322#define MD_RECOVERY_FROZEN 9
323
324 unsigned long recovery;
325
326
327
328
329
330 int recovery_disabled;
331
332 int in_sync;
333
334
335
336
337
338
339
340
341
342 struct mutex open_mutex;
343 struct mutex reconfig_mutex;
344 atomic_t active;
345 atomic_t openers;
346
347 int changed;
348
349 int degraded;
350
351
352 int merge_check_needed;
353
354
355
356
357 atomic_t recovery_active;
358 wait_queue_head_t recovery_wait;
359 sector_t recovery_cp;
360 sector_t resync_min;
361
362 sector_t resync_max;
363
364
365 struct sysfs_dirent *sysfs_state;
366
367
368 struct sysfs_dirent *sysfs_action;
369
370 struct work_struct del_work;
371
372 spinlock_t write_lock;
373 wait_queue_head_t sb_wait;
374 atomic_t pending_writes;
375
376 unsigned int safemode;
377
378
379 unsigned int safemode_delay;
380 struct timer_list safemode_timer;
381 atomic_t writes_pending;
382 struct request_queue *queue;
383
384 struct bitmap *bitmap;
385 struct {
386 struct file *file;
387 loff_t offset;
388
389
390
391
392
393 unsigned long space;
394 loff_t default_offset;
395
396
397
398 unsigned long default_space;
399
400 struct mutex mutex;
401 unsigned long chunksize;
402 unsigned long daemon_sleep;
403 unsigned long max_write_behind;
404 int external;
405 } bitmap_info;
406
407 atomic_t max_corr_read_errors;
408 struct list_head all_mddevs;
409
410 struct attribute_group *to_remove;
411
412 struct bio_set *bio_set;
413
414
415
416
417
418 struct bio *flush_bio;
419 atomic_t flush_pending;
420 struct work_struct flush_work;
421 struct work_struct event_work;
422 void (*sync_super)(struct mddev *mddev, struct md_rdev *rdev);
423};
424
425
426static inline void rdev_dec_pending(struct md_rdev *rdev, struct mddev *mddev)
427{
428 int faulty = test_bit(Faulty, &rdev->flags);
429 if (atomic_dec_and_test(&rdev->nr_pending) && faulty)
430 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
431}
432
433static inline void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors)
434{
435 atomic_add(nr_sectors, &bdev->bd_contains->bd_disk->sync_io);
436}
437
438struct md_personality
439{
440 char *name;
441 int level;
442 struct list_head list;
443 struct module *owner;
444 void (*make_request)(struct mddev *mddev, struct bio *bio);
445 int (*run)(struct mddev *mddev);
446 int (*stop)(struct mddev *mddev);
447 void (*status)(struct seq_file *seq, struct mddev *mddev);
448
449
450
451 void (*error_handler)(struct mddev *mddev, struct md_rdev *rdev);
452 int (*hot_add_disk) (struct mddev *mddev, struct md_rdev *rdev);
453 int (*hot_remove_disk) (struct mddev *mddev, struct md_rdev *rdev);
454 int (*spare_active) (struct mddev *mddev);
455 sector_t (*sync_request)(struct mddev *mddev, sector_t sector_nr, int *skipped, int go_faster);
456 int (*resize) (struct mddev *mddev, sector_t sectors);
457 sector_t (*size) (struct mddev *mddev, sector_t sectors, int raid_disks);
458 int (*check_reshape) (struct mddev *mddev);
459 int (*start_reshape) (struct mddev *mddev);
460 void (*finish_reshape) (struct mddev *mddev);
461
462
463
464
465
466 void (*quiesce) (struct mddev *mddev, int state);
467
468
469
470
471
472
473
474
475
476 void *(*takeover) (struct mddev *mddev);
477};
478
479
480struct md_sysfs_entry {
481 struct attribute attr;
482 ssize_t (*show)(struct mddev *, char *);
483 ssize_t (*store)(struct mddev *, const char *, size_t);
484};
485extern struct attribute_group md_bitmap_group;
486
487static inline struct sysfs_dirent *sysfs_get_dirent_safe(struct sysfs_dirent *sd, char *name)
488{
489 if (sd)
490 return sysfs_get_dirent(sd, NULL, name);
491 return sd;
492}
493static inline void sysfs_notify_dirent_safe(struct sysfs_dirent *sd)
494{
495 if (sd)
496 sysfs_notify_dirent(sd);
497}
498
499static inline char * mdname (struct mddev * mddev)
500{
501 return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
502}
503
504static inline int sysfs_link_rdev(struct mddev *mddev, struct md_rdev *rdev)
505{
506 char nm[20];
507 if (!test_bit(Replacement, &rdev->flags)) {
508 sprintf(nm, "rd%d", rdev->raid_disk);
509 return sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
510 } else
511 return 0;
512}
513
514static inline void sysfs_unlink_rdev(struct mddev *mddev, struct md_rdev *rdev)
515{
516 char nm[20];
517 if (!test_bit(Replacement, &rdev->flags)) {
518 sprintf(nm, "rd%d", rdev->raid_disk);
519 sysfs_remove_link(&mddev->kobj, nm);
520 }
521}
522
523
524
525
526
527#define rdev_for_each_list(rdev, tmp, head) \
528 list_for_each_entry_safe(rdev, tmp, head, same_set)
529
530
531
532
533#define rdev_for_each(rdev, mddev) \
534 list_for_each_entry(rdev, &((mddev)->disks), same_set)
535
536#define rdev_for_each_safe(rdev, tmp, mddev) \
537 list_for_each_entry_safe(rdev, tmp, &((mddev)->disks), same_set)
538
539#define rdev_for_each_rcu(rdev, mddev) \
540 list_for_each_entry_rcu(rdev, &((mddev)->disks), same_set)
541
542struct md_thread {
543 void (*run) (struct md_thread *thread);
544 struct mddev *mddev;
545 wait_queue_head_t wqueue;
546 unsigned long flags;
547 struct task_struct *tsk;
548 unsigned long timeout;
549 void *private;
550};
551
552#define THREAD_WAKEUP 0
553
554#define __wait_event_lock_irq(wq, condition, lock, cmd) \
555do { \
556 wait_queue_t __wait; \
557 init_waitqueue_entry(&__wait, current); \
558 \
559 add_wait_queue(&wq, &__wait); \
560 for (;;) { \
561 set_current_state(TASK_UNINTERRUPTIBLE); \
562 if (condition) \
563 break; \
564 spin_unlock_irq(&lock); \
565 cmd; \
566 schedule(); \
567 spin_lock_irq(&lock); \
568 } \
569 current->state = TASK_RUNNING; \
570 remove_wait_queue(&wq, &__wait); \
571} while (0)
572
573#define wait_event_lock_irq(wq, condition, lock, cmd) \
574do { \
575 if (condition) \
576 break; \
577 __wait_event_lock_irq(wq, condition, lock, cmd); \
578} while (0)
579
580static inline void safe_put_page(struct page *p)
581{
582 if (p) put_page(p);
583}
584
585extern int register_md_personality(struct md_personality *p);
586extern int unregister_md_personality(struct md_personality *p);
587extern struct md_thread *md_register_thread(
588 void (*run)(struct md_thread *thread),
589 struct mddev *mddev,
590 const char *name);
591extern void md_unregister_thread(struct md_thread **threadp);
592extern void md_wakeup_thread(struct md_thread *thread);
593extern void md_check_recovery(struct mddev *mddev);
594extern void md_write_start(struct mddev *mddev, struct bio *bi);
595extern void md_write_end(struct mddev *mddev);
596extern void md_done_sync(struct mddev *mddev, int blocks, int ok);
597extern void md_error(struct mddev *mddev, struct md_rdev *rdev);
598extern void md_finish_reshape(struct mddev *mddev);
599
600extern int mddev_congested(struct mddev *mddev, int bits);
601extern void md_flush_request(struct mddev *mddev, struct bio *bio);
602extern void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
603 sector_t sector, int size, struct page *page);
604extern void md_super_wait(struct mddev *mddev);
605extern int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
606 struct page *page, int rw, bool metadata_op);
607extern void md_do_sync(struct md_thread *thread);
608extern void md_new_event(struct mddev *mddev);
609extern int md_allow_write(struct mddev *mddev);
610extern void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev);
611extern void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors);
612extern int md_check_no_bitmap(struct mddev *mddev);
613extern int md_integrity_register(struct mddev *mddev);
614extern void md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev);
615extern int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale);
616extern void restore_bitmap_write_access(struct file *file);
617
618extern void mddev_init(struct mddev *mddev);
619extern int md_run(struct mddev *mddev);
620extern void md_stop(struct mddev *mddev);
621extern void md_stop_writes(struct mddev *mddev);
622extern int md_rdev_init(struct md_rdev *rdev);
623extern void md_rdev_clear(struct md_rdev *rdev);
624
625extern void mddev_suspend(struct mddev *mddev);
626extern void mddev_resume(struct mddev *mddev);
627extern struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
628 struct mddev *mddev);
629extern struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
630 struct mddev *mddev);
631extern void md_trim_bio(struct bio *bio, int offset, int size);
632
633extern void md_unplug(struct blk_plug_cb *cb, bool from_schedule);
634static inline int mddev_check_plugged(struct mddev *mddev)
635{
636 return !!blk_check_plugged(md_unplug, mddev,
637 sizeof(struct blk_plug_cb));
638}
639#endif
640