md.h 23.7 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
   md.h : kernel internal structure of the Linux MD driver
L
Linus Torvalds 已提交
3
          Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
4

L
Linus Torvalds 已提交
5 6 7 8
   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.
9

L
Linus Torvalds 已提交
10 11
   You should have received a copy of the GNU General Public License
   (for example /usr/src/linux/COPYING); if not, write to the Free
12
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
L
Linus Torvalds 已提交
13 14
*/

C
Christoph Hellwig 已提交
15 16 17 18
#ifndef _MD_MD_H
#define _MD_MD_H

#include <linux/blkdev.h>
19
#include <linux/backing-dev.h>
C
Christoph Hellwig 已提交
20 21 22 23 24 25 26
#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>
27
#include "md-cluster.h"
28

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

31 32 33 34 35 36 37
/* 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 已提交
38 39 40
/*
 * MD's 'extended' device
 */
41
struct md_rdev {
L
Linus Torvalds 已提交
42 43
	struct list_head same_set;	/* RAID devices within the same set */

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

48 49 50 51 52 53
	/*
	 * 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 已提交
54 55
	struct block_device *bdev;	/* block device handle */

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

65 66
	struct kobject	kobj;

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

78
	unsigned long	flags;	/* bit set of 'enum flag_bits' bits. */
79
	wait_queue_head_t blocked_wait;
80

L
Linus Torvalds 已提交
81 82
	int desc_nr;			/* descriptor index in the superblock */
	int raid_disk;			/* role of device in array */
83 84 85
	int new_raid_disk;		/* role that the device will have in
					 * the array after a level-change completes.
					 */
86 87 88 89
	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
					 */
90 91
	union {
		sector_t recovery_offset;/* If this device has been partially
92 93 94
					 * recovered, this is where we were
					 * up to.
					 */
95 96 97 98 99
		sector_t journal_tail;	/* If this device is a journal device,
					 * this is the journal tail (journal
					 * recovery start point)
					 */
	};
L
Linus Torvalds 已提交
100 101 102 103 104

	atomic_t	nr_pending;	/* number of pending requests.
					 * only maintained for arrays that
					 * support hot removal
					 */
105 106 107
	atomic_t	read_errors;	/* number of consecutive read errors that
					 * we have tried to ignore.
					 */
108 109 110
	struct timespec last_read_error;	/* monotonic time since our
						 * last read error
						 */
111 112 113 114
	atomic_t	corrected_errors; /* number of corrected read errors,
					   * for reporting to userspace and storing
					   * in superblock.
					   */
115
	struct work_struct del_work;	/* used for delayed sysfs removal */
116

117
	struct kernfs_node *sysfs_state; /* handle for 'state'
118
					   * sysfs entry */
119 120 121

	struct badblocks {
		int	count;		/* count of bad blocks */
122 123 124 125
		int	unacked_exist;	/* there probably are unacknowledged
					 * bad blocks.  This is only cleared
					 * when a read discovers none
					 */
126 127 128 129 130 131
		int	shift;		/* shift from sectors to block size
					 * a -ve shift means badblocks are
					 * disabled.*/
		u64	*page;		/* badblock list */
		int	changed;
		seqlock_t lock;
132 133 134

		sector_t sector;
		sector_t size;		/* in sectors */
135
	} badblocks;
L
Linus Torvalds 已提交
136
};
137 138 139
enum flag_bits {
	Faulty,			/* device is known to have a fault */
	In_sync,		/* device is in_sync with rest of array */
140 141 142
	Bitmap_sync,		/* ..actually, not quite In_sync.  Need a
				 * bitmap-based recovery to get fully in sync
				 */
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
	WriteMostly,		/* Avoid reading if at all possible */
	AutoDetected,		/* added by auto-detect */
	Blocked,		/* An error occurred but has not yet
				 * been acknowledged by the metadata
				 * handler, so don't allow writes
				 * until it is cleared */
	WriteErrorSeen,		/* A write error has been seen on this
				 * device
				 */
	FaultRecorded,		/* 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.
				 */
	BlockedBadBlocks,	/* 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.
				 */
	WantReplacement,	/* This device is a candidate to be
				 * hot-replaced, either because it has
				 * reported some faults, or because
				 * of explicit request.
				 */
	Replacement,		/* This device is a replacement for
				 * a want_replacement device with same
				 * raid_disk number.
				 */
177 178 179 180
	Candidate,		/* For clustered environments only:
				 * This device is seen locally but not
				 * by the whole cluster
				 */
181 182 183 184 185
	Journal,		/* This device is used as journal for
				 * raid-5/6.
				 * Usually, this device should be faster
				 * than other devices in the array
				 */
186
	ClusterRemove,
187
};
L
Linus Torvalds 已提交
188

189 190 191 192 193 194 195 196 197 198 199
#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);
200
static inline int is_badblock(struct md_rdev *rdev, sector_t s, int sectors,
201 202 203 204 205 206 207 208 209 210 211 212
			      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;
}
213
extern int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
214 215 216
			      int is_new);
extern int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
				int is_new);
217 218
extern void md_ack_all_badblocks(struct badblocks *bb);

G
Goldwyn Rodrigues 已提交
219 220
struct md_cluster_info;

221
struct mddev {
L
Linus Torvalds 已提交
222
	void				*private;
223
	struct md_personality		*pers;
L
Linus Torvalds 已提交
224 225
	dev_t				unit;
	int				md_minor;
226
	struct list_head		disks;
227 228 229
	unsigned long			flags;
#define MD_CHANGE_DEVS	0	/* Some device status has changed */
#define MD_CHANGE_CLEAN 1	/* transition to or from 'clean' */
230
#define MD_CHANGE_PENDING 2	/* switch from 'clean' to 'active' in progress */
231
#define MD_UPDATE_SB_FLAGS (1 | 2 | 4)	/* If these are set, md_update_sb needed */
232
#define MD_ARRAY_FIRST_USE 3    /* First use of array, needs initialization */
233 234 235
#define MD_STILL_CLOSED	4	/* If set, then array has not been opened since
				 * md_ioctl checked on it.
				 */
236
#define MD_JOURNAL_CLEAN 5	/* A raid with journal is already clean */
237
#define MD_HAS_JOURNAL	6	/* The raid array has journal feature set */
238 239 240
#define MD_RELOAD_SB	7	/* Reload the superblock because another node
				 * updated it.
				 */
241

242 243
	int				suspended;
	atomic_t			active_io;
L
Linus Torvalds 已提交
244
	int				ro;
245 246 247 248
	int				sysfs_active; /* set when sysfs deletes
						       * are happening, so run/
						       * takeover/stop are not safe
						       */
L
Linus Torvalds 已提交
249 250
	struct gendisk			*gendisk;

251
	struct kobject			kobj;
252 253
	int				hold_active;
#define	UNTIL_IOCTL	1
254
#define	UNTIL_STOP	2
255

L
Linus Torvalds 已提交
256 257 258 259 260
	/* Superblock information */
	int				major_version,
					minor_version,
					patch_version;
	int				persistent;
261
	int				external;	/* metadata is
262 263
							 * managed externally */
	char				metadata_type[17]; /* externally set*/
264
	int				chunk_sectors;
265
	time64_t			ctime, utime;
L
Linus Torvalds 已提交
266
	int				level, layout;
267
	char				clevel[16];
L
Linus Torvalds 已提交
268 269
	int				raid_disks;
	int				max_disks;
270
	sector_t			dev_sectors;	/* used size of
A
Andre Noll 已提交
271
							 * component devices */
272
	sector_t			array_sectors; /* exported array size */
D
Dan Williams 已提交
273 274
	int				external_size; /* size managed
							* externally */
L
Linus Torvalds 已提交
275
	__u64				events;
276 277 278 279 280 281
	/* 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 已提交
282 283 284

	char				uuid[16];

285 286 287 288 289 290
	/* 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;
291 292
	int				delta_disks, new_level, new_layout;
	int				new_chunk_sectors;
293
	int				reshape_backwards;
294

295 296
	struct md_thread		*thread;	/* management thread */
	struct md_thread		*sync_thread;	/* doing resync or reconstruct */
297 298 299 300 301 302 303 304

	/* 'last_sync_action' is initialized to "none".  It is set when a
	 * sync operation (i.e "data-check", "requested-resync", "resync",
	 * "recovery", or "reshape") is started.  It holds this value even
	 * when the sync thread is "frozen" (interrupted) or "idle" (stopped
	 * or finished).  It is overwritten when a new sync operation is begun.
	 */
	char				*last_sync_action;
305
	sector_t			curr_resync;	/* last block scheduled */
306 307 308 309 310 311 312
	/* 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 已提交
313 314
	unsigned long			resync_mark;	/* a recent timestamp */
	sector_t			resync_mark_cnt;/* blocks written at resync_mark */
315
	sector_t			curr_mark_cnt; /* blocks scheduled now */
L
Linus Torvalds 已提交
316 317

	sector_t			resync_max_sectors; /* may be set by personality */
318

319
	atomic64_t			resync_mismatches; /* count of sectors where
320 321
							    * parity/replica mismatch found
							    */
322 323 324 325

	/* allow user-space to request suspension of IO to regions of the array */
	sector_t			suspend_lo;
	sector_t			suspend_hi;
326 327 328 329
	/* if zero, use the system-wide default */
	int				sync_speed_min;
	int				sync_speed_max;

330 331 332
	/* resync even though the same disks are shared among md-devices */
	int				parallel_resync;

333
	int				ok_start_degraded;
334
	/* recovery/resync flags
L
Linus Torvalds 已提交
335 336 337
	 * 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
338
	 * RECOVER:  doing recovery, or need to try it.
339
	 * INTR:     resync needs to be aborted for some reason
L
Linus Torvalds 已提交
340
	 * DONE:     thread is done and is waiting to be reaped
341
	 * REQUEST:  user-space has requested a sync (used with SYNC)
342
	 * CHECK:    user-space request for check-only, no repair
343
	 * RESHAPE:  A reshape is happening
344
	 * ERROR:    sync-action interrupted because io-error
345 346
	 *
	 * If neither SYNC or RESHAPE are set, then it is a recovery.
L
Linus Torvalds 已提交
347 348 349
	 */
#define	MD_RECOVERY_RUNNING	0
#define	MD_RECOVERY_SYNC	1
350
#define	MD_RECOVERY_RECOVER	2
L
Linus Torvalds 已提交
351 352 353
#define	MD_RECOVERY_INTR	3
#define	MD_RECOVERY_DONE	4
#define	MD_RECOVERY_NEEDED	5
354 355
#define	MD_RECOVERY_REQUESTED	6
#define	MD_RECOVERY_CHECK	7
356
#define MD_RECOVERY_RESHAPE	8
357
#define	MD_RECOVERY_FROZEN	9
358
#define	MD_RECOVERY_ERROR	10
359

L
Linus Torvalds 已提交
360
	unsigned long			recovery;
361 362 363 364 365 366
	/* 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 已提交
367 368

	int				in_sync;	/* know to not need resync */
N
NeilBrown 已提交
369 370 371 372 373 374 375 376 377 378
	/* '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;
379
	struct mutex			reconfig_mutex;
380 381
	atomic_t			active;		/* general refcount */
	atomic_t			openers;	/* number of active opens */
L
Linus Torvalds 已提交
382

383 384
	int				changed;	/* True if we might need to
							 * reread partition info */
L
Linus Torvalds 已提交
385 386 387 388 389 390 391
	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;
392 393
	sector_t			resync_min;	/* user requested sync
							 * starts here */
394 395
	sector_t			resync_max;	/* resync should pause
							 * when it gets here */
396

397
	struct kernfs_node		*sysfs_state;	/* handle for 'array_state'
398 399
							 * file in sysfs.
							 */
400
	struct kernfs_node		*sysfs_action;  /* handle for 'sync_action' */
401

402 403
	struct work_struct del_work;	/* used for delayed sysfs removal */

404 405 406 407 408
	/* "lock" protects:
	 *   flush_bio transition from NULL to !NULL
	 *   rdev superblocks, events
	 *   clearing MD_CHANGE_*
	 *   in_sync - and related safemode and MD_CHANGE changes
409
	 *   pers (also protected by reconfig_mutex and pending IO).
410
	 *   clearing ->bitmap
411
	 *   clearing ->bitmap_info.file
412 413
	 *   changing ->resync_{min,max}
	 *   setting MD_RECOVERY_RUNNING (which interacts with resync_{min,max})
414 415
	 */
	spinlock_t			lock;
416
	wait_queue_head_t		sb_wait;	/* for waiting on superblock updates */
417
	atomic_t			pending_writes;	/* number of active superblock writes */
418

L
Linus Torvalds 已提交
419 420
	unsigned int			safemode;	/* if set, update "clean" superblock
							 * when no writes pending.
421
							 */
L
Linus Torvalds 已提交
422 423
	unsigned int			safemode_delay;
	struct timer_list		safemode_timer;
424
	atomic_t			writes_pending;
425
	struct request_queue		*queue;	/* for plugging ... */
L
Linus Torvalds 已提交
426

427
	struct bitmap			*bitmap; /* the bitmap for the device */
428 429
	struct {
		struct file		*file; /* the bitmap file */
430
		loff_t			offset; /* offset from superblock of
431 432
						 * start of bitmap. May be
						 * negative, but not '0'
433
						 * For external metadata, offset
434
						 * from start of device.
435
						 */
436
		unsigned long		space; /* space available at this offset */
437
		loff_t			default_offset; /* this is the offset to use when
438 439 440
							 * hot-adding a bitmap.  It should
							 * eventually be settable by sysfs.
							 */
441 442
		unsigned long		default_space; /* space available at
							* default offset */
443
		struct mutex		mutex;
444
		unsigned long		chunksize;
445
		unsigned long		daemon_sleep; /* how many jiffies between updates? */
446
		unsigned long		max_write_behind; /* write-behind mode */
447
		int			external;
G
Goldwyn Rodrigues 已提交
448
		int			nodes; /* Maximum number of nodes in the cluster */
G
Goldwyn Rodrigues 已提交
449
		char                    cluster_name[64]; /* Name of the cluster */
450
	} bitmap_info;
451

452
	atomic_t			max_corr_read_errors; /* max read retries */
L
Linus Torvalds 已提交
453
	struct list_head		all_mddevs;
454

455
	struct attribute_group		*to_remove;
456

457 458
	struct bio_set			*bio_set;

T
Tejun Heo 已提交
459 460 461
	/* Generic flush handling.
	 * The last to finish preflush schedules a worker to submit
	 * the rest of the request (without the REQ_FLUSH flag).
462
	 */
T
Tejun Heo 已提交
463
	struct bio *flush_bio;
464
	atomic_t flush_pending;
T
Tejun Heo 已提交
465
	struct work_struct flush_work;
466
	struct work_struct event_work;	/* used by dm to report failure event */
467
	void (*sync_super)(struct mddev *mddev, struct md_rdev *rdev);
G
Goldwyn Rodrigues 已提交
468
	struct md_cluster_info		*cluster_info;
469
	unsigned int			good_device_nr;	/* good device num within cluster raid */
L
Linus Torvalds 已提交
470 471
};

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
static inline int __must_check mddev_lock(struct mddev *mddev)
{
	return mutex_lock_interruptible(&mddev->reconfig_mutex);
}

/* Sometimes we need to take the lock in a situation where
 * failure due to interrupts is not acceptable.
 */
static inline void mddev_lock_nointr(struct mddev *mddev)
{
	mutex_lock(&mddev->reconfig_mutex);
}

static inline int mddev_is_locked(struct mddev *mddev)
{
	return mutex_is_locked(&mddev->reconfig_mutex);
}

static inline int mddev_trylock(struct mddev *mddev)
{
	return mutex_trylock(&mddev->reconfig_mutex);
}
extern void mddev_unlock(struct mddev *mddev);

L
Linus Torvalds 已提交
496 497
static inline void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors)
{
498
	atomic_add(nr_sectors, &bdev->bd_contains->bd_disk->sync_io);
L
Linus Torvalds 已提交
499 500
}

501
struct md_personality
L
Linus Torvalds 已提交
502 503
{
	char *name;
504 505
	int level;
	struct list_head list;
L
Linus Torvalds 已提交
506
	struct module *owner;
507
	void (*make_request)(struct mddev *mddev, struct bio *bio);
508
	int (*run)(struct mddev *mddev);
N
NeilBrown 已提交
509
	void (*free)(struct mddev *mddev, void *priv);
510
	void (*status)(struct seq_file *seq, struct mddev *mddev);
L
Linus Torvalds 已提交
511
	/* error_handler must set ->faulty and clear ->in_sync
512
	 * if appropriate, and should abort recovery if needed
L
Linus Torvalds 已提交
513
	 */
514 515
	void (*error_handler)(struct mddev *mddev, struct md_rdev *rdev);
	int (*hot_add_disk) (struct mddev *mddev, struct md_rdev *rdev);
516
	int (*hot_remove_disk) (struct mddev *mddev, struct md_rdev *rdev);
517
	int (*spare_active) (struct mddev *mddev);
518
	sector_t (*sync_request)(struct mddev *mddev, sector_t sector_nr, int *skipped);
519 520 521 522 523
	int (*resize) (struct mddev *mddev, sector_t sectors);
	sector_t (*size) (struct mddev *mddev, sector_t sectors, int raid_disks);
	int (*check_reshape) (struct mddev *mddev);
	int (*start_reshape) (struct mddev *mddev);
	void (*finish_reshape) (struct mddev *mddev);
524 525 526 527 528
	/* quiesce moves between quiescence states
	 * 0 - fully active
	 * 1 - no new requests allowed
	 * others - reserved
	 */
529
	void (*quiesce) (struct mddev *mddev, int state);
530 531 532 533 534 535 536 537 538
	/* 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.
	 */
539
	void *(*takeover) (struct mddev *mddev);
540 541 542
	/* congested implements bdi.congested_fn().
	 * Will not be called while array is 'suspended' */
	int (*congested)(struct mddev *mddev, int bits);
L
Linus Torvalds 已提交
543 544
};

545 546
struct md_sysfs_entry {
	struct attribute attr;
547 548
	ssize_t (*show)(struct mddev *, char *);
	ssize_t (*store)(struct mddev *, const char *, size_t);
549
};
550
extern struct attribute_group md_bitmap_group;
551

552
static inline struct kernfs_node *sysfs_get_dirent_safe(struct kernfs_node *sd, char *name)
N
NeilBrown 已提交
553 554
{
	if (sd)
T
Tejun Heo 已提交
555
		return sysfs_get_dirent(sd, name);
N
NeilBrown 已提交
556 557
	return sd;
}
558
static inline void sysfs_notify_dirent_safe(struct kernfs_node *sd)
N
NeilBrown 已提交
559 560 561 562 563
{
	if (sd)
		sysfs_notify_dirent(sd);
}

564
static inline char * mdname (struct mddev * mddev)
L
Linus Torvalds 已提交
565 566 567 568
{
	return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
}

569
static inline int sysfs_link_rdev(struct mddev *mddev, struct md_rdev *rdev)
570 571
{
	char nm[20];
572 573 574
	if (!test_bit(Replacement, &rdev->flags) &&
	    !test_bit(Journal, &rdev->flags) &&
	    mddev->kobj.sd) {
575 576 577 578
		sprintf(nm, "rd%d", rdev->raid_disk);
		return sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
	} else
		return 0;
579 580
}

581
static inline void sysfs_unlink_rdev(struct mddev *mddev, struct md_rdev *rdev)
582 583
{
	char nm[20];
584 585 586
	if (!test_bit(Replacement, &rdev->flags) &&
	    !test_bit(Journal, &rdev->flags) &&
	    mddev->kobj.sd) {
587 588 589
		sprintf(nm, "rd%d", rdev->raid_disk);
		sysfs_remove_link(&mddev->kobj, nm);
	}
590 591
}

L
Linus Torvalds 已提交
592 593 594 595
/*
 * iterates through some rdev ringlist. It's safe to remove the
 * current 'rdev'. Dont touch 'tmp' though.
 */
596 597 598
#define rdev_for_each_list(rdev, tmp, head)				\
	list_for_each_entry_safe(rdev, tmp, head, same_set)

L
Linus Torvalds 已提交
599 600 601
/*
 * iterates through the 'same array disks' ringlist
 */
N
NeilBrown 已提交
602 603 604 605
#define rdev_for_each(rdev, mddev)				\
	list_for_each_entry(rdev, &((mddev)->disks), same_set)

#define rdev_for_each_safe(rdev, tmp, mddev)				\
606
	list_for_each_entry_safe(rdev, tmp, &((mddev)->disks), same_set)
L
Linus Torvalds 已提交
607

608 609 610
#define rdev_for_each_rcu(rdev, mddev)				\
	list_for_each_entry_rcu(rdev, &((mddev)->disks), same_set)

611
struct md_thread {
S
Shaohua Li 已提交
612
	void			(*run) (struct md_thread *thread);
613
	struct mddev		*mddev;
L
Linus Torvalds 已提交
614
	wait_queue_head_t	wqueue;
615
	unsigned long		flags;
L
Linus Torvalds 已提交
616
	struct task_struct	*tsk;
617
	unsigned long		timeout;
S
Shaohua Li 已提交
618
	void			*private;
619
};
L
Linus Torvalds 已提交
620 621 622

#define THREAD_WAKEUP  0

623 624 625 626 627
static inline void safe_put_page(struct page *p)
{
	if (p) put_page(p);
}

628 629
extern int register_md_personality(struct md_personality *p);
extern int unregister_md_personality(struct md_personality *p);
630 631 632 633 634
extern int register_md_cluster_operations(struct md_cluster_operations *ops,
		struct module *module);
extern int unregister_md_cluster_operations(void);
extern int md_setup_cluster(struct mddev *mddev, int nodes);
extern void md_cluster_stop(struct mddev *mddev);
635
extern struct md_thread *md_register_thread(
S
Shaohua Li 已提交
636
	void (*run)(struct md_thread *thread),
637 638 639 640
	struct mddev *mddev,
	const char *name);
extern void md_unregister_thread(struct md_thread **threadp);
extern void md_wakeup_thread(struct md_thread *thread);
641
extern void md_check_recovery(struct mddev *mddev);
642
extern void md_reap_sync_thread(struct mddev *mddev);
643 644 645 646
extern void md_write_start(struct mddev *mddev, struct bio *bi);
extern void md_write_end(struct mddev *mddev);
extern void md_done_sync(struct mddev *mddev, int blocks, int ok);
extern void md_error(struct mddev *mddev, struct md_rdev *rdev);
647
extern void md_finish_reshape(struct mddev *mddev);
648 649 650 651

extern int mddev_congested(struct mddev *mddev, int bits);
extern void md_flush_request(struct mddev *mddev, struct bio *bio);
extern void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
652
			   sector_t sector, int size, struct page *page);
653
extern void md_super_wait(struct mddev *mddev);
654
extern int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
J
Jonathan Brassow 已提交
655
			struct page *page, int rw, bool metadata_op);
S
Shaohua Li 已提交
656
extern void md_do_sync(struct md_thread *thread);
657 658 659 660 661 662 663
extern void md_new_event(struct mddev *mddev);
extern int md_allow_write(struct mddev *mddev);
extern void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev);
extern void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors);
extern int md_check_no_bitmap(struct mddev *mddev);
extern int md_integrity_register(struct mddev *mddev);
extern void md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev);
664
extern int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale);
C
Christoph Hellwig 已提交
665

666 667 668 669
extern void mddev_init(struct mddev *mddev);
extern int md_run(struct mddev *mddev);
extern void md_stop(struct mddev *mddev);
extern void md_stop_writes(struct mddev *mddev);
670
extern int md_rdev_init(struct md_rdev *rdev);
671
extern void md_rdev_clear(struct md_rdev *rdev);
C
Christoph Hellwig 已提交
672

673 674
extern void mddev_suspend(struct mddev *mddev);
extern void mddev_resume(struct mddev *mddev);
675
extern struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
676
				   struct mddev *mddev);
677
extern struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
678
				   struct mddev *mddev);
679

680
extern void md_unplug(struct blk_plug_cb *cb, bool from_schedule);
681
extern void md_reload_sb(struct mddev *mddev, int raid_disk);
682
extern void md_update_sb(struct mddev *mddev, int force);
683
extern void md_kick_rdev_from_array(struct md_rdev * rdev);
684
struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr);
685 686 687 688 689
static inline int mddev_check_plugged(struct mddev *mddev)
{
	return !!blk_check_plugged(md_unplug, mddev,
				   sizeof(struct blk_plug_cb));
}
690 691 692 693 694 695 696 697 698 699

static inline void rdev_dec_pending(struct md_rdev *rdev, struct mddev *mddev)
{
	int faulty = test_bit(Faulty, &rdev->flags);
	if (atomic_dec_and_test(&rdev->nr_pending) && faulty) {
		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
		md_wakeup_thread(mddev->thread);
	}
}

700
extern struct md_cluster_operations *md_cluster_ops;
G
Goldwyn Rodrigues 已提交
701 702 703 704
static inline int mddev_is_clustered(struct mddev *mddev)
{
	return mddev->cluster_info && mddev->bitmap_info.nodes > 1;
}
C
Christoph Hellwig 已提交
705
#endif /* _MD_MD_H */