1#ifndef _RAID1_H
2#define _RAID1_H
3
4typedef struct mirror_info mirror_info_t;
5
6struct 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
19struct pool_info {
20	mddev_t *mddev;
21	int	raid_disks;
22};
23
24
25typedef struct r1bio_s r1bio_t;
26
27struct r1_private_data_s {
28	mddev_t			*mddev;
29	mirror_info_t		*mirrors;
30	int			raid_disks;
31	int			last_used;
32	sector_t		next_seq_sect;
33	spinlock_t		device_lock;
34
35	struct list_head	retry_list;
36	/* queue pending writes and submit them on unplug */
37	struct bio_list		pending_bio_list;
38	/* queue of writes that have been unplugged */
39	struct bio_list		flushing_bio_list;
40
41	/* for use when syncing mirrors: */
42
43	spinlock_t		resync_lock;
44	int			nr_pending;
45	int			nr_waiting;
46	int			nr_queued;
47	int			barrier;
48	sector_t		next_resync;
49	int			fullsync;  /* set to 1 if a full sync is needed,
50					    * (fresh device added).
51					    * Cleared when a sync completes.
52					    */
53
54	wait_queue_head_t	wait_barrier;
55
56	struct pool_info	*poolinfo;
57
58	struct page		*tmppage;
59
60	mempool_t *r1bio_pool;
61	mempool_t *r1buf_pool;
62
63	/* When taking over an array from a different personality, we store
64	 * the new thread here until we fully activate the array.
65	 */
66	struct mdk_thread_s	*thread;
67};
68
69typedef struct r1_private_data_s conf_t;
70
71/*
72 * this is our 'private' RAID1 bio.
73 *
74 * it contains information about what kind of IO operations were started
75 * for this RAID1 operation, and about their status:
76 */
77
78struct r1bio_s {
79	atomic_t		remaining; /* 'have we finished' count,
80					    * used from IRQ handlers
81					    */
82	atomic_t		behind_remaining; /* number of write-behind ios remaining
83						 * in this BehindIO request
84						 */
85	sector_t		sector;
86	int			sectors;
87	unsigned long		state;
88	mddev_t			*mddev;
89	/*
90	 * original bio going to /dev/mdx
91	 */
92	struct bio		*master_bio;
93	/*
94	 * if the IO is in READ direction, then this is where we read
95	 */
96	int			read_disk;
97
98	struct list_head	retry_list;
99	struct bitmap_update	*bitmap_update;
100	/*
101	 * if the IO is in WRITE direction, then multiple bios are used.
102	 * We choose the number when they are allocated.
103	 */
104	struct bio		*bios[0];
105	/* DO NOT PUT ANY NEW FIELDS HERE - bios array is contiguously alloced*/
106};
107
108/* when we get a read error on a read-only array, we redirect to another
109 * device without failing the first device, or trying to over-write to
110 * correct the read error.  To keep track of bad blocks on a per-bio
111 * level, we store IO_BLOCKED in the appropriate 'bios' pointer
112 */
113#define IO_BLOCKED ((struct bio*)1)
114
115/* bits for r1bio.state */
116#define	R1BIO_Uptodate	0
117#define	R1BIO_IsSync	1
118#define	R1BIO_Degraded	2
119#define	R1BIO_BehindIO	3
120#define	R1BIO_Barrier	4
121#define R1BIO_BarrierRetry 5
122/* For write-behind requests, we call bi_end_io when
123 * the last non-write-behind device completes, providing
124 * any write was successful.  Otherwise we call when
125 * any write-behind write succeeds, otherwise we call
126 * with failure when last write completes (and all failed).
127 * Record that bi_end_io was called with this flag...
128 */
129#define	R1BIO_Returned 6
130
131#endif
132