md.h 17.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/*
   md_k.h : kernel internal structure of the Linux MD driver
          Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
	  
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.
   
   You should have received a copy of the GNU General Public License
   (for example /usr/src/linux/COPYING); if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
*/

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

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

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

typedef struct mddev_s mddev_t;
typedef struct mdk_rdev_s mdk_rdev_t;

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
/* generic plugging support - like that provided with request_queue,
 * but does not require a request_queue
 */
struct plug_handle {
	void			(*unplug_fn)(struct plug_handle *);
	struct timer_list	unplug_timer;
	struct work_struct	unplug_work;
	unsigned long		unplug_flag;
};
#define	PLUGGED_FLAG 1
void plugger_init(struct plug_handle *plug,
		  void (*unplug_fn)(struct plug_handle *));
void plugger_set_plug(struct plug_handle *plug);
int plugger_remove_plug(struct plug_handle *plug);
static inline void plugger_flush(struct plug_handle *plug)
{
	del_timer_sync(&plug->unplug_timer);
	cancel_work_sync(&plug->unplug_work);
}

L
Linus Torvalds 已提交
52 53 54 55 56 57 58
/*
 * MD's 'extended' device
 */
struct mdk_rdev_s
{
	struct list_head same_set;	/* RAID devices within the same set */

59
	sector_t sectors;		/* Device size (in 512bytes sectors) */
L
Linus Torvalds 已提交
60
	mddev_t *mddev;			/* RAID array if running */
N
NeilBrown 已提交
61
	int last_events;		/* IO event timestamp */
L
Linus Torvalds 已提交
62 63 64 65 66

	struct block_device *bdev;	/* block device handle */

	struct page	*sb_page;
	int		sb_loaded;
67
	__u64		sb_events;
L
Linus Torvalds 已提交
68
	sector_t	data_offset;	/* start of data in array */
69
	sector_t 	sb_start;	/* offset of the super block (in 512byte sectors) */
70
	int		sb_size;	/* bytes in the superblock */
L
Linus Torvalds 已提交
71 72
	int		preferred_minor;	/* autorun support */

73 74
	struct kobject	kobj;

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

86 87 88
	unsigned long	flags;
#define	Faulty		1		/* device is known to have a fault */
#define	In_sync		2		/* device is in_sync with rest of array */
89
#define	WriteMostly	4		/* Avoid reading if at all possible */
90
#define	BarriersNotsupp	5		/* REQ_HARDBARRIER is not supported */
91 92
#define	AllReserved	6		/* If whole device is reserved for
					 * one array */
93
#define	AutoDetected	7		/* added by auto-detect */
94 95 96 97
#define Blocked		8		/* An error occured on an externally
					 * managed array, don't allow writes
					 * until it is cleared */
	wait_queue_head_t blocked_wait;
98

L
Linus Torvalds 已提交
99 100
	int desc_nr;			/* descriptor index in the superblock */
	int raid_disk;			/* role of device in array */
101 102 103
	int new_raid_disk;		/* role that the device will have in
					 * the array after a level-change completes.
					 */
104 105 106 107
	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
					 */
108 109 110 111
	sector_t	recovery_offset;/* If this device has been partially
					 * recovered, this is where we were
					 * up to.
					 */
L
Linus Torvalds 已提交
112 113 114 115 116

	atomic_t	nr_pending;	/* number of pending requests.
					 * only maintained for arrays that
					 * support hot removal
					 */
117 118 119
	atomic_t	read_errors;	/* number of consecutive read errors that
					 * we have tried to ignore.
					 */
120 121 122
	struct timespec last_read_error;	/* monotonic time since our
						 * last read error
						 */
123 124 125 126
	atomic_t	corrected_errors; /* number of corrected read errors,
					   * for reporting to userspace and storing
					   * in superblock.
					   */
127
	struct work_struct del_work;	/* used for delayed sysfs removal */
128 129 130

	struct sysfs_dirent *sysfs_state; /* handle for 'state'
					   * sysfs entry */
L
Linus Torvalds 已提交
131 132 133 134 135
};

struct mddev_s
{
	void				*private;
136
	struct mdk_personality		*pers;
L
Linus Torvalds 已提交
137 138 139
	dev_t				unit;
	int				md_minor;
	struct list_head 		disks;
140 141 142 143 144
	unsigned long			flags;
#define MD_CHANGE_DEVS	0	/* Some device status has changed */
#define MD_CHANGE_CLEAN 1	/* transition to or from 'clean' */
#define MD_CHANGE_PENDING 2	/* superblock update in progress */

145 146
	int				suspended;
	atomic_t			active_io;
L
Linus Torvalds 已提交
147
	int				ro;
148 149 150 151
	int				sysfs_active; /* set when sysfs deletes
						       * are happening, so run/
						       * takeover/stop are not safe
						       */
L
Linus Torvalds 已提交
152 153 154

	struct gendisk			*gendisk;

155
	struct kobject			kobj;
156 157
	int				hold_active;
#define	UNTIL_IOCTL	1
158
#define	UNTIL_STOP	2
159

L
Linus Torvalds 已提交
160 161 162 163 164
	/* Superblock information */
	int				major_version,
					minor_version,
					patch_version;
	int				persistent;
165 166 167
	int 				external;	/* metadata is
							 * managed externally */
	char				metadata_type[17]; /* externally set*/
168
	int				chunk_sectors;
L
Linus Torvalds 已提交
169 170
	time_t				ctime, utime;
	int				level, layout;
171
	char				clevel[16];
L
Linus Torvalds 已提交
172 173
	int				raid_disks;
	int				max_disks;
A
Andre Noll 已提交
174 175
	sector_t			dev_sectors; 	/* used size of
							 * component devices */
176
	sector_t			array_sectors; /* exported array size */
D
Dan Williams 已提交
177 178
	int				external_size; /* size managed
							* externally */
L
Linus Torvalds 已提交
179
	__u64				events;
180 181 182 183 184 185
	/* 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 已提交
186 187 188

	char				uuid[16];

189 190 191 192 193 194
	/* 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;
195 196
	int				delta_disks, new_level, new_layout;
	int				new_chunk_sectors;
197

L
Linus Torvalds 已提交
198 199
	struct mdk_thread_s		*thread;	/* management thread */
	struct mdk_thread_s		*sync_thread;	/* doing resync or reconstruct */
200
	sector_t			curr_resync;	/* last block scheduled */
201 202 203 204 205 206 207
	/* 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 已提交
208 209
	unsigned long			resync_mark;	/* a recent timestamp */
	sector_t			resync_mark_cnt;/* blocks written at resync_mark */
210
	sector_t			curr_mark_cnt; /* blocks scheduled now */
L
Linus Torvalds 已提交
211 212

	sector_t			resync_max_sectors; /* may be set by personality */
213 214 215 216

	sector_t			resync_mismatches; /* count of sectors where
							    * parity/replica mismatch found
							    */
217 218 219 220

	/* allow user-space to request suspension of IO to regions of the array */
	sector_t			suspend_lo;
	sector_t			suspend_hi;
221 222 223 224
	/* if zero, use the system-wide default */
	int				sync_speed_min;
	int				sync_speed_max;

225 226 227
	/* resync even though the same disks are shared among md-devices */
	int				parallel_resync;

228
	int				ok_start_degraded;
L
Linus Torvalds 已提交
229 230 231 232
	/* recovery/resync flags 
	 * NEEDED:   we might need to start a resync/recover
	 * RUNNING:  a thread is running, or about to be started
	 * SYNC:     actually doing a resync, not a recovery
233
	 * RECOVER:  doing recovery, or need to try it.
234
	 * INTR:     resync needs to be aborted for some reason
L
Linus Torvalds 已提交
235
	 * DONE:     thread is done and is waiting to be reaped
236
	 * REQUEST:  user-space has requested a sync (used with SYNC)
237
	 * CHECK:    user-space request for check-only, no repair
238 239 240
	 * RESHAPE:  A reshape is happening
	 *
	 * If neither SYNC or RESHAPE are set, then it is a recovery.
L
Linus Torvalds 已提交
241 242 243
	 */
#define	MD_RECOVERY_RUNNING	0
#define	MD_RECOVERY_SYNC	1
244
#define	MD_RECOVERY_RECOVER	2
L
Linus Torvalds 已提交
245 246 247
#define	MD_RECOVERY_INTR	3
#define	MD_RECOVERY_DONE	4
#define	MD_RECOVERY_NEEDED	5
248 249
#define	MD_RECOVERY_REQUESTED	6
#define	MD_RECOVERY_CHECK	7
250
#define MD_RECOVERY_RESHAPE	8
251 252
#define	MD_RECOVERY_FROZEN	9

L
Linus Torvalds 已提交
253
	unsigned long			recovery;
254 255 256
	int				recovery_disabled; /* if we detect that recovery
							    * will always fail, set this
							    * so we don't loop trying */
L
Linus Torvalds 已提交
257 258

	int				in_sync;	/* know to not need resync */
N
NeilBrown 已提交
259 260 261 262 263 264 265 266 267 268
	/* '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;
269
	struct mutex			reconfig_mutex;
270 271
	atomic_t			active;		/* general refcount */
	atomic_t			openers;	/* number of active opens */
L
Linus Torvalds 已提交
272 273 274 275

	int				degraded;	/* whether md should consider
							 * adding a spare
							 */
276 277 278 279 280
	int				barriers_work;	/* initialised to true, cleared as soon
							 * as a barrier request to slave
							 * fails.  Only supported
							 */
	struct bio			*biolist; 	/* bios that need to be retried
281
							 * because REQ_HARDBARRIER is not supported
282
							 */
L
Linus Torvalds 已提交
283 284 285 286

	atomic_t			recovery_active; /* blocks scheduled, but not written */
	wait_queue_head_t		recovery_wait;
	sector_t			recovery_cp;
287 288
	sector_t			resync_min;	/* user requested sync
							 * starts here */
289 290
	sector_t			resync_max;	/* resync should pause
							 * when it gets here */
291

292 293 294
	struct sysfs_dirent		*sysfs_state;	/* handle for 'array_state'
							 * file in sysfs.
							 */
295
	struct sysfs_dirent		*sysfs_action;  /* handle for 'sync_action' */
296

297 298
	struct work_struct del_work;	/* used for delayed sysfs removal */

299
	spinlock_t			write_lock;
300
	wait_queue_head_t		sb_wait;	/* for waiting on superblock updates */
301
	atomic_t			pending_writes;	/* number of active superblock writes */
302

L
Linus Torvalds 已提交
303 304 305 306 307 308
	unsigned int			safemode;	/* if set, update "clean" superblock
							 * when no writes pending.
							 */ 
	unsigned int			safemode_delay;
	struct timer_list		safemode_timer;
	atomic_t			writes_pending; 
309
	struct request_queue		*queue;	/* for plugging ... */
L
Linus Torvalds 已提交
310

311
	struct bitmap                   *bitmap; /* the bitmap for the device */
312 313
	struct {
		struct file		*file; /* the bitmap file */
314
		loff_t			offset; /* offset from superblock of
315 316
						 * start of bitmap. May be
						 * negative, but not '0'
317 318
						 * For external metadata, offset
						 * from start of device. 
319
						 */
320
		loff_t			default_offset; /* this is the offset to use when
321 322 323
							 * hot-adding a bitmap.  It should
							 * eventually be settable by sysfs.
							 */
324 325 326 327 328
		/* When md is serving under dm, it might use a
		 * dirty_log to store the bits.
		 */
		struct dm_dirty_log *log;

329
		struct mutex		mutex;
330
		unsigned long		chunksize;
331
		unsigned long		daemon_sleep; /* how many jiffies between updates? */
332
		unsigned long		max_write_behind; /* write-behind mode */
333
		int			external;
334
	} bitmap_info;
335

336
	atomic_t 			max_corr_read_errors; /* max read retries */
L
Linus Torvalds 已提交
337
	struct list_head		all_mddevs;
338

339
	struct attribute_group		*to_remove;
340 341
	struct plug_handle		*plug; /* if used by personality */

342 343 344 345 346 347 348 349 350 351
	/* Generic barrier handling.
	 * If there is a pending barrier request, all other
	 * writes are blocked while the devices are flushed.
	 * The last to finish a flush schedules a worker to
	 * submit the barrier request (without the barrier flag),
	 * then submit more flush requests.
	 */
	struct bio *barrier;
	atomic_t flush_pending;
	struct work_struct barrier_work;
352
	struct work_struct event_work;	/* used by dm to report failure event */
L
Linus Torvalds 已提交
353 354 355 356 357
};


static inline void rdev_dec_pending(mdk_rdev_t *rdev, mddev_t *mddev)
{
358
	int faulty = test_bit(Faulty, &rdev->flags);
L
Linus Torvalds 已提交
359 360 361 362 363 364 365 366 367
	if (atomic_dec_and_test(&rdev->nr_pending) && faulty)
		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
}

static inline void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors)
{
        atomic_add(nr_sectors, &bdev->bd_contains->bd_disk->sync_io);
}

368
struct mdk_personality
L
Linus Torvalds 已提交
369 370
{
	char *name;
371 372
	int level;
	struct list_head list;
L
Linus Torvalds 已提交
373
	struct module *owner;
374
	int (*make_request)(mddev_t *mddev, struct bio *bio);
L
Linus Torvalds 已提交
375 376 377 378 379 380 381 382 383 384
	int (*run)(mddev_t *mddev);
	int (*stop)(mddev_t *mddev);
	void (*status)(struct seq_file *seq, mddev_t *mddev);
	/* error_handler must set ->faulty and clear ->in_sync
	 * if appropriate, and should abort recovery if needed 
	 */
	void (*error_handler)(mddev_t *mddev, mdk_rdev_t *rdev);
	int (*hot_add_disk) (mddev_t *mddev, mdk_rdev_t *rdev);
	int (*hot_remove_disk) (mddev_t *mddev, int number);
	int (*spare_active) (mddev_t *mddev);
385
	sector_t (*sync_request)(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster);
L
Linus Torvalds 已提交
386
	int (*resize) (mddev_t *mddev, sector_t sectors);
387
	sector_t (*size) (mddev_t *mddev, sector_t sectors, int raid_disks);
388 389
	int (*check_reshape) (mddev_t *mddev);
	int (*start_reshape) (mddev_t *mddev);
390
	void (*finish_reshape) (mddev_t *mddev);
391 392 393 394 395 396
	/* quiesce moves between quiescence states
	 * 0 - fully active
	 * 1 - no new requests allowed
	 * others - reserved
	 */
	void (*quiesce) (mddev_t *mddev, int state);
397 398 399 400 401 402 403 404 405 406
	/* takeover is used to transition an array from one
	 * personality to another.  The new personality must be able
	 * to handle the data in the current layout.
	 * e.g. 2drive raid1 -> 2drive raid5
	 *      ndrive raid5 -> degraded n+1drive raid6 with special layout
	 * If the takeover succeeds, a new 'private' structure is returned.
	 * This needs to be installed and then ->run used to activate the
	 * array.
	 */
	void *(*takeover) (mddev_t *mddev);
L
Linus Torvalds 已提交
407 408 409
};


410 411 412 413 414
struct md_sysfs_entry {
	struct attribute attr;
	ssize_t (*show)(mddev_t *, char *);
	ssize_t (*store)(mddev_t *, const char *, size_t);
};
415
extern struct attribute_group md_bitmap_group;
416

N
NeilBrown 已提交
417 418 419 420 421 422 423 424 425 426 427 428
static inline struct sysfs_dirent *sysfs_get_dirent_safe(struct sysfs_dirent *sd, char *name)
{
	if (sd)
		return sysfs_get_dirent(sd, NULL, name);
	return sd;
}
static inline void sysfs_notify_dirent_safe(struct sysfs_dirent *sd)
{
	if (sd)
		sysfs_notify_dirent(sd);
}

L
Linus Torvalds 已提交
429 430 431 432 433 434 435 436 437
static inline char * mdname (mddev_t * mddev)
{
	return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
}

/*
 * iterates through some rdev ringlist. It's safe to remove the
 * current 'rdev'. Dont touch 'tmp' though.
 */
438 439 440
#define rdev_for_each_list(rdev, tmp, head)				\
	list_for_each_entry_safe(rdev, tmp, head, same_set)

L
Linus Torvalds 已提交
441 442 443
/*
 * iterates through the 'same array disks' ringlist
 */
444
#define rdev_for_each(rdev, tmp, mddev)				\
445
	list_for_each_entry_safe(rdev, tmp, &((mddev)->disks), same_set)
L
Linus Torvalds 已提交
446

447 448 449
#define rdev_for_each_rcu(rdev, mddev)				\
	list_for_each_entry_rcu(rdev, &((mddev)->disks), same_set)

L
Linus Torvalds 已提交
450 451 452 453 454 455
typedef struct mdk_thread_s {
	void			(*run) (mddev_t *mddev);
	mddev_t			*mddev;
	wait_queue_head_t	wqueue;
	unsigned long           flags;
	struct task_struct	*tsk;
456
	unsigned long		timeout;
L
Linus Torvalds 已提交
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
} mdk_thread_t;

#define THREAD_WAKEUP  0

#define __wait_event_lock_irq(wq, condition, lock, cmd) 		\
do {									\
	wait_queue_t __wait;						\
	init_waitqueue_entry(&__wait, current);				\
									\
	add_wait_queue(&wq, &__wait);					\
	for (;;) {							\
		set_current_state(TASK_UNINTERRUPTIBLE);		\
		if (condition)						\
			break;						\
		spin_unlock_irq(&lock);					\
		cmd;							\
		schedule();						\
		spin_lock_irq(&lock);					\
	}								\
	current->state = TASK_RUNNING;					\
	remove_wait_queue(&wq, &__wait);				\
} while (0)

#define wait_event_lock_irq(wq, condition, lock, cmd) 			\
do {									\
	if (condition)	 						\
		break;							\
	__wait_event_lock_irq(wq, condition, lock, cmd);		\
} while (0)

487 488 489 490 491
static inline void safe_put_page(struct page *p)
{
	if (p) put_page(p);
}

492 493 494 495 496 497 498 499 500 501 502 503
extern int register_md_personality(struct mdk_personality *p);
extern int unregister_md_personality(struct mdk_personality *p);
extern mdk_thread_t * md_register_thread(void (*run) (mddev_t *mddev),
				mddev_t *mddev, const char *name);
extern void md_unregister_thread(mdk_thread_t *thread);
extern void md_wakeup_thread(mdk_thread_t *thread);
extern void md_check_recovery(mddev_t *mddev);
extern void md_write_start(mddev_t *mddev, struct bio *bi);
extern void md_write_end(mddev_t *mddev);
extern void md_done_sync(mddev_t *mddev, int blocks, int ok);
extern void md_error(mddev_t *mddev, mdk_rdev_t *rdev);

504
extern int mddev_congested(mddev_t *mddev, int bits);
505
extern void md_barrier_request(mddev_t *mddev, struct bio *bio);
506 507 508 509 510 511 512 513 514
extern void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
			   sector_t sector, int size, struct page *page);
extern void md_super_wait(mddev_t *mddev);
extern int sync_page_io(struct block_device *bdev, sector_t sector, int size,
			struct page *page, int rw);
extern void md_do_sync(mddev_t *mddev);
extern void md_new_event(mddev_t *mddev);
extern int md_allow_write(mddev_t *mddev);
extern void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev);
515
extern void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors);
516
extern int md_check_no_bitmap(mddev_t *mddev);
517
extern int md_integrity_register(mddev_t *mddev);
518 519
extern void md_integrity_add_rdev(mdk_rdev_t *rdev, mddev_t *mddev);
extern int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale);
520
extern void restore_bitmap_write_access(struct file *file);
N
NeilBrown 已提交
521
extern void md_unplug(mddev_t *mddev);
C
Christoph Hellwig 已提交
522

523 524 525 526
extern void mddev_init(mddev_t *mddev);
extern int md_run(mddev_t *mddev);
extern void md_stop(mddev_t *mddev);
extern void md_stop_writes(mddev_t *mddev);
N
NeilBrown 已提交
527
extern void md_rdev_init(mdk_rdev_t *rdev);
C
Christoph Hellwig 已提交
528

529 530
extern void mddev_suspend(mddev_t *mddev);
extern void mddev_resume(mddev_t *mddev);
C
Christoph Hellwig 已提交
531
#endif /* _MD_MD_H */