md.h 25.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)
L
Linus Torvalds 已提交
35 36 37
/*
 * MD's 'extended' device
 */
38
struct md_rdev {
L
Linus Torvalds 已提交
39 40
	struct list_head same_set;	/* RAID devices within the same set */

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

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

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

62 63
	struct kobject	kobj;

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

75
	unsigned long	flags;	/* bit set of 'enum flag_bits' bits. */
76
	wait_queue_head_t blocked_wait;
77

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

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

114
	struct kernfs_node *sysfs_state; /* handle for 'state'
115
					   * sysfs entry */
116

117
	struct badblocks badblocks;
118 119 120 121 122 123 124

	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 已提交
125
};
126 127 128
enum flag_bits {
	Faulty,			/* device is known to have a fault */
	In_sync,		/* device is in_sync with rest of array */
129
	Bitmap_sync,		/* ..actually, not quite In_sync.  Need a
130 131 132
				 * bitmap-based recovery to get fully in sync.
				 * The bit is only meaningful before device
				 * has been passed to pers->hot_add_disk.
133
				 */
134 135 136 137 138 139 140 141 142 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
	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.
				 */
168 169 170 171
	Candidate,		/* For clustered environments only:
				 * This device is seen locally but not
				 * by the whole cluster
				 */
172 173 174 175 176
	Journal,		/* This device is used as journal for
				 * raid-5/6.
				 * Usually, this device should be faster
				 * than other devices in the array
				 */
177
	ClusterRemove,
178 179 180 181 182
	RemoveSynchronized,	/* synchronize_rcu() was called after
				 * this device was known to be faulty,
				 * so it is safe to remove without
				 * another synchronize_rcu() call.
				 */
183 184 185
	ExternalBbl,            /* External metadata provides bad
				 * block management for a disk
				 */
186 187 188 189 190 191
	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.
				 */
192 193 194 195
	LastDev,		/* Seems to be the last working dev as
				 * it didn't fail, so don't use FailFast
				 * any more for metadata
				 */
196
};
L
Linus Torvalds 已提交
197

198
static inline int is_badblock(struct md_rdev *rdev, sector_t s, int sectors,
199 200 201
			      sector_t *first_bad, int *bad_sectors)
{
	if (unlikely(rdev->badblocks.count)) {
202
		int rv = badblocks_check(&rdev->badblocks, rdev->data_offset + s,
203 204 205 206 207 208 209 210
					sectors,
					first_bad, bad_sectors);
		if (rv)
			*first_bad -= rdev->data_offset;
		return rv;
	}
	return 0;
}
211
extern int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
212 213 214
			      int is_new);
extern int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
				int is_new);
G
Goldwyn Rodrigues 已提交
215 216
struct md_cluster_info;

217
/* change UNSUPPORTED_MDDEV_FLAGS for each array type if new flag is added */
218 219 220 221 222 223 224 225 226
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 */
227 228 229 230
	MD_FAILFAST_SUPPORTED,	/* Using MD_FAILFAST on metadata writes is
				 * supported as calls to md_error() will
				 * never cause the array to become failed.
				 */
231
	MD_HAS_PPL,		/* The raid array has PPL feature set */
232
	MD_HAS_MULTIPLE_PPLS,	/* The raid array has multiple PPLs feature set */
233 234 235 236 237 238
	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.
				 */
239
};
240 241 242 243 244 245 246 247

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 */
};

248
struct mddev {
L
Linus Torvalds 已提交
249
	void				*private;
250
	struct md_personality		*pers;
L
Linus Torvalds 已提交
251 252
	dev_t				unit;
	int				md_minor;
253
	struct list_head		disks;
254
	unsigned long			flags;
255
	unsigned long			sb_flags;
256

257 258
	int				suspended;
	atomic_t			active_io;
L
Linus Torvalds 已提交
259
	int				ro;
260 261 262 263
	int				sysfs_active; /* set when sysfs deletes
						       * are happening, so run/
						       * takeover/stop are not safe
						       */
L
Linus Torvalds 已提交
264 265
	struct gendisk			*gendisk;

266
	struct kobject			kobj;
267 268
	int				hold_active;
#define	UNTIL_IOCTL	1
269
#define	UNTIL_STOP	2
270

L
Linus Torvalds 已提交
271 272 273 274 275
	/* Superblock information */
	int				major_version,
					minor_version,
					patch_version;
	int				persistent;
276
	int				external;	/* metadata is
277 278
							 * managed externally */
	char				metadata_type[17]; /* externally set*/
279
	int				chunk_sectors;
280
	time64_t			ctime, utime;
L
Linus Torvalds 已提交
281
	int				level, layout;
282
	char				clevel[16];
L
Linus Torvalds 已提交
283 284
	int				raid_disks;
	int				max_disks;
285
	sector_t			dev_sectors;	/* used size of
A
Andre Noll 已提交
286
							 * component devices */
287
	sector_t			array_sectors; /* exported array size */
D
Dan Williams 已提交
288 289
	int				external_size; /* size managed
							* externally */
L
Linus Torvalds 已提交
290
	__u64				events;
291 292 293 294 295 296
	/* 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 已提交
297 298 299

	char				uuid[16];

300 301 302 303 304 305
	/* 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;
306 307
	int				delta_disks, new_level, new_layout;
	int				new_chunk_sectors;
308
	int				reshape_backwards;
309

310 311
	struct md_thread		*thread;	/* management thread */
	struct md_thread		*sync_thread;	/* doing resync or reconstruct */
312 313 314 315 316 317 318 319

	/* '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;
320
	sector_t			curr_resync;	/* last block scheduled */
321 322 323 324 325 326 327
	/* 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 已提交
328 329
	unsigned long			resync_mark;	/* a recent timestamp */
	sector_t			resync_mark_cnt;/* blocks written at resync_mark */
330
	sector_t			curr_mark_cnt; /* blocks scheduled now */
L
Linus Torvalds 已提交
331 332

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

334
	atomic64_t			resync_mismatches; /* count of sectors where
335 336
							    * parity/replica mismatch found
							    */
337 338 339 340

	/* allow user-space to request suspension of IO to regions of the array */
	sector_t			suspend_lo;
	sector_t			suspend_hi;
341 342 343 344
	/* if zero, use the system-wide default */
	int				sync_speed_min;
	int				sync_speed_max;

345 346 347
	/* resync even though the same disks are shared among md-devices */
	int				parallel_resync;

348
	int				ok_start_degraded;
349

L
Linus Torvalds 已提交
350
	unsigned long			recovery;
351 352 353 354 355 356
	/* 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 已提交
357 358

	int				in_sync;	/* know to not need resync */
N
NeilBrown 已提交
359 360 361 362 363 364 365 366 367 368
	/* '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;
369
	struct mutex			reconfig_mutex;
370 371
	atomic_t			active;		/* general refcount */
	atomic_t			openers;	/* number of active opens */
L
Linus Torvalds 已提交
372

373 374
	int				changed;	/* True if we might need to
							 * reread partition info */
L
Linus Torvalds 已提交
375 376 377 378 379 380 381
	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;
382 383
	sector_t			resync_min;	/* user requested sync
							 * starts here */
384 385
	sector_t			resync_max;	/* resync should pause
							 * when it gets here */
386

387
	struct kernfs_node		*sysfs_state;	/* handle for 'array_state'
388 389
							 * file in sysfs.
							 */
390
	struct kernfs_node		*sysfs_action;  /* handle for 'sync_action' */
391

392 393
	struct work_struct del_work;	/* used for delayed sysfs removal */

394 395 396 397 398
	/* "lock" protects:
	 *   flush_bio transition from NULL to !NULL
	 *   rdev superblocks, events
	 *   clearing MD_CHANGE_*
	 *   in_sync - and related safemode and MD_CHANGE changes
399
	 *   pers (also protected by reconfig_mutex and pending IO).
400
	 *   clearing ->bitmap
401
	 *   clearing ->bitmap_info.file
402 403
	 *   changing ->resync_{min,max}
	 *   setting MD_RECOVERY_RUNNING (which interacts with resync_{min,max})
404 405
	 */
	spinlock_t			lock;
406
	wait_queue_head_t		sb_wait;	/* for waiting on superblock updates */
407
	atomic_t			pending_writes;	/* number of active superblock writes */
408

L
Linus Torvalds 已提交
409 410
	unsigned int			safemode;	/* if set, update "clean" superblock
							 * when no writes pending.
411
							 */
L
Linus Torvalds 已提交
412 413
	unsigned int			safemode_delay;
	struct timer_list		safemode_timer;
414 415
	struct percpu_ref		writes_pending;
	int				sync_checkers;	/* # of threads checking writes_pending */
416
	struct request_queue		*queue;	/* for plugging ... */
L
Linus Torvalds 已提交
417

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

443
	atomic_t			max_corr_read_errors; /* max read retries */
L
Linus Torvalds 已提交
444
	struct list_head		all_mddevs;
445

446
	struct attribute_group		*to_remove;
447

448 449
	struct bio_set			bio_set;
	struct bio_set			sync_set; /* for sync operations like
450 451
						   * metadata and bitmap writes
						   */
452

453 454 455 456 457 458
	/* 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 已提交
459 460 461
	ktime_t start_flush, last_flush; /* last_flush is when the last completed
					  * flush was started.
					  */
462
	struct work_struct flush_work;
463
	struct work_struct event_work;	/* used by dm to report failure event */
464
	void (*sync_super)(struct mddev *mddev, struct md_rdev *rdev);
G
Goldwyn Rodrigues 已提交
465
	struct md_cluster_info		*cluster_info;
466
	unsigned int			good_device_nr;	/* good device num within cluster raid */
467 468

	bool	has_superblocks:1;
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
};

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 */
486
	MD_RECOVERY_WAIT,	/* waiting for pers->start() to finish */
487
	MD_RESYNCING_REMOTE,	/* remote node is running resync thread */
L
Linus Torvalds 已提交
488 489
};

490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
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 已提交
509 510
static inline void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors)
{
511
	atomic_add(nr_sectors, &bdev->bd_contains->bd_disk->sync_io);
L
Linus Torvalds 已提交
512 513
}

514 515 516 517 518
static inline void md_sync_acct_bio(struct bio *bio, unsigned long nr_sectors)
{
	atomic_add(nr_sectors, &bio->bi_disk->sync_io);
}

519
struct md_personality
L
Linus Torvalds 已提交
520 521
{
	char *name;
522 523
	int level;
	struct list_head list;
L
Linus Torvalds 已提交
524
	struct module *owner;
525
	bool (*make_request)(struct mddev *mddev, struct bio *bio);
526 527 528 529
	/*
	 * start up works that do NOT require md_thread. tasks that
	 * requires md_thread should go into start()
	 */
530
	int (*run)(struct mddev *mddev);
531 532
	/* start up works that require md threads */
	int (*start)(struct mddev *mddev);
N
NeilBrown 已提交
533
	void (*free)(struct mddev *mddev, void *priv);
534
	void (*status)(struct seq_file *seq, struct mddev *mddev);
L
Linus Torvalds 已提交
535
	/* error_handler must set ->faulty and clear ->in_sync
536
	 * if appropriate, and should abort recovery if needed
L
Linus Torvalds 已提交
537
	 */
538 539
	void (*error_handler)(struct mddev *mddev, struct md_rdev *rdev);
	int (*hot_add_disk) (struct mddev *mddev, struct md_rdev *rdev);
540
	int (*hot_remove_disk) (struct mddev *mddev, struct md_rdev *rdev);
541
	int (*spare_active) (struct mddev *mddev);
542
	sector_t (*sync_request)(struct mddev *mddev, sector_t sector_nr, int *skipped);
543 544 545 546 547
	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);
548
	void (*update_reshape_pos) (struct mddev *mddev);
549 550 551
	/* quiesce suspends or resumes internal processing.
	 * 1 - stop new actions and wait for action io to complete
	 * 0 - return to normal behaviour
552
	 */
553
	void (*quiesce) (struct mddev *mddev, int quiesce);
554 555 556 557 558 559 560 561 562
	/* 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.
	 */
563
	void *(*takeover) (struct mddev *mddev);
564 565 566
	/* congested implements bdi.congested_fn().
	 * Will not be called while array is 'suspended' */
	int (*congested)(struct mddev *mddev, int bits);
567 568
	/* Changes the consistency policy of an active array. */
	int (*change_consistency_policy)(struct mddev *mddev, const char *buf);
L
Linus Torvalds 已提交
569 570
};

571 572
struct md_sysfs_entry {
	struct attribute attr;
573 574
	ssize_t (*show)(struct mddev *, char *);
	ssize_t (*store)(struct mddev *, const char *, size_t);
575
};
576
extern struct attribute_group md_bitmap_group;
577

578
static inline struct kernfs_node *sysfs_get_dirent_safe(struct kernfs_node *sd, char *name)
N
NeilBrown 已提交
579 580
{
	if (sd)
T
Tejun Heo 已提交
581
		return sysfs_get_dirent(sd, name);
N
NeilBrown 已提交
582 583
	return sd;
}
584
static inline void sysfs_notify_dirent_safe(struct kernfs_node *sd)
N
NeilBrown 已提交
585 586 587 588 589
{
	if (sd)
		sysfs_notify_dirent(sd);
}

590
static inline char * mdname (struct mddev * mddev)
L
Linus Torvalds 已提交
591 592 593 594
{
	return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
}

595
static inline int sysfs_link_rdev(struct mddev *mddev, struct md_rdev *rdev)
596 597
{
	char nm[20];
598 599 600
	if (!test_bit(Replacement, &rdev->flags) &&
	    !test_bit(Journal, &rdev->flags) &&
	    mddev->kobj.sd) {
601 602 603 604
		sprintf(nm, "rd%d", rdev->raid_disk);
		return sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
	} else
		return 0;
605 606
}

607
static inline void sysfs_unlink_rdev(struct mddev *mddev, struct md_rdev *rdev)
608 609
{
	char nm[20];
610 611 612
	if (!test_bit(Replacement, &rdev->flags) &&
	    !test_bit(Journal, &rdev->flags) &&
	    mddev->kobj.sd) {
613 614 615
		sprintf(nm, "rd%d", rdev->raid_disk);
		sysfs_remove_link(&mddev->kobj, nm);
	}
616 617
}

L
Linus Torvalds 已提交
618 619 620 621
/*
 * iterates through some rdev ringlist. It's safe to remove the
 * current 'rdev'. Dont touch 'tmp' though.
 */
622 623 624
#define rdev_for_each_list(rdev, tmp, head)				\
	list_for_each_entry_safe(rdev, tmp, head, same_set)

L
Linus Torvalds 已提交
625 626 627
/*
 * iterates through the 'same array disks' ringlist
 */
N
NeilBrown 已提交
628 629 630 631
#define rdev_for_each(rdev, mddev)				\
	list_for_each_entry(rdev, &((mddev)->disks), same_set)

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

634 635 636
#define rdev_for_each_rcu(rdev, mddev)				\
	list_for_each_entry_rcu(rdev, &((mddev)->disks), same_set)

637
struct md_thread {
S
Shaohua Li 已提交
638
	void			(*run) (struct md_thread *thread);
639
	struct mddev		*mddev;
L
Linus Torvalds 已提交
640
	wait_queue_head_t	wqueue;
641
	unsigned long		flags;
L
Linus Torvalds 已提交
642
	struct task_struct	*tsk;
643
	unsigned long		timeout;
S
Shaohua Li 已提交
644
	void			*private;
645
};
L
Linus Torvalds 已提交
646 647 648

#define THREAD_WAKEUP  0

649 650 651 652 653
static inline void safe_put_page(struct page *p)
{
	if (p) put_page(p);
}

654 655
extern int register_md_personality(struct md_personality *p);
extern int unregister_md_personality(struct md_personality *p);
656 657 658 659 660
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);
661
extern struct md_thread *md_register_thread(
S
Shaohua Li 已提交
662
	void (*run)(struct md_thread *thread),
663 664 665 666
	struct mddev *mddev,
	const char *name);
extern void md_unregister_thread(struct md_thread **threadp);
extern void md_wakeup_thread(struct md_thread *thread);
667
extern void md_check_recovery(struct mddev *mddev);
668
extern void md_reap_sync_thread(struct mddev *mddev);
669
extern int mddev_init_writes_pending(struct mddev *mddev);
670
extern bool md_write_start(struct mddev *mddev, struct bio *bi);
671
extern void md_write_inc(struct mddev *mddev, struct bio *bi);
672 673 674
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);
675
extern void md_finish_reshape(struct mddev *mddev);
676 677 678 679

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,
680
			   sector_t sector, int size, struct page *page);
681
extern int md_super_wait(struct mddev *mddev);
682
extern int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
M
Mike Christie 已提交
683 684
			struct page *page, int op, int op_flags,
			bool metadata_op);
S
Shaohua Li 已提交
685
extern void md_do_sync(struct md_thread *thread);
686
extern void md_new_event(struct mddev *mddev);
687
extern void md_allow_write(struct mddev *mddev);
688 689 690 691
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);
692
extern int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev);
693
extern int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale);
C
Christoph Hellwig 已提交
694

695 696
extern void mddev_init(struct mddev *mddev);
extern int md_run(struct mddev *mddev);
697
extern int md_start(struct mddev *mddev);
698 699
extern void md_stop(struct mddev *mddev);
extern void md_stop_writes(struct mddev *mddev);
700
extern int md_rdev_init(struct md_rdev *rdev);
701
extern void md_rdev_clear(struct md_rdev *rdev);
C
Christoph Hellwig 已提交
702

S
Shaohua Li 已提交
703
extern void md_handle_request(struct mddev *mddev, struct bio *bio);
704 705
extern void mddev_suspend(struct mddev *mddev);
extern void mddev_resume(struct mddev *mddev);
706
extern struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
707
				   struct mddev *mddev);
708

709
extern void md_reload_sb(struct mddev *mddev, int raid_disk);
710
extern void md_update_sb(struct mddev *mddev, int force);
711
extern void md_kick_rdev_from_array(struct md_rdev * rdev);
712
struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr);
713
struct md_rdev *md_find_rdev_rcu(struct mddev *mddev, dev_t dev);
714 715 716 717 718 719 720 721 722 723

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);
	}
}

724
extern struct md_cluster_operations *md_cluster_ops;
G
Goldwyn Rodrigues 已提交
725 726 727 728
static inline int mddev_is_clustered(struct mddev *mddev)
{
	return mddev->cluster_info && mddev->bitmap_info.nodes > 1;
}
729 730 731 732 733 734 735

/* clear unsupported mddev_flags */
static inline void mddev_clear_unsupported_flags(struct mddev *mddev,
	unsigned long unsupported_flags)
{
	mddev->flags &= ~unsupported_flags;
}
736 737 738 739

static inline void mddev_check_writesame(struct mddev *mddev, struct bio *bio)
{
	if (bio_op(bio) == REQ_OP_WRITE_SAME &&
740
	    !bio->bi_disk->queue->limits.max_write_same_sectors)
741 742
		mddev->queue->limits.max_write_same_sectors = 0;
}
743 744 745 746

static inline void mddev_check_write_zeroes(struct mddev *mddev, struct bio *bio)
{
	if (bio_op(bio) == REQ_OP_WRITE_ZEROES &&
747
	    !bio->bi_disk->queue->limits.max_write_zeroes_sectors)
748 749
		mddev->queue->limits.max_write_zeroes_sectors = 0;
}
C
Christoph Hellwig 已提交
750
#endif /* _MD_MD_H */