md.h 28.6 KB
Newer Older
1
/* SPDX-License-Identifier: GPL-2.0-or-later */
L
Linus Torvalds 已提交
2
/*
3
   md.h : kernel internal structure of the Linux MD driver
L
Linus Torvalds 已提交
4
          Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
5

L
Linus Torvalds 已提交
6 7
*/

C
Christoph Hellwig 已提交
8 9 10 11
#ifndef _MD_MD_H
#define _MD_MD_H

#include <linux/blkdev.h>
12
#include <linux/backing-dev.h>
13
#include <linux/badblocks.h>
C
Christoph Hellwig 已提交
14 15 16 17 18 19 20
#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>
21
#include "md-cluster.h"
22

L
Linus Torvalds 已提交
23 24
#define MaxSector (~(sector_t)0)

25 26 27 28 29 30 31 32 33 34
/*
 * These flags should really be called "NO_RETRY" rather than
 * "FAILFAST" because they don't make any promise about time lapse,
 * only about the number of retries, which will be zero.
 * REQ_FAILFAST_DRIVER is not included because
 * Commit: 4a27446f3e39 ("[SCSI] modify scsi to handle new fail fast flags.")
 * seems to suggest that the errors it avoids retrying should usually
 * be retried.
 */
#define	MD_FAILFAST	(REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT)
35 36 37 38 39 40 41 42 43 44

/*
 * The struct embedded in rdev is used to serialize IO.
 */
struct serial_in_rdev {
	struct rb_root_cached serial_rb;
	spinlock_t serial_lock;
	wait_queue_head_t serial_io_wait;
};

L
Linus Torvalds 已提交
45 46 47
/*
 * MD's 'extended' device
 */
48
struct md_rdev {
L
Linus Torvalds 已提交
49 50
	struct list_head same_set;	/* RAID devices within the same set */

51
	sector_t sectors;		/* Device size (in 512bytes sectors) */
52
	struct mddev *mddev;		/* RAID array if running */
53
	long long last_events;		/* IO event timestamp */
L
Linus Torvalds 已提交
54

55 56 57 58 59 60
	/*
	 * 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 已提交
61 62
	struct block_device *bdev;	/* block device handle */

63
	struct page	*sb_page, *bb_page;
L
Linus Torvalds 已提交
64
	int		sb_loaded;
65
	__u64		sb_events;
L
Linus Torvalds 已提交
66
	sector_t	data_offset;	/* start of data in array */
67
	sector_t	new_data_offset;/* only relevant while reshaping */
68
	sector_t	sb_start;	/* offset of the super block (in 512byte sectors) */
69
	int		sb_size;	/* bytes in the superblock */
L
Linus Torvalds 已提交
70 71
	int		preferred_minor;	/* autorun support */

72 73
	struct kobject	kobj;

L
Linus Torvalds 已提交
74 75 76 77 78 79 80 81 82 83 84
	/* 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
	 */

85
	unsigned long	flags;	/* bit set of 'enum flag_bits' bits. */
86
	wait_queue_head_t blocked_wait;
87

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

	atomic_t	nr_pending;	/* number of pending requests.
					 * only maintained for arrays that
					 * support hot removal
					 */
112 113 114
	atomic_t	read_errors;	/* number of consecutive read errors that
					 * we have tried to ignore.
					 */
115
	time64_t	last_read_error;	/* monotonic time since our
116 117
						 * last read error
						 */
118 119 120 121
	atomic_t	corrected_errors; /* number of corrected read errors,
					   * for reporting to userspace and storing
					   * in superblock.
					   */
122

123
	struct serial_in_rdev *serial;  /* used for raid1 io serialization */
124

125
	struct work_struct del_work;	/* used for delayed sysfs removal */
126

127
	struct kernfs_node *sysfs_state; /* handle for 'state'
128
					   * sysfs entry */
129 130 131 132
	/* handle for 'unacknowledged_bad_blocks' sysfs dentry */
	struct kernfs_node *sysfs_unack_badblocks;
	/* handle for 'bad_blocks' sysfs dentry */
	struct kernfs_node *sysfs_badblocks;
133
	struct badblocks badblocks;
134 135 136 137 138 139 140

	struct {
		short offset;	/* Offset from superblock to start of PPL.
				 * Not used by external metadata. */
		unsigned int size;	/* Size in sectors of the PPL space */
		sector_t sector;	/* First sector of the PPL space */
	} ppl;
L
Linus Torvalds 已提交
141
};
142 143 144
enum flag_bits {
	Faulty,			/* device is known to have a fault */
	In_sync,		/* device is in_sync with rest of array */
145
	Bitmap_sync,		/* ..actually, not quite In_sync.  Need a
146 147 148
				 * bitmap-based recovery to get fully in sync.
				 * The bit is only meaningful before device
				 * has been passed to pers->hot_add_disk.
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 177 178 179 180 181 182 183
	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.
				 */
184 185 186 187
	Candidate,		/* For clustered environments only:
				 * This device is seen locally but not
				 * by the whole cluster
				 */
188 189 190 191 192
	Journal,		/* This device is used as journal for
				 * raid-5/6.
				 * Usually, this device should be faster
				 * than other devices in the array
				 */
193
	ClusterRemove,
194 195 196 197 198
	RemoveSynchronized,	/* synchronize_rcu() was called after
				 * this device was known to be faulty,
				 * so it is safe to remove without
				 * another synchronize_rcu() call.
				 */
199 200 201
	ExternalBbl,            /* External metadata provides bad
				 * block management for a disk
				 */
202 203 204 205 206 207
	FailFast,		/* Minimal retries should be attempted on
				 * this device, so use REQ_FAILFAST_DEV.
				 * Also don't try to repair failed reads.
				 * It is expects that no bad block log
				 * is present.
				 */
208 209 210 211
	LastDev,		/* Seems to be the last working dev as
				 * it didn't fail, so don't use FailFast
				 * any more for metadata
				 */
G
Guoqing Jiang 已提交
212 213 214
	CollisionCheck,		/*
				 * check if there is collision between raid1
				 * serial bios.
215
				 */
216 217 218 219
	WantRemove,		/* Before set conf->mirrors[i] as NULL,
				 * we set the bit first, avoiding access the
				 * conf->mirrors[i] after it set NULL.
				 */
220
};
L
Linus Torvalds 已提交
221

222
static inline int is_badblock(struct md_rdev *rdev, sector_t s, int sectors,
223 224 225
			      sector_t *first_bad, int *bad_sectors)
{
	if (unlikely(rdev->badblocks.count)) {
226
		int rv = badblocks_check(&rdev->badblocks, rdev->data_offset + s,
227 228 229 230 231 232 233 234
					sectors,
					first_bad, bad_sectors);
		if (rv)
			*first_bad -= rdev->data_offset;
		return rv;
	}
	return 0;
}
235
extern int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
236 237 238
			      int is_new);
extern int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
				int is_new);
G
Goldwyn Rodrigues 已提交
239 240
struct md_cluster_info;

241
/* change UNSUPPORTED_MDDEV_FLAGS for each array type if new flag is added */
242 243 244 245 246 247 248 249 250
enum mddev_flags {
	MD_ARRAY_FIRST_USE,	/* First use of array, needs initialization */
	MD_CLOSING,		/* If set, we are closing the array, do not open
				 * it then */
	MD_JOURNAL_CLEAN,	/* A raid with journal is already clean */
	MD_HAS_JOURNAL,		/* The raid array has journal feature set */
	MD_CLUSTER_RESYNC_LOCKED, /* cluster raid only, which means node
				   * already took resync lock, need to
				   * release the lock */
251 252 253 254
	MD_FAILFAST_SUPPORTED,	/* Using MD_FAILFAST on metadata writes is
				 * supported as calls to md_error() will
				 * never cause the array to become failed.
				 */
255
	MD_HAS_PPL,		/* The raid array has PPL feature set */
256
	MD_HAS_MULTIPLE_PPLS,	/* The raid array has multiple PPLs feature set */
257 258 259 260 261 262
	MD_ALLOW_SB_UPDATE,	/* md_check_recovery is allowed to update
				 * the metadata without taking reconfig_mutex.
				 */
	MD_UPDATING_SB,		/* md_check_recovery is updating the metadata
				 * without explicitly holding reconfig_mutex.
				 */
263 264 265
	MD_NOT_READY,		/* do_md_run() is active, so 'array_state'
				 * must not report that array is ready yet
				 */
266 267 268
	MD_BROKEN,              /* This is used in RAID-0/LINEAR only, to stop
				 * I/O in case an array member is gone/failed.
				 */
269
};
270 271 272 273 274 275 276 277

enum mddev_sb_flags {
	MD_SB_CHANGE_DEVS,		/* Some device status has changed */
	MD_SB_CHANGE_CLEAN,	/* transition to or from 'clean' */
	MD_SB_CHANGE_PENDING,	/* switch from 'clean' to 'active' in progress */
	MD_SB_NEED_REWRITE,	/* metadata write needs to be repeated */
};

G
Guoqing Jiang 已提交
278 279 280
#define NR_SERIAL_INFOS		8
/* record current range of serialize IOs */
struct serial_info {
281 282 283 284
	struct rb_node node;
	sector_t start;		/* start sector of rb node */
	sector_t last;		/* end sector of rb node */
	sector_t _subtree_last; /* highest sector in subtree of rb node */
285 286
};

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
/*
 * mddev->curr_resync stores the current sector of the resync but
 * also has some overloaded values.
 */
enum {
	/* No resync in progress */
	MD_RESYNC_NONE = 0,
	/* Yielded to allow another conflicting resync to commence */
	MD_RESYNC_YIELDED = 1,
	/* Delayed to check that there is no conflict with another sync */
	MD_RESYNC_DELAYED = 2,
	/* Any value greater than or equal to this is in an active resync */
	MD_RESYNC_ACTIVE = 3,
};

302
struct mddev {
L
Linus Torvalds 已提交
303
	void				*private;
304
	struct md_personality		*pers;
L
Linus Torvalds 已提交
305 306
	dev_t				unit;
	int				md_minor;
307
	struct list_head		disks;
308
	unsigned long			flags;
309
	unsigned long			sb_flags;
310

311 312
	int				suspended;
	atomic_t			active_io;
L
Linus Torvalds 已提交
313
	int				ro;
314 315 316 317
	int				sysfs_active; /* set when sysfs deletes
						       * are happening, so run/
						       * takeover/stop are not safe
						       */
L
Linus Torvalds 已提交
318 319
	struct gendisk			*gendisk;

320
	struct kobject			kobj;
321 322
	int				hold_active;
#define	UNTIL_IOCTL	1
323
#define	UNTIL_STOP	2
324

L
Linus Torvalds 已提交
325 326 327 328 329
	/* Superblock information */
	int				major_version,
					minor_version,
					patch_version;
	int				persistent;
330
	int				external;	/* metadata is
331 332
							 * managed externally */
	char				metadata_type[17]; /* externally set*/
333
	int				chunk_sectors;
334
	time64_t			ctime, utime;
L
Linus Torvalds 已提交
335
	int				level, layout;
336
	char				clevel[16];
L
Linus Torvalds 已提交
337 338
	int				raid_disks;
	int				max_disks;
339
	sector_t			dev_sectors;	/* used size of
A
Andre Noll 已提交
340
							 * component devices */
341
	sector_t			array_sectors; /* exported array size */
D
Dan Williams 已提交
342 343
	int				external_size; /* size managed
							* externally */
L
Linus Torvalds 已提交
344
	__u64				events;
345 346 347 348 349 350
	/* 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 已提交
351 352 353

	char				uuid[16];

354 355 356 357 358 359
	/* 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;
360
	int				delta_disks, new_level, new_layout;
361
	int				new_chunk_sectors;
362
	int				reshape_backwards;
363

364 365
	struct md_thread		*thread;	/* management thread */
	struct md_thread		*sync_thread;	/* doing resync or reconstruct */
366 367 368 369 370 371 372 373

	/* '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;
374
	sector_t			curr_resync;	/* last block scheduled */
375 376 377 378 379 380 381
	/* 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 已提交
382 383
	unsigned long			resync_mark;	/* a recent timestamp */
	sector_t			resync_mark_cnt;/* blocks written at resync_mark */
384
	sector_t			curr_mark_cnt; /* blocks scheduled now */
L
Linus Torvalds 已提交
385 386

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

388
	atomic64_t			resync_mismatches; /* count of sectors where
389 390
							    * parity/replica mismatch found
							    */
391 392 393 394

	/* allow user-space to request suspension of IO to regions of the array */
	sector_t			suspend_lo;
	sector_t			suspend_hi;
395 396 397 398
	/* if zero, use the system-wide default */
	int				sync_speed_min;
	int				sync_speed_max;

399 400 401
	/* resync even though the same disks are shared among md-devices */
	int				parallel_resync;

402
	int				ok_start_degraded;
403

L
Linus Torvalds 已提交
404
	unsigned long			recovery;
405 406 407 408 409 410
	/* 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 已提交
411 412

	int				in_sync;	/* know to not need resync */
N
NeilBrown 已提交
413 414 415 416 417 418
	/* '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:
419
	 *  reconfig_mutex -> bd_mutex
N
NeilBrown 已提交
420 421 422
	 *  bd_mutex -> open_mutex:  e.g. __blkdev_get -> md_open
	 */
	struct mutex			open_mutex;
423
	struct mutex			reconfig_mutex;
424 425
	atomic_t			active;		/* general refcount */
	atomic_t			openers;	/* number of active opens */
L
Linus Torvalds 已提交
426

427 428
	int				changed;	/* True if we might need to
							 * reread partition info */
L
Linus Torvalds 已提交
429 430 431 432 433 434 435
	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;
436 437
	sector_t			resync_min;	/* user requested sync
							 * starts here */
438 439
	sector_t			resync_max;	/* resync should pause
							 * when it gets here */
440

441
	struct kernfs_node		*sysfs_state;	/* handle for 'array_state'
442 443
							 * file in sysfs.
							 */
444
	struct kernfs_node		*sysfs_action;  /* handle for 'sync_action' */
445 446 447
	struct kernfs_node		*sysfs_completed;	/*handle for 'sync_completed' */
	struct kernfs_node		*sysfs_degraded;	/*handle for 'degraded' */
	struct kernfs_node		*sysfs_level;		/*handle for 'level' */
448

449 450
	struct work_struct del_work;	/* used for delayed sysfs removal */

451 452 453 454 455
	/* "lock" protects:
	 *   flush_bio transition from NULL to !NULL
	 *   rdev superblocks, events
	 *   clearing MD_CHANGE_*
	 *   in_sync - and related safemode and MD_CHANGE changes
456
	 *   pers (also protected by reconfig_mutex and pending IO).
457
	 *   clearing ->bitmap
458
	 *   clearing ->bitmap_info.file
459 460
	 *   changing ->resync_{min,max}
	 *   setting MD_RECOVERY_RUNNING (which interacts with resync_{min,max})
461 462
	 */
	spinlock_t			lock;
463
	wait_queue_head_t		sb_wait;	/* for waiting on superblock updates */
464
	atomic_t			pending_writes;	/* number of active superblock writes */
465

L
Linus Torvalds 已提交
466 467
	unsigned int			safemode;	/* if set, update "clean" superblock
							 * when no writes pending.
468
							 */
L
Linus Torvalds 已提交
469 470
	unsigned int			safemode_delay;
	struct timer_list		safemode_timer;
471 472
	struct percpu_ref		writes_pending;
	int				sync_checkers;	/* # of threads checking writes_pending */
473
	struct request_queue		*queue;	/* for plugging ... */
L
Linus Torvalds 已提交
474

475
	struct bitmap			*bitmap; /* the bitmap for the device */
476 477
	struct {
		struct file		*file; /* the bitmap file */
478
		loff_t			offset; /* offset from superblock of
479 480
						 * start of bitmap. May be
						 * negative, but not '0'
481
						 * For external metadata, offset
482
						 * from start of device.
483
						 */
484
		unsigned long		space; /* space available at this offset */
485
		loff_t			default_offset; /* this is the offset to use when
486 487 488
							 * hot-adding a bitmap.  It should
							 * eventually be settable by sysfs.
							 */
489 490
		unsigned long		default_space; /* space available at
							* default offset */
491
		struct mutex		mutex;
492
		unsigned long		chunksize;
493
		unsigned long		daemon_sleep; /* how many jiffies between updates? */
494
		unsigned long		max_write_behind; /* write-behind mode */
495
		int			external;
G
Goldwyn Rodrigues 已提交
496
		int			nodes; /* Maximum number of nodes in the cluster */
G
Goldwyn Rodrigues 已提交
497
		char                    cluster_name[64]; /* Name of the cluster */
498
	} bitmap_info;
499

500
	atomic_t			max_corr_read_errors; /* max read retries */
L
Linus Torvalds 已提交
501
	struct list_head		all_mddevs;
502

503
	struct attribute_group		*to_remove;
504

505 506
	struct bio_set			bio_set;
	struct bio_set			sync_set; /* for sync operations like
507 508
						   * metadata and bitmap writes
						   */
509
	struct bio_set			io_acct_set; /* for raid0 and raid5 io accounting */
510

511 512 513 514 515 516
	/* Generic flush handling.
	 * The last to finish preflush schedules a worker to submit
	 * the rest of the request (without the REQ_PREFLUSH flag).
	 */
	struct bio *flush_bio;
	atomic_t flush_pending;
N
NeilBrown 已提交
517 518 519
	ktime_t start_flush, last_flush; /* last_flush is when the last completed
					  * flush was started.
					  */
520
	struct work_struct flush_work;
521
	struct work_struct event_work;	/* used by dm to report failure event */
G
Guoqing Jiang 已提交
522
	mempool_t *serial_info_pool;
523
	void (*sync_super)(struct mddev *mddev, struct md_rdev *rdev);
G
Goldwyn Rodrigues 已提交
524
	struct md_cluster_info		*cluster_info;
525
	unsigned int			good_device_nr;	/* good device num within cluster raid */
526
	unsigned int			noio_flag; /* for memalloc scope API */
527 528

	bool	has_superblocks:1;
529
	bool	fail_last_dev:1;
530
	bool	serialize_policy:1;
531 532 533

	/* Used to synchronize idle and frozen for action_store() */
	struct mutex sync_mutex;
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
};

enum recovery_flags {
	/*
	 * If neither SYNC or RESHAPE are set, then it is a recovery.
	 */
	MD_RECOVERY_RUNNING,	/* a thread is running, or about to be started */
	MD_RECOVERY_SYNC,	/* actually doing a resync, not a recovery */
	MD_RECOVERY_RECOVER,	/* doing recovery, or need to try it. */
	MD_RECOVERY_INTR,	/* resync needs to be aborted for some reason */
	MD_RECOVERY_DONE,	/* thread is done and is waiting to be reaped */
	MD_RECOVERY_NEEDED,	/* we might need to start a resync/recover */
	MD_RECOVERY_REQUESTED,	/* user-space has requested a sync (used with SYNC) */
	MD_RECOVERY_CHECK,	/* user-space request for check-only, no repair */
	MD_RECOVERY_RESHAPE,	/* A reshape is happening */
	MD_RECOVERY_FROZEN,	/* User request to abort, and not restart, any action */
	MD_RECOVERY_ERROR,	/* sync-action interrupted because io-error */
551
	MD_RECOVERY_WAIT,	/* waiting for pers->start() to finish */
552
	MD_RESYNCING_REMOTE,	/* remote node is running resync thread */
L
Linus Torvalds 已提交
553 554
};

555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
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_trylock(struct mddev *mddev)
{
	return mutex_trylock(&mddev->reconfig_mutex);
}
extern void mddev_unlock(struct mddev *mddev);

L
Linus Torvalds 已提交
574 575
static inline void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors)
{
576
	atomic64_add(nr_sectors, &bdev->bd_disk->sync_io_sectors);
L
Linus Torvalds 已提交
577 578
}

579 580
static inline void md_sync_acct_bio(struct bio *bio, unsigned long nr_sectors)
{
581
	atomic64_add(nr_sectors, &bio->bi_disk->sync_io_sectors);
582 583
}

584
struct md_personality
L
Linus Torvalds 已提交
585 586
{
	char *name;
587 588
	int level;
	struct list_head list;
L
Linus Torvalds 已提交
589
	struct module *owner;
590
	bool __must_check (*make_request)(struct mddev *mddev, struct bio *bio);
591 592 593 594
	/*
	 * start up works that do NOT require md_thread. tasks that
	 * requires md_thread should go into start()
	 */
595
	int (*run)(struct mddev *mddev);
596 597
	/* start up works that require md threads */
	int (*start)(struct mddev *mddev);
N
NeilBrown 已提交
598
	void (*free)(struct mddev *mddev, void *priv);
599
	void (*status)(struct seq_file *seq, struct mddev *mddev);
L
Linus Torvalds 已提交
600
	/* error_handler must set ->faulty and clear ->in_sync
601
	 * if appropriate, and should abort recovery if needed
L
Linus Torvalds 已提交
602
	 */
603 604
	void (*error_handler)(struct mddev *mddev, struct md_rdev *rdev);
	int (*hot_add_disk) (struct mddev *mddev, struct md_rdev *rdev);
605
	int (*hot_remove_disk) (struct mddev *mddev, struct md_rdev *rdev);
606
	int (*spare_active) (struct mddev *mddev);
607
	sector_t (*sync_request)(struct mddev *mddev, sector_t sector_nr, int *skipped);
608 609 610 611 612
	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);
613
	void (*update_reshape_pos) (struct mddev *mddev);
614 615 616
	/* quiesce suspends or resumes internal processing.
	 * 1 - stop new actions and wait for action io to complete
	 * 0 - return to normal behaviour
617
	 */
618
	void (*quiesce) (struct mddev *mddev, int quiesce);
619 620 621 622 623 624 625 626 627
	/* 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.
	 */
628
	void *(*takeover) (struct mddev *mddev);
629 630
	/* Changes the consistency policy of an active array. */
	int (*change_consistency_policy)(struct mddev *mddev, const char *buf);
L
Linus Torvalds 已提交
631 632
};

633 634
struct md_sysfs_entry {
	struct attribute attr;
635 636
	ssize_t (*show)(struct mddev *, char *);
	ssize_t (*store)(struct mddev *, const char *, size_t);
637
};
638
extern struct attribute_group md_bitmap_group;
639

640
static inline struct kernfs_node *sysfs_get_dirent_safe(struct kernfs_node *sd, char *name)
N
NeilBrown 已提交
641 642
{
	if (sd)
T
Tejun Heo 已提交
643
		return sysfs_get_dirent(sd, name);
N
NeilBrown 已提交
644 645
	return sd;
}
646
static inline void sysfs_notify_dirent_safe(struct kernfs_node *sd)
N
NeilBrown 已提交
647 648 649 650 651
{
	if (sd)
		sysfs_notify_dirent(sd);
}

652
static inline char * mdname (struct mddev * mddev)
L
Linus Torvalds 已提交
653 654 655 656
{
	return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
}

657
static inline int sysfs_link_rdev(struct mddev *mddev, struct md_rdev *rdev)
658 659
{
	char nm[20];
660 661 662
	if (!test_bit(Replacement, &rdev->flags) &&
	    !test_bit(Journal, &rdev->flags) &&
	    mddev->kobj.sd) {
663 664 665 666
		sprintf(nm, "rd%d", rdev->raid_disk);
		return sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
	} else
		return 0;
667 668
}

669
static inline void sysfs_unlink_rdev(struct mddev *mddev, struct md_rdev *rdev)
670 671
{
	char nm[20];
672 673 674
	if (!test_bit(Replacement, &rdev->flags) &&
	    !test_bit(Journal, &rdev->flags) &&
	    mddev->kobj.sd) {
675 676 677
		sprintf(nm, "rd%d", rdev->raid_disk);
		sysfs_remove_link(&mddev->kobj, nm);
	}
678 679
}

L
Linus Torvalds 已提交
680 681 682 683
/*
 * iterates through some rdev ringlist. It's safe to remove the
 * current 'rdev'. Dont touch 'tmp' though.
 */
684 685 686
#define rdev_for_each_list(rdev, tmp, head)				\
	list_for_each_entry_safe(rdev, tmp, head, same_set)

L
Linus Torvalds 已提交
687 688 689
/*
 * iterates through the 'same array disks' ringlist
 */
N
NeilBrown 已提交
690 691 692 693
#define rdev_for_each(rdev, mddev)				\
	list_for_each_entry(rdev, &((mddev)->disks), same_set)

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

696 697 698
#define rdev_for_each_rcu(rdev, mddev)				\
	list_for_each_entry_rcu(rdev, &((mddev)->disks), same_set)

699
struct md_thread {
S
Shaohua Li 已提交
700
	void			(*run) (struct md_thread *thread);
701
	struct mddev		*mddev;
L
Linus Torvalds 已提交
702
	wait_queue_head_t	wqueue;
703
	unsigned long		flags;
L
Linus Torvalds 已提交
704
	struct task_struct	*tsk;
705
	unsigned long		timeout;
S
Shaohua Li 已提交
706
	void			*private;
707
};
L
Linus Torvalds 已提交
708

709 710 711 712 713 714
struct md_io_acct {
	struct bio *orig_bio;
	unsigned long start_time;
	struct bio bio_clone;
};

L
Linus Torvalds 已提交
715 716
#define THREAD_WAKEUP  0

717 718 719 720 721
static inline void safe_put_page(struct page *p)
{
	if (p) put_page(p);
}

722 723
extern int register_md_personality(struct md_personality *p);
extern int unregister_md_personality(struct md_personality *p);
724 725 726 727 728
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);
729
extern struct md_thread *md_register_thread(
S
Shaohua Li 已提交
730
	void (*run)(struct md_thread *thread),
731 732 733 734
	struct mddev *mddev,
	const char *name);
extern void md_unregister_thread(struct md_thread **threadp);
extern void md_wakeup_thread(struct md_thread *thread);
735
extern void md_check_recovery(struct mddev *mddev);
736
extern void md_reap_sync_thread(struct mddev *mddev);
737
extern int mddev_init_writes_pending(struct mddev *mddev);
738
extern bool md_write_start(struct mddev *mddev, struct bio *bi);
739
extern void md_write_inc(struct mddev *mddev, struct bio *bi);
740 741 742
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);
743
extern void md_finish_reshape(struct mddev *mddev);
744
void md_account_bio(struct mddev *mddev, struct bio **bio);
745

746
extern bool __must_check md_flush_request(struct mddev *mddev, struct bio *bio);
747
extern void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
748
			   sector_t sector, int size, struct page *page);
749
extern int md_super_wait(struct mddev *mddev);
750
extern int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
M
Mike Christie 已提交
751 752
			struct page *page, int op, int op_flags,
			bool metadata_op);
S
Shaohua Li 已提交
753
extern void md_do_sync(struct md_thread *thread);
754
extern void md_new_event(struct mddev *mddev);
755
extern void md_allow_write(struct mddev *mddev);
756 757 758 759
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);
760
extern int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev);
761
extern int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale);
C
Christoph Hellwig 已提交
762

763 764
extern void mddev_init(struct mddev *mddev);
extern int md_run(struct mddev *mddev);
765
extern int md_start(struct mddev *mddev);
766 767
extern void md_stop(struct mddev *mddev);
extern void md_stop_writes(struct mddev *mddev);
768
extern int md_rdev_init(struct md_rdev *rdev);
769
extern void md_rdev_clear(struct md_rdev *rdev);
C
Christoph Hellwig 已提交
770

S
Shaohua Li 已提交
771
extern void md_handle_request(struct mddev *mddev, struct bio *bio);
772 773
extern void mddev_suspend(struct mddev *mddev);
extern void mddev_resume(struct mddev *mddev);
774
extern struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
775
				   struct mddev *mddev);
776

777
extern void md_reload_sb(struct mddev *mddev, int raid_disk);
778
extern void md_update_sb(struct mddev *mddev, int force);
779
extern void md_kick_rdev_from_array(struct md_rdev * rdev);
G
Guoqing Jiang 已提交
780
extern void mddev_create_serial_pool(struct mddev *mddev, struct md_rdev *rdev,
781
				     bool is_suspend);
782 783
extern void mddev_destroy_serial_pool(struct mddev *mddev, struct md_rdev *rdev,
				      bool is_suspend);
784
struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr);
785
struct md_rdev *md_find_rdev_rcu(struct mddev *mddev, dev_t dev);
786

787 788 789 790 791 792 793 794 795 796 797 798 799
static inline bool is_mddev_broken(struct md_rdev *rdev, const char *md_type)
{
	int flags = rdev->bdev->bd_disk->flags;

	if (!(flags & GENHD_FL_UP)) {
		if (!test_and_set_bit(MD_BROKEN, &rdev->mddev->flags))
			pr_warn("md: %s: %s array has a missing/failed member\n",
				mdname(rdev->mddev), md_type);
		return true;
	}
	return false;
}

800 801 802 803 804 805 806 807 808
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);
	}
}

809
extern struct md_cluster_operations *md_cluster_ops;
G
Goldwyn Rodrigues 已提交
810 811 812 813
static inline int mddev_is_clustered(struct mddev *mddev)
{
	return mddev->cluster_info && mddev->bitmap_info.nodes > 1;
}
814 815 816 817 818 819 820

/* clear unsupported mddev_flags */
static inline void mddev_clear_unsupported_flags(struct mddev *mddev,
	unsigned long unsupported_flags)
{
	mddev->flags &= ~unsupported_flags;
}
821 822 823 824

static inline void mddev_check_writesame(struct mddev *mddev, struct bio *bio)
{
	if (bio_op(bio) == REQ_OP_WRITE_SAME &&
825
	    !bio->bi_disk->queue->limits.max_write_same_sectors)
826 827
		mddev->queue->limits.max_write_same_sectors = 0;
}
828 829 830 831

static inline void mddev_check_write_zeroes(struct mddev *mddev, struct bio *bio)
{
	if (bio_op(bio) == REQ_OP_WRITE_ZEROES &&
832
	    !bio->bi_disk->queue->limits.max_write_zeroes_sectors)
833 834
		mddev->queue->limits.max_write_zeroes_sectors = 0;
}
835

836 837 838
struct mdu_array_info_s;
struct mdu_disk_info_s;

839
extern int mdp_major;
840
void md_autostart_arrays(int part);
841 842 843 844 845
int md_set_array_info(struct mddev *mddev, struct mdu_array_info_s *info);
int md_add_new_disk(struct mddev *mddev, struct mdu_disk_info_s *info);
int do_md_run(struct mddev *mddev);

extern const struct block_device_operations md_fops;
846

C
Christoph Hellwig 已提交
847
#endif /* _MD_MD_H */