[deliverable/linux.git] / drivers / md / raid1.h

#ifndef _RAID1_H
#define _RAID1_H

typedef struct mirror_info mirror_info_t;

struct mirror_info {
	mdk_rdev_t	*rdev;
	sector_t	head_position;
};

/*
 * memory pools need a pointer to the mddev, so they can force an unplug
 * when memory is tight, and a count of the number of drives that the
 * pool was allocated for, so they know how much to allocate and free.
 * mddev->raid_disks cannot be used, as it can change while a pool is active
 * These two datums are stored in a kmalloced struct.
 */

struct pool_info {
	mddev_t *mddev;
	int	raid_disks;
};


typedef struct r1bio_s r1bio_t;

struct r1_private_data_s {
	mddev_t			*mddev;
	mirror_info_t		*mirrors;
	int			raid_disks;
	int			last_used;
	sector_t		next_seq_sect;
	spinlock_t		device_lock;

	struct list_head	retry_list;
	/* queue pending writes and submit them on unplug */
	struct bio_list		pending_bio_list;

	/* for use when syncing mirrors: */

	spinlock_t		resync_lock;
	int			nr_pending;
	int			nr_waiting;
	int			nr_queued;
	int			barrier;
	sector_t		next_resync;
	int			fullsync;  /* set to 1 if a full sync is needed,
					    * (fresh device added).
					    * Cleared when a sync completes.
					    */
	int			recovery_disabled; /* when the same as
						    * mddev->recovery_disabled
						    * we don't allow recovery
						    * to be attempted as we
						    * expect a read error
						    */

	wait_queue_head_t	wait_barrier;

	struct pool_info	*poolinfo;

	struct page		*tmppage;

	mempool_t *r1bio_pool;
	mempool_t *r1buf_pool;

	/* When taking over an array from a different personality, we store
	 * the new thread here until we fully activate the array.
	 */
	struct mdk_thread_s	*thread;
};

typedef struct r1_private_data_s conf_t;

/*
 * this is our 'private' RAID1 bio.
 *
 * it contains information about what kind of IO operations were started
 * for this RAID1 operation, and about their status:
 */

struct r1bio_s {
	atomic_t		remaining; /* 'have we finished' count,
					    * used from IRQ handlers
					    */
	atomic_t		behind_remaining; /* number of write-behind ios remaining
						 * in this BehindIO request
						 */
	sector_t		sector;
	int			sectors;
	unsigned long		state;
	mddev_t			*mddev;
	/*
	 * original bio going to /dev/mdx
	 */
	struct bio		*master_bio;
	/*
	 * if the IO is in READ direction, then this is where we read
	 */
	int			read_disk;

	struct list_head	retry_list;
	/* Next two are only valid when R1BIO_BehindIO is set */
	struct bio_vec		*behind_bvecs;
	int			behind_page_count;
	/*
	 * if the IO is in WRITE direction, then multiple bios are used.
	 * We choose the number when they are allocated.
	 */
	struct bio		*bios[0];
	/* DO NOT PUT ANY NEW FIELDS HERE - bios array is contiguously alloced*/
};

/* when we get a read error on a read-only array, we redirect to another
 * device without failing the first device, or trying to over-write to
 * correct the read error.  To keep track of bad blocks on a per-bio
 * level, we store IO_BLOCKED in the appropriate 'bios' pointer
 */
#define IO_BLOCKED ((struct bio *)1)
/* When we successfully write to a known bad-block, we need to remove the
 * bad-block marking which must be done from process context.  So we record
 * the success by setting bios[n] to IO_MADE_GOOD
 */
#define IO_MADE_GOOD ((struct bio *)2)

#define BIO_SPECIAL(bio) ((unsigned long)bio <= 2)

/* bits for r1bio.state */
#define	R1BIO_Uptodate	0
#define	R1BIO_IsSync	1
#define	R1BIO_Degraded	2
#define	R1BIO_BehindIO	3
/* Set ReadError on bios that experience a readerror so that
 * raid1d knows what to do with them.
 */
#define R1BIO_ReadError 4
/* For write-behind requests, we call bi_end_io when
 * the last non-write-behind device completes, providing
 * any write was successful.  Otherwise we call when
 * any write-behind write succeeds, otherwise we call
 * with failure when last write completes (and all failed).
 * Record that bi_end_io was called with this flag...
 */
#define	R1BIO_Returned 6
/* If a write for this request means we can clear some
 * known-bad-block records, we set this flag
 */
#define	R1BIO_MadeGood 7
#define	R1BIO_WriteError 8

extern int md_raid1_congested(mddev_t *mddev, int bits);

#endif
Commit	Line	Data
1da177e4 LT	1	#ifndef _RAID1_H
	2	#define _RAID1_H
	3
1da177e4 LT	4	typedef struct mirror_info mirror_info_t;
	5
	6	struct mirror_info {
	7	mdk_rdev_t *rdev;
	8	sector_t head_position;
	9	};
	10
	11	/*
	12	* memory pools need a pointer to the mddev, so they can force an unplug
	13	* when memory is tight, and a count of the number of drives that the
	14	* pool was allocated for, so they know how much to allocate and free.
	15	* mddev->raid_disks cannot be used, as it can change while a pool is active
	16	* These two datums are stored in a kmalloced struct.
	17	*/
	18
	19	struct pool_info {
	20	mddev_t *mddev;
	21	int raid_disks;
	22	};
	23
	24
	25	typedef struct r1bio_s r1bio_t;
	26
	27	struct r1_private_data_s {
	28	mddev_t *mddev;
	29	mirror_info_t *mirrors;
	30	int raid_disks;
1da177e4 LT	31	int last_used;
	32	sector_t next_seq_sect;
	33	spinlock_t device_lock;
	34
	35	struct list_head retry_list;
191ea9b2 N	36	/* queue pending writes and submit them on unplug */
191ea9b2 N	37	struct bio_list pending_bio_list;
191ea9b2	38
1da177e4 LT	39	/* for use when syncing mirrors: */
	40
	41	spinlock_t resync_lock;
191ea9b2	42	int nr_pending;
17999be4	43	int nr_waiting;
ddaf22ab	44	int nr_queued;
191ea9b2	45	int barrier;
1da177e4	46	sector_t next_resync;
191ea9b2 N	47	int fullsync; /* set to 1 if a full sync is needed,
	48	* (fresh device added).
	49	* Cleared when a sync completes.
	50	*/
5389042f N	51	int recovery_disabled; /* when the same as
	52	* mddev->recovery_disabled
	53	* we don't allow recovery
	54	* to be attempted as we
	55	* expect a read error
	56	*/
1da177e4	57
17999be4	58	wait_queue_head_t wait_barrier;
1da177e4 LT	59
	60	struct pool_info *poolinfo;
	61
ddaf22ab N	62	struct page *tmppage;
ddaf22ab N	63
1da177e4 LT	64	mempool_t *r1bio_pool;
1da177e4 LT	65	mempool_t *r1buf_pool;
709ae487 N	66
	67	/* When taking over an array from a different personality, we store
	68	* the new thread here until we fully activate the array.
	69	*/
	70	struct mdk_thread_s *thread;
1da177e4 LT	71	};
	72
	73	typedef struct r1_private_data_s conf_t;
	74
1da177e4 LT	75	/*
	76	* this is our 'private' RAID1 bio.
	77	*
	78	* it contains information about what kind of IO operations were started
	79	* for this RAID1 operation, and about their status:
	80	*/
	81
	82	struct r1bio_s {
	83	atomic_t remaining; /* 'have we finished' count,
	84	* used from IRQ handlers
	85	*/
4b6d287f N	86	atomic_t behind_remaining; /* number of write-behind ios remaining
	87	* in this BehindIO request
	88	*/
1da177e4 LT	89	sector_t sector;
	90	int sectors;
	91	unsigned long state;
	92	mddev_t *mddev;
	93	/*
	94	* original bio going to /dev/mdx
	95	*/
	96	struct bio *master_bio;
	97	/*
	98	* if the IO is in READ direction, then this is where we read
	99	*/
	100	int read_disk;
	101
	102	struct list_head retry_list;
af6d7b76	103	/* Next two are only valid when R1BIO_BehindIO is set */
2ca68f5e	104	struct bio_vec *behind_bvecs;
af6d7b76	105	int behind_page_count;
1da177e4 LT	106	/*
	107	* if the IO is in WRITE direction, then multiple bios are used.
	108	* We choose the number when they are allocated.
	109	*/
	110	struct bio *bios[0];
191ea9b2	111	/* DO NOT PUT ANY NEW FIELDS HERE - bios array is contiguously alloced*/
1da177e4 LT	112	};
1da177e4 LT	113
cf30a473 N	114	/* when we get a read error on a read-only array, we redirect to another
	115	* device without failing the first device, or trying to over-write to
	116	* correct the read error. To keep track of bad blocks on a per-bio
	117	* level, we store IO_BLOCKED in the appropriate 'bios' pointer
	118	*/
4367af55 N	119	#define IO_BLOCKED ((struct bio *)1)
	120	/* When we successfully write to a known bad-block, we need to remove the
	121	* bad-block marking which must be done from process context. So we record
	122	* the success by setting bios[n] to IO_MADE_GOOD
	123	*/
	124	#define IO_MADE_GOOD ((struct bio *)2)
	125
	126	#define BIO_SPECIAL(bio) ((unsigned long)bio <= 2)
cf30a473	127
1da177e4 LT	128	/* bits for r1bio.state */
	129	#define R1BIO_Uptodate 0
	130	#define R1BIO_IsSync 1
191ea9b2	131	#define R1BIO_Degraded 2
a9701a30	132	#define R1BIO_BehindIO 3
d2eb35ac N	133	/* Set ReadError on bios that experience a readerror so that
	134	* raid1d knows what to do with them.
	135	*/
	136	#define R1BIO_ReadError 4
4b6d287f N	137	/* For write-behind requests, we call bi_end_io when
	138	* the last non-write-behind device completes, providing
	139	* any write was successful. Otherwise we call when
	140	* any write-behind write succeeds, otherwise we call
	141	* with failure when last write completes (and all failed).
	142	* Record that bi_end_io was called with this flag...
	143	*/
9e71f9c8	144	#define R1BIO_Returned 6
4367af55 N	145	/* If a write for this request means we can clear some
	146	* known-bad-block records, we set this flag
	147	*/
cd5ff9a1 N	148	#define R1BIO_MadeGood 7
cd5ff9a1 N	149	#define R1BIO_WriteError 8
4b6d287f	150
1ed7242e JB	151	extern int md_raid1_congested(mddev_t *mddev, int bits);
1ed7242e JB	152
1da177e4	153	#endif