1 files changed, 134 insertions, 0 deletions
diff --git a/drivers/md/raid1.h b/drivers/md/raid1.h
new file mode 100644
index 000000000000..0a9ba7c3302e
--- /dev/null
+++ b/drivers/md/raid1.h
@@ -0,0 +1,134 @@
+#ifndef _RAID1_H
+#define _RAID1_H
+#include <linux/raid/md.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;
+        /* queue of writes that have been unplugged */
+        struct bio_list         flushing_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.
+                                            */
+        wait_queue_head_t       wait_barrier;
+        struct pool_info        *poolinfo;
+        struct page             *tmppage;
+        mempool_t *r1bio_pool;
+        mempool_t *r1buf_pool;
+};
+typedef struct r1_private_data_s conf_t;
+/*
+ * this is the only point in the RAID code where we violate
+ * C type safety. mddev->private is an 'opaque' pointer.
+ */
+#define mddev_to_conf(mddev) ((conf_t *) mddev->private)
+/*
+ * 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;
+        struct bitmap_update    *bitmap_update;
+        /*
+         * 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)
+/* bits for r1bio.state */
+#define R1BIO_Uptodate  0
+#define R1BIO_IsSync    1
+#define R1BIO_Degraded  2
+#define R1BIO_BehindIO  3
+#define R1BIO_Barrier   4
+#define R1BIO_BarrierRetry 5
+/* 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
+#endif

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