md.h 19.7 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
   md.h : kernel internal structure of the Linux MD driver
L
Linus Torvalds 已提交
3 4 5 6 7 8 9 10 11 12 13 14
          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.  
*/

C
Christoph Hellwig 已提交
15 16 17 18 19 20 21 22 23 24 25
#ifndef _MD_MD_H
#define _MD_MD_H

#include <linux/blkdev.h>
#include <linux/kobject.h>
#include <linux/list.h>
#include <linux/mm.h>
#include <linux/mutex.h>
#include <linux/timer.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
26

L
Linus Torvalds 已提交
27 28 29 30 31
#define MaxSector (~(sector_t)0)

typedef struct mddev_s mddev_t;
typedef struct mdk_rdev_s mdk_rdev_t;

32 33 34 35 36 37 38
/* Bad block numbers are stored sorted in a single page.
 * 64bits is used for each block or extent.
 * 54 bits are sector number, 9 bits are extent size,
 * 1 bit is an 'acknowledged' flag.
 */
#define MD_MAX_BADBLOCKS	(PAGE_SIZE/8)

L
Linus Torvalds 已提交
39 40 41 42 43 44 45
/*
 * MD's 'extended' device
 */
struct mdk_rdev_s
{
	struct list_head same_set;	/* RAID devices within the same set */

46
	sector_t sectors;		/* Device size (in 512bytes sectors) */
L
Linus Torvalds 已提交
47
	mddev_t *mddev;			/* RAID array if running */
N
NeilBrown 已提交
48
	int last_events;		/* IO event timestamp */
L
Linus Torvalds 已提交
49

50 51 52 53 54 55
	/*
	 * If meta_bdev is non-NULL, it means that a separate device is
	 * being used to store the metadata (superblock/bitmap) which
	 * would otherwise be contained on the same device as the data (bdev).
	 */
	struct block_device *meta_bdev;
L
Linus Torvalds 已提交
56 57
	struct block_device *bdev;	/* block device handle */

58
	struct page	*sb_page, *bb_page;
L
Linus Torvalds 已提交
59
	int		sb_loaded;
60
	__u64		sb_events;
L
Linus Torvalds 已提交
61
	sector_t	data_offset;	/* start of data in array */
62
	sector_t 	sb_start;	/* offset of the super block (in 512byte sectors) */
63
	int		sb_size;	/* bytes in the superblock */
L
Linus Torvalds 已提交
64 65
	int		preferred_minor;	/* autorun support */

66 67
	struct kobject	kobj;

L
Linus Torvalds 已提交
68 69 70 71 72 73 74 75 76 77 78
	/* 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
	 */

79 80 81
	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 */
82
#define	WriteMostly	4		/* Avoid reading if at all possible */
83
#define	AutoDetected	7		/* added by auto-detect */
84 85 86
#define Blocked		8		/* An error occurred but has not yet
					 * been acknowledged by the metadata
					 * handler, so don't allow writes
87
					 * until it is cleared */
88 89 90
#define WriteErrorSeen	9		/* A write error has been seen on this
					 * device
					 */
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
#define FaultRecorded	10		/* Intermediate state for clearing
					 * Blocked.  The Fault is/will-be
					 * recorded in the metadata, but that
					 * metadata hasn't been stored safely
					 * on disk yet.
					 */
#define BlockedBadBlocks 11		/* A writer is blocked because they
					 * found an unacknowledged bad-block.
					 * This can safely be cleared at any
					 * time, and the writer will re-check.
					 * It may be set at any time, and at
					 * worst the writer will timeout and
					 * re-check.  So setting it as
					 * accurately as possible is good, but
					 * not absolutely critical.
					 */
107
	wait_queue_head_t blocked_wait;
108

L
Linus Torvalds 已提交
109 110
	int desc_nr;			/* descriptor index in the superblock */
	int raid_disk;			/* role of device in array */
111 112 113
	int new_raid_disk;		/* role that the device will have in
					 * the array after a level-change completes.
					 */
114 115 116 117
	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
					 */
118 119 120 121
	sector_t	recovery_offset;/* If this device has been partially
					 * recovered, this is where we were
					 * up to.
					 */
L
Linus Torvalds 已提交
122 123 124 125 126

	atomic_t	nr_pending;	/* number of pending requests.
					 * only maintained for arrays that
					 * support hot removal
					 */
127 128 129
	atomic_t	read_errors;	/* number of consecutive read errors that
					 * we have tried to ignore.
					 */
130 131 132
	struct timespec last_read_error;	/* monotonic time since our
						 * last read error
						 */
133 134 135 136
	atomic_t	corrected_errors; /* number of corrected read errors,
					   * for reporting to userspace and storing
					   * in superblock.
					   */
137
	struct work_struct del_work;	/* used for delayed sysfs removal */
138 139 140

	struct sysfs_dirent *sysfs_state; /* handle for 'state'
					   * sysfs entry */
141 142 143

	struct badblocks {
		int	count;		/* count of bad blocks */
144 145 146 147
		int	unacked_exist;	/* there probably are unacknowledged
					 * bad blocks.  This is only cleared
					 * when a read discovers none
					 */
148 149 150 151 152 153
		int	shift;		/* shift from sectors to block size
					 * a -ve shift means badblocks are
					 * disabled.*/
		u64	*page;		/* badblock list */
		int	changed;
		seqlock_t lock;
154 155 156

		sector_t sector;
		sector_t size;		/* in sectors */
157
	} badblocks;
L
Linus Torvalds 已提交
158 159
};

160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
#define BB_LEN_MASK	(0x00000000000001FFULL)
#define BB_OFFSET_MASK	(0x7FFFFFFFFFFFFE00ULL)
#define BB_ACK_MASK	(0x8000000000000000ULL)
#define BB_MAX_LEN	512
#define BB_OFFSET(x)	(((x) & BB_OFFSET_MASK) >> 9)
#define BB_LEN(x)	(((x) & BB_LEN_MASK) + 1)
#define BB_ACK(x)	(!!((x) & BB_ACK_MASK))
#define BB_MAKE(a, l, ack) (((a)<<9) | ((l)-1) | ((u64)(!!(ack)) << 63))

extern int md_is_badblock(struct badblocks *bb, sector_t s, int sectors,
			  sector_t *first_bad, int *bad_sectors);
static inline int is_badblock(mdk_rdev_t *rdev, sector_t s, int sectors,
			      sector_t *first_bad, int *bad_sectors)
{
	if (unlikely(rdev->badblocks.count)) {
		int rv = md_is_badblock(&rdev->badblocks, rdev->data_offset + s,
					sectors,
					first_bad, bad_sectors);
		if (rv)
			*first_bad -= rdev->data_offset;
		return rv;
	}
	return 0;
}
extern int rdev_set_badblocks(mdk_rdev_t *rdev, sector_t s, int sectors,
			      int acknowledged);
extern int rdev_clear_badblocks(mdk_rdev_t *rdev, sector_t s, int sectors);
extern void md_ack_all_badblocks(struct badblocks *bb);

L
Linus Torvalds 已提交
189 190 191
struct mddev_s
{
	void				*private;
192
	struct mdk_personality		*pers;
L
Linus Torvalds 已提交
193 194 195
	dev_t				unit;
	int				md_minor;
	struct list_head 		disks;
196 197 198
	unsigned long			flags;
#define MD_CHANGE_DEVS	0	/* Some device status has changed */
#define MD_CHANGE_CLEAN 1	/* transition to or from 'clean' */
199
#define MD_CHANGE_PENDING 2	/* switch from 'clean' to 'active' in progress */
200
#define MD_ARRAY_FIRST_USE 3    /* First use of array, needs initialization */
201

202 203
	int				suspended;
	atomic_t			active_io;
L
Linus Torvalds 已提交
204
	int				ro;
205 206 207 208
	int				sysfs_active; /* set when sysfs deletes
						       * are happening, so run/
						       * takeover/stop are not safe
						       */
209 210
	int				ready; /* See when safe to pass 
						* IO requests down */
L
Linus Torvalds 已提交
211 212
	struct gendisk			*gendisk;

213
	struct kobject			kobj;
214 215
	int				hold_active;
#define	UNTIL_IOCTL	1
216
#define	UNTIL_STOP	2
217

L
Linus Torvalds 已提交
218 219 220 221 222
	/* Superblock information */
	int				major_version,
					minor_version,
					patch_version;
	int				persistent;
223 224 225
	int 				external;	/* metadata is
							 * managed externally */
	char				metadata_type[17]; /* externally set*/
226
	int				chunk_sectors;
L
Linus Torvalds 已提交
227 228
	time_t				ctime, utime;
	int				level, layout;
229
	char				clevel[16];
L
Linus Torvalds 已提交
230 231
	int				raid_disks;
	int				max_disks;
A
Andre Noll 已提交
232 233
	sector_t			dev_sectors; 	/* used size of
							 * component devices */
234
	sector_t			array_sectors; /* exported array size */
D
Dan Williams 已提交
235 236
	int				external_size; /* size managed
							* externally */
L
Linus Torvalds 已提交
237
	__u64				events;
238 239 240 241 242 243
	/* If the last 'event' was simply a clean->dirty transition, and
	 * we didn't write it to the spares, then it is safe and simple
	 * to just decrement the event count on a dirty->clean transition.
	 * So we record that possibility here.
	 */
	int				can_decrease_events;
L
Linus Torvalds 已提交
244 245 246

	char				uuid[16];

247 248 249 250 251 252
	/* 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;
253 254
	int				delta_disks, new_level, new_layout;
	int				new_chunk_sectors;
255

256 257 258
	atomic_t			plug_cnt;	/* If device is expecting
							 * more bios soon.
							 */
L
Linus Torvalds 已提交
259 260
	struct mdk_thread_s		*thread;	/* management thread */
	struct mdk_thread_s		*sync_thread;	/* doing resync or reconstruct */
261
	sector_t			curr_resync;	/* last block scheduled */
262 263 264 265 266 267 268
	/* As resync requests can complete out of order, we cannot easily track
	 * how much resync has been completed.  So we occasionally pause until
	 * everything completes, then set curr_resync_completed to curr_resync.
	 * As such it may be well behind the real resync mark, but it is a value
	 * we are certain of.
	 */
	sector_t			curr_resync_completed;
L
Linus Torvalds 已提交
269 270
	unsigned long			resync_mark;	/* a recent timestamp */
	sector_t			resync_mark_cnt;/* blocks written at resync_mark */
271
	sector_t			curr_mark_cnt; /* blocks scheduled now */
L
Linus Torvalds 已提交
272 273

	sector_t			resync_max_sectors; /* may be set by personality */
274 275 276 277

	sector_t			resync_mismatches; /* count of sectors where
							    * parity/replica mismatch found
							    */
278 279 280 281

	/* allow user-space to request suspension of IO to regions of the array */
	sector_t			suspend_lo;
	sector_t			suspend_hi;
282 283 284 285
	/* if zero, use the system-wide default */
	int				sync_speed_min;
	int				sync_speed_max;

286 287 288
	/* resync even though the same disks are shared among md-devices */
	int				parallel_resync;

289
	int				ok_start_degraded;
L
Linus Torvalds 已提交
290 291 292 293
	/* 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
294
	 * RECOVER:  doing recovery, or need to try it.
295
	 * INTR:     resync needs to be aborted for some reason
L
Linus Torvalds 已提交
296
	 * DONE:     thread is done and is waiting to be reaped
297
	 * REQUEST:  user-space has requested a sync (used with SYNC)
298
	 * CHECK:    user-space request for check-only, no repair
299 300 301
	 * RESHAPE:  A reshape is happening
	 *
	 * If neither SYNC or RESHAPE are set, then it is a recovery.
L
Linus Torvalds 已提交
302 303 304
	 */
#define	MD_RECOVERY_RUNNING	0
#define	MD_RECOVERY_SYNC	1
305
#define	MD_RECOVERY_RECOVER	2
L
Linus Torvalds 已提交
306 307 308
#define	MD_RECOVERY_INTR	3
#define	MD_RECOVERY_DONE	4
#define	MD_RECOVERY_NEEDED	5
309 310
#define	MD_RECOVERY_REQUESTED	6
#define	MD_RECOVERY_CHECK	7
311
#define MD_RECOVERY_RESHAPE	8
312 313
#define	MD_RECOVERY_FROZEN	9

L
Linus Torvalds 已提交
314
	unsigned long			recovery;
315 316 317 318 319 320
	/* If a RAID personality determines that recovery (of a particular
	 * device) will fail due to a read error on the source device, it
	 * takes a copy of this number and does not attempt recovery again
	 * until this number changes.
	 */
	int				recovery_disabled;
L
Linus Torvalds 已提交
321 322

	int				in_sync;	/* know to not need resync */
N
NeilBrown 已提交
323 324 325 326 327 328 329 330 331 332
	/* 'open_mutex' avoids races between 'md_open' and 'do_md_stop', so
	 * that we are never stopping an array while it is open.
	 * 'reconfig_mutex' protects all other reconfiguration.
	 * These locks are separate due to conflicting interactions
	 * with bdev->bd_mutex.
	 * Lock ordering is:
	 *  reconfig_mutex -> bd_mutex : e.g. do_md_run -> revalidate_disk
	 *  bd_mutex -> open_mutex:  e.g. __blkdev_get -> md_open
	 */
	struct mutex			open_mutex;
333
	struct mutex			reconfig_mutex;
334 335
	atomic_t			active;		/* general refcount */
	atomic_t			openers;	/* number of active opens */
L
Linus Torvalds 已提交
336

337 338
	int				changed;	/* True if we might need to
							 * reread partition info */
L
Linus Torvalds 已提交
339 340 341 342 343 344 345
	int				degraded;	/* whether md should consider
							 * adding a spare
							 */

	atomic_t			recovery_active; /* blocks scheduled, but not written */
	wait_queue_head_t		recovery_wait;
	sector_t			recovery_cp;
346 347
	sector_t			resync_min;	/* user requested sync
							 * starts here */
348 349
	sector_t			resync_max;	/* resync should pause
							 * when it gets here */
350

351 352 353
	struct sysfs_dirent		*sysfs_state;	/* handle for 'array_state'
							 * file in sysfs.
							 */
354
	struct sysfs_dirent		*sysfs_action;  /* handle for 'sync_action' */
355

356 357
	struct work_struct del_work;	/* used for delayed sysfs removal */

358
	spinlock_t			write_lock;
359
	wait_queue_head_t		sb_wait;	/* for waiting on superblock updates */
360
	atomic_t			pending_writes;	/* number of active superblock writes */
361

L
Linus Torvalds 已提交
362 363 364 365 366 367
	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; 
368
	struct request_queue		*queue;	/* for plugging ... */
L
Linus Torvalds 已提交
369

370
	struct bitmap                   *bitmap; /* the bitmap for the device */
371 372
	struct {
		struct file		*file; /* the bitmap file */
373
		loff_t			offset; /* offset from superblock of
374 375
						 * start of bitmap. May be
						 * negative, but not '0'
376 377
						 * For external metadata, offset
						 * from start of device. 
378
						 */
379
		loff_t			default_offset; /* this is the offset to use when
380 381 382 383
							 * hot-adding a bitmap.  It should
							 * eventually be settable by sysfs.
							 */
		struct mutex		mutex;
384
		unsigned long		chunksize;
385
		unsigned long		daemon_sleep; /* how many jiffies between updates? */
386
		unsigned long		max_write_behind; /* write-behind mode */
387
		int			external;
388
	} bitmap_info;
389

390
	atomic_t 			max_corr_read_errors; /* max read retries */
L
Linus Torvalds 已提交
391
	struct list_head		all_mddevs;
392

393
	struct attribute_group		*to_remove;
394

395 396
	struct bio_set			*bio_set;

T
Tejun Heo 已提交
397 398 399
	/* Generic flush handling.
	 * The last to finish preflush schedules a worker to submit
	 * the rest of the request (without the REQ_FLUSH flag).
400
	 */
T
Tejun Heo 已提交
401
	struct bio *flush_bio;
402
	atomic_t flush_pending;
T
Tejun Heo 已提交
403
	struct work_struct flush_work;
404
	struct work_struct event_work;	/* used by dm to report failure event */
405
	void (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
L
Linus Torvalds 已提交
406 407 408 409 410
};


static inline void rdev_dec_pending(mdk_rdev_t *rdev, mddev_t *mddev)
{
411
	int faulty = test_bit(Faulty, &rdev->flags);
L
Linus Torvalds 已提交
412 413 414 415 416 417 418 419 420
	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);
}

421
struct mdk_personality
L
Linus Torvalds 已提交
422 423
{
	char *name;
424 425
	int level;
	struct list_head list;
L
Linus Torvalds 已提交
426
	struct module *owner;
427
	int (*make_request)(mddev_t *mddev, struct bio *bio);
L
Linus Torvalds 已提交
428 429 430 431 432 433 434 435 436 437
	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);
438
	sector_t (*sync_request)(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster);
L
Linus Torvalds 已提交
439
	int (*resize) (mddev_t *mddev, sector_t sectors);
440
	sector_t (*size) (mddev_t *mddev, sector_t sectors, int raid_disks);
441 442
	int (*check_reshape) (mddev_t *mddev);
	int (*start_reshape) (mddev_t *mddev);
443
	void (*finish_reshape) (mddev_t *mddev);
444 445 446 447 448 449
	/* quiesce moves between quiescence states
	 * 0 - fully active
	 * 1 - no new requests allowed
	 * others - reserved
	 */
	void (*quiesce) (mddev_t *mddev, int state);
450 451 452 453 454 455 456 457 458 459
	/* takeover is used to transition an array from one
	 * personality to another.  The new personality must be able
	 * to handle the data in the current layout.
	 * e.g. 2drive raid1 -> 2drive raid5
	 *      ndrive raid5 -> degraded n+1drive raid6 with special layout
	 * If the takeover succeeds, a new 'private' structure is returned.
	 * This needs to be installed and then ->run used to activate the
	 * array.
	 */
	void *(*takeover) (mddev_t *mddev);
L
Linus Torvalds 已提交
460 461 462
};


463 464 465 466 467
struct md_sysfs_entry {
	struct attribute attr;
	ssize_t (*show)(mddev_t *, char *);
	ssize_t (*store)(mddev_t *, const char *, size_t);
};
468
extern struct attribute_group md_bitmap_group;
469

N
NeilBrown 已提交
470 471 472 473 474 475 476 477 478 479 480 481
static inline struct sysfs_dirent *sysfs_get_dirent_safe(struct sysfs_dirent *sd, char *name)
{
	if (sd)
		return sysfs_get_dirent(sd, NULL, name);
	return sd;
}
static inline void sysfs_notify_dirent_safe(struct sysfs_dirent *sd)
{
	if (sd)
		sysfs_notify_dirent(sd);
}

L
Linus Torvalds 已提交
482 483 484 485 486
static inline char * mdname (mddev_t * mddev)
{
	return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
}

487 488 489 490 491 492 493 494 495 496 497 498 499 500
static inline int sysfs_link_rdev(mddev_t *mddev, mdk_rdev_t *rdev)
{
	char nm[20];
	sprintf(nm, "rd%d", rdev->raid_disk);
	return sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
}

static inline void sysfs_unlink_rdev(mddev_t *mddev, mdk_rdev_t *rdev)
{
	char nm[20];
	sprintf(nm, "rd%d", rdev->raid_disk);
	sysfs_remove_link(&mddev->kobj, nm);
}

L
Linus Torvalds 已提交
501 502 503 504
/*
 * iterates through some rdev ringlist. It's safe to remove the
 * current 'rdev'. Dont touch 'tmp' though.
 */
505 506 507
#define rdev_for_each_list(rdev, tmp, head)				\
	list_for_each_entry_safe(rdev, tmp, head, same_set)

L
Linus Torvalds 已提交
508 509 510
/*
 * iterates through the 'same array disks' ringlist
 */
511
#define rdev_for_each(rdev, tmp, mddev)				\
512
	list_for_each_entry_safe(rdev, tmp, &((mddev)->disks), same_set)
L
Linus Torvalds 已提交
513

514 515 516
#define rdev_for_each_rcu(rdev, mddev)				\
	list_for_each_entry_rcu(rdev, &((mddev)->disks), same_set)

L
Linus Torvalds 已提交
517 518 519 520 521 522
typedef struct mdk_thread_s {
	void			(*run) (mddev_t *mddev);
	mddev_t			*mddev;
	wait_queue_head_t	wqueue;
	unsigned long           flags;
	struct task_struct	*tsk;
523
	unsigned long		timeout;
L
Linus Torvalds 已提交
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
} 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)

554 555 556 557 558
static inline void safe_put_page(struct page *p)
{
	if (p) put_page(p);
}

559 560 561 562
extern int register_md_personality(struct mdk_personality *p);
extern int unregister_md_personality(struct mdk_personality *p);
extern mdk_thread_t * md_register_thread(void (*run) (mddev_t *mddev),
				mddev_t *mddev, const char *name);
563
extern void md_unregister_thread(mdk_thread_t **threadp);
564 565 566 567 568 569 570
extern void md_wakeup_thread(mdk_thread_t *thread);
extern void md_check_recovery(mddev_t *mddev);
extern void md_write_start(mddev_t *mddev, struct bio *bi);
extern void md_write_end(mddev_t *mddev);
extern void md_done_sync(mddev_t *mddev, int blocks, int ok);
extern void md_error(mddev_t *mddev, mdk_rdev_t *rdev);

571
extern int mddev_congested(mddev_t *mddev, int bits);
T
Tejun Heo 已提交
572
extern void md_flush_request(mddev_t *mddev, struct bio *bio);
573 574 575
extern void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
			   sector_t sector, int size, struct page *page);
extern void md_super_wait(mddev_t *mddev);
J
Jonathan Brassow 已提交
576 577
extern int sync_page_io(mdk_rdev_t *rdev, sector_t sector, int size, 
			struct page *page, int rw, bool metadata_op);
578 579 580 581
extern void md_do_sync(mddev_t *mddev);
extern void md_new_event(mddev_t *mddev);
extern int md_allow_write(mddev_t *mddev);
extern void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev);
582
extern void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors);
583
extern int md_check_no_bitmap(mddev_t *mddev);
584
extern int md_integrity_register(mddev_t *mddev);
585 586
extern void md_integrity_add_rdev(mdk_rdev_t *rdev, mddev_t *mddev);
extern int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale);
587
extern void restore_bitmap_write_access(struct file *file);
C
Christoph Hellwig 已提交
588

589 590 591 592
extern void mddev_init(mddev_t *mddev);
extern int md_run(mddev_t *mddev);
extern void md_stop(mddev_t *mddev);
extern void md_stop_writes(mddev_t *mddev);
593
extern int md_rdev_init(mdk_rdev_t *rdev);
C
Christoph Hellwig 已提交
594

595 596
extern void mddev_suspend(mddev_t *mddev);
extern void mddev_resume(mddev_t *mddev);
597 598 599 600
extern struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
				   mddev_t *mddev);
extern struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
				   mddev_t *mddev);
601
extern int mddev_check_plugged(mddev_t *mddev);
602
extern void md_trim_bio(struct bio *bio, int offset, int size);
C
Christoph Hellwig 已提交
603
#endif /* _MD_MD_H */