/*
   * raid1.c : Multiple Devices driver for Linux
   *
   * Copyright (C) 1999, 2000, 2001 Ingo Molnar, Red Hat
   *
   * Copyright (C) 1996, 1997, 1998 Ingo Molnar, Miguel de Icaza, Gadi Oxman
   *
   * RAID-1 management functions.
   *
   * Better read-balancing code written by Mika Kuoppala <miku@iki.fi>, 2000
   *

   * Fixes to reconstruction by Jakob Østergaard" <jakob@ostenfeld.dk>

   * Various fixes by Neil Brown <neilb@cse.unsw.edu.au>
   *

   * Changes by Peter T. Breuer <ptb@it.uc3m.es> 31/1/2003 to support
   * bitmapped intelligence in resync:
   *
   *      - bitmap marked during normal i/o
   *      - bitmap used to skip nondirty blocks during sync
   *
   * Additions to bitmap code, (C) 2003-2004 Paul Clements, SteelEye Technology:
   * - persistent bitmap code
   *

   * 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.
   */

  #include <linux/slab.h>

  #include <linux/delay.h>

  #include <linux/blkdev.h>

  #include <linux/module.h>

  #include <linux/seq_file.h>

  #include <linux/ratelimit.h>

  #include "md.h"

  #include "raid1.h"
  #include "bitmap.h"

  /*
   * Number of guaranteed r1bios in case of extreme VM load:
   */
  #define	NR_RAID1_BIOS 256

  /* When there are this many requests queue to be written by
   * the raid1 thread, we become 'congested' to provide back-pressure
   * for writeback.
   */
  static int max_queued_requests = 1024;

  static void allow_barrier(struct r1conf *conf);
  static void lower_barrier(struct r1conf *conf);

  static void * r1bio_pool_alloc(gfp_t gfp_flags, void *data)

  {
  	struct pool_info *pi = data;

  	int size = offsetof(struct r1bio, bios[pi->raid_disks]);

  
  	/* allocate a r1bio with room for raid_disks entries in the bios array */

  	return kzalloc(size, gfp_flags);

  }
  
  static void r1bio_pool_free(void *r1_bio, void *data)
  {
  	kfree(r1_bio);
  }
  
  #define RESYNC_BLOCK_SIZE (64*1024)
  //#define RESYNC_BLOCK_SIZE PAGE_SIZE
  #define RESYNC_SECTORS (RESYNC_BLOCK_SIZE >> 9)
  #define RESYNC_PAGES ((RESYNC_BLOCK_SIZE + PAGE_SIZE-1) / PAGE_SIZE)
  #define RESYNC_WINDOW (2048*1024)

  static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)

  {
  	struct pool_info *pi = data;
  	struct page *page;

  	struct r1bio *r1_bio;

  	struct bio *bio;
  	int i, j;
  
  	r1_bio = r1bio_pool_alloc(gfp_flags, pi);

  	if (!r1_bio)

  		return NULL;

  
  	/*
  	 * Allocate bios : 1 for reading, n-1 for writing
  	 */
  	for (j = pi->raid_disks ; j-- ; ) {

  		bio = bio_kmalloc(gfp_flags, RESYNC_PAGES);

  		if (!bio)
  			goto out_free_bio;
  		r1_bio->bios[j] = bio;
  	}
  	/*
  	 * Allocate RESYNC_PAGES data pages and attach them to

  	 * the first bio.
  	 * If this is a user-requested check/repair, allocate
  	 * RESYNC_PAGES for each bio.

  	 */

  	if (test_bit(MD_RECOVERY_REQUESTED, &pi->mddev->recovery))
  		j = pi->raid_disks;
  	else
  		j = 1;
  	while(j--) {
  		bio = r1_bio->bios[j];
  		for (i = 0; i < RESYNC_PAGES; i++) {
  			page = alloc_page(gfp_flags);
  			if (unlikely(!page))
  				goto out_free_pages;
  
  			bio->bi_io_vec[i].bv_page = page;

  			bio->bi_vcnt = i+1;

  		}
  	}
  	/* If not user-requests, copy the page pointers to all bios */
  	if (!test_bit(MD_RECOVERY_REQUESTED, &pi->mddev->recovery)) {
  		for (i=0; i<RESYNC_PAGES ; i++)
  			for (j=1; j<pi->raid_disks; j++)
  				r1_bio->bios[j]->bi_io_vec[i].bv_page =
  					r1_bio->bios[0]->bi_io_vec[i].bv_page;

  	}
  
  	r1_bio->master_bio = NULL;
  
  	return r1_bio;
  
  out_free_pages:

  	for (j=0 ; j < pi->raid_disks; j++)
  		for (i=0; i < r1_bio->bios[j]->bi_vcnt ; i++)
  			put_page(r1_bio->bios[j]->bi_io_vec[i].bv_page);

  	j = -1;

  out_free_bio:

  	while (++j < pi->raid_disks)

  		bio_put(r1_bio->bios[j]);
  	r1bio_pool_free(r1_bio, data);
  	return NULL;
  }
  
  static void r1buf_pool_free(void *__r1_bio, void *data)
  {
  	struct pool_info *pi = data;

  	int i,j;

  	struct r1bio *r1bio = __r1_bio;

  	for (i = 0; i < RESYNC_PAGES; i++)
  		for (j = pi->raid_disks; j-- ;) {
  			if (j == 0 ||
  			    r1bio->bios[j]->bi_io_vec[i].bv_page !=
  			    r1bio->bios[0]->bi_io_vec[i].bv_page)

  				safe_put_page(r1bio->bios[j]->bi_io_vec[i].bv_page);

  		}

  	for (i=0 ; i < pi->raid_disks; i++)
  		bio_put(r1bio->bios[i]);
  
  	r1bio_pool_free(r1bio, data);
  }

  static void put_all_bios(struct r1conf *conf, struct r1bio *r1_bio)

  {
  	int i;

  	for (i = 0; i < conf->raid_disks * 2; i++) {

  		struct bio **bio = r1_bio->bios + i;

  		if (!BIO_SPECIAL(*bio))

  			bio_put(*bio);
  		*bio = NULL;
  	}
  }

  static void free_r1bio(struct r1bio *r1_bio)

  {

  	struct r1conf *conf = r1_bio->mddev->private;

  	put_all_bios(conf, r1_bio);
  	mempool_free(r1_bio, conf->r1bio_pool);
  }

  static void put_buf(struct r1bio *r1_bio)

  {

  	struct r1conf *conf = r1_bio->mddev->private;

  	int i;

  	for (i = 0; i < conf->raid_disks * 2; i++) {

  		struct bio *bio = r1_bio->bios[i];
  		if (bio->bi_end_io)
  			rdev_dec_pending(conf->mirrors[i].rdev, r1_bio->mddev);
  	}

  
  	mempool_free(r1_bio, conf->r1buf_pool);

  	lower_barrier(conf);

  }

  static void reschedule_retry(struct r1bio *r1_bio)

  {
  	unsigned long flags;

  	struct mddev *mddev = r1_bio->mddev;

  	struct r1conf *conf = mddev->private;

  
  	spin_lock_irqsave(&conf->device_lock, flags);
  	list_add(&r1_bio->retry_list, &conf->retry_list);

  	conf->nr_queued ++;

  	spin_unlock_irqrestore(&conf->device_lock, flags);

  	wake_up(&conf->wait_barrier);

  	md_wakeup_thread(mddev->thread);
  }
  
  /*
   * raid_end_bio_io() is called when we have finished servicing a mirrored
   * operation and are ready to return a success/failure code to the buffer
   * cache layer.
   */

  static void call_bio_endio(struct r1bio *r1_bio)

  {
  	struct bio *bio = r1_bio->master_bio;
  	int done;

  	struct r1conf *conf = r1_bio->mddev->private;

  
  	if (bio->bi_phys_segments) {
  		unsigned long flags;
  		spin_lock_irqsave(&conf->device_lock, flags);
  		bio->bi_phys_segments--;
  		done = (bio->bi_phys_segments == 0);
  		spin_unlock_irqrestore(&conf->device_lock, flags);
  	} else
  		done = 1;
  
  	if (!test_bit(R1BIO_Uptodate, &r1_bio->state))
  		clear_bit(BIO_UPTODATE, &bio->bi_flags);
  	if (done) {
  		bio_endio(bio, 0);
  		/*
  		 * Wake up any possible resync thread that waits for the device
  		 * to go idle.
  		 */
  		allow_barrier(conf);
  	}
  }

  static void raid_end_bio_io(struct r1bio *r1_bio)

  {
  	struct bio *bio = r1_bio->master_bio;

  	/* if nobody has done the final endio yet, do it now */
  	if (!test_and_set_bit(R1BIO_Returned, &r1_bio->state)) {

  		pr_debug("raid1: sync end %s on sectors %llu-%llu
  ",
  			 (bio_data_dir(bio) == WRITE) ? "write" : "read",
  			 (unsigned long long) bio->bi_sector,
  			 (unsigned long long) bio->bi_sector +
  			 (bio->bi_size >> 9) - 1);

  		call_bio_endio(r1_bio);

  	}

  	free_r1bio(r1_bio);
  }
  
  /*
   * Update disk head position estimator based on IRQ completion info.
   */

  static inline void update_head_pos(int disk, struct r1bio *r1_bio)

  {

  	struct r1conf *conf = r1_bio->mddev->private;

  
  	conf->mirrors[disk].head_position =
  		r1_bio->sector + (r1_bio->sectors);
  }

  /*
   * Find the disk number which triggered given bio
   */

  static int find_bio_disk(struct r1bio *r1_bio, struct bio *bio)

  {
  	int mirror;

  	struct r1conf *conf = r1_bio->mddev->private;
  	int raid_disks = conf->raid_disks;

  	for (mirror = 0; mirror < raid_disks * 2; mirror++)

  		if (r1_bio->bios[mirror] == bio)
  			break;

  	BUG_ON(mirror == raid_disks * 2);

  	update_head_pos(mirror, r1_bio);
  
  	return mirror;
  }

  static void raid1_end_read_request(struct bio *bio, int error)

  {
  	int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);

  	struct r1bio *r1_bio = bio->bi_private;

  	int mirror;

  	struct r1conf *conf = r1_bio->mddev->private;

  	mirror = r1_bio->read_disk;
  	/*
  	 * this branch is our 'one mirror IO has finished' event handler:
  	 */

  	update_head_pos(mirror, r1_bio);

  	if (uptodate)
  		set_bit(R1BIO_Uptodate, &r1_bio->state);
  	else {
  		/* If all other devices have failed, we want to return
  		 * the error upwards rather than fail the last device.
  		 * Here we redefine "uptodate" to mean "Don't want to retry"

  		 */

  		unsigned long flags;
  		spin_lock_irqsave(&conf->device_lock, flags);
  		if (r1_bio->mddev->degraded == conf->raid_disks ||
  		    (r1_bio->mddev->degraded == conf->raid_disks-1 &&
  		     !test_bit(Faulty, &conf->mirrors[mirror].rdev->flags)))
  			uptodate = 1;
  		spin_unlock_irqrestore(&conf->device_lock, flags);
  	}

  	if (uptodate)

  		raid_end_bio_io(r1_bio);

  	else {

  		/*
  		 * oops, read error:
  		 */
  		char b[BDEVNAME_SIZE];

  		printk_ratelimited(
  			KERN_ERR "md/raid1:%s: %s: "
  			"rescheduling sector %llu
  ",
  			mdname(conf->mddev),
  			bdevname(conf->mirrors[mirror].rdev->bdev,
  				 b),
  			(unsigned long long)r1_bio->sector);

  		set_bit(R1BIO_ReadError, &r1_bio->state);

  		reschedule_retry(r1_bio);
  	}
  
  	rdev_dec_pending(conf->mirrors[mirror].rdev, conf->mddev);

  }

  static void close_write(struct r1bio *r1_bio)

  {
  	/* it really is the end of this request */
  	if (test_bit(R1BIO_BehindIO, &r1_bio->state)) {
  		/* free extra copy of the data pages */
  		int i = r1_bio->behind_page_count;
  		while (i--)
  			safe_put_page(r1_bio->behind_bvecs[i].bv_page);
  		kfree(r1_bio->behind_bvecs);
  		r1_bio->behind_bvecs = NULL;
  	}
  	/* clear the bitmap if all writes complete successfully */
  	bitmap_endwrite(r1_bio->mddev->bitmap, r1_bio->sector,
  			r1_bio->sectors,
  			!test_bit(R1BIO_Degraded, &r1_bio->state),
  			test_bit(R1BIO_BehindIO, &r1_bio->state));
  	md_write_end(r1_bio->mddev);
  }

  static void r1_bio_write_done(struct r1bio *r1_bio)

  {

  	if (!atomic_dec_and_test(&r1_bio->remaining))
  		return;
  
  	if (test_bit(R1BIO_WriteError, &r1_bio->state))
  		reschedule_retry(r1_bio);
  	else {
  		close_write(r1_bio);

  		if (test_bit(R1BIO_MadeGood, &r1_bio->state))
  			reschedule_retry(r1_bio);
  		else
  			raid_end_bio_io(r1_bio);

  	}
  }

  static void raid1_end_write_request(struct bio *bio, int error)

  {
  	int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);

  	struct r1bio *r1_bio = bio->bi_private;

  	int mirror, behind = test_bit(R1BIO_BehindIO, &r1_bio->state);

  	struct r1conf *conf = r1_bio->mddev->private;

  	struct bio *to_put = NULL;

  	mirror = find_bio_disk(r1_bio, bio);

  	/*
  	 * 'one mirror IO has finished' event handler:
  	 */

  	if (!uptodate) {

  		set_bit(WriteErrorSeen,
  			&conf->mirrors[mirror].rdev->flags);

  		if (!test_and_set_bit(WantReplacement,
  				      &conf->mirrors[mirror].rdev->flags))
  			set_bit(MD_RECOVERY_NEEDED, &
  				conf->mddev->recovery);

  		set_bit(R1BIO_WriteError, &r1_bio->state);

  	} else {

  		/*

  		 * Set R1BIO_Uptodate in our master bio, so that we
  		 * will return a good error code for to the higher
  		 * levels even if IO on some other mirrored buffer
  		 * fails.
  		 *
  		 * The 'master' represents the composite IO operation
  		 * to user-side. So if something waits for IO, then it
  		 * will wait for the 'master' bio.

  		 */

  		sector_t first_bad;
  		int bad_sectors;

  		r1_bio->bios[mirror] = NULL;
  		to_put = bio;

  		set_bit(R1BIO_Uptodate, &r1_bio->state);

  		/* Maybe we can clear some bad blocks. */
  		if (is_badblock(conf->mirrors[mirror].rdev,
  				r1_bio->sector, r1_bio->sectors,
  				&first_bad, &bad_sectors)) {
  			r1_bio->bios[mirror] = IO_MADE_GOOD;
  			set_bit(R1BIO_MadeGood, &r1_bio->state);
  		}
  	}

  	if (behind) {
  		if (test_bit(WriteMostly, &conf->mirrors[mirror].rdev->flags))
  			atomic_dec(&r1_bio->behind_remaining);
  
  		/*
  		 * In behind mode, we ACK the master bio once the I/O
  		 * has safely reached all non-writemostly
  		 * disks. Setting the Returned bit ensures that this
  		 * gets done only once -- we don't ever want to return
  		 * -EIO here, instead we'll wait
  		 */
  		if (atomic_read(&r1_bio->behind_remaining) >= (atomic_read(&r1_bio->remaining)-1) &&
  		    test_bit(R1BIO_Uptodate, &r1_bio->state)) {
  			/* Maybe we can return now */
  			if (!test_and_set_bit(R1BIO_Returned, &r1_bio->state)) {
  				struct bio *mbio = r1_bio->master_bio;

  				pr_debug("raid1: behind end write sectors"
  					 " %llu-%llu
  ",
  					 (unsigned long long) mbio->bi_sector,
  					 (unsigned long long) mbio->bi_sector +
  					 (mbio->bi_size >> 9) - 1);

  				call_bio_endio(r1_bio);

  			}
  		}
  	}

  	if (r1_bio->bios[mirror] == NULL)
  		rdev_dec_pending(conf->mirrors[mirror].rdev,
  				 conf->mddev);

  	/*

  	 * Let's see if all mirrored write operations have finished
  	 * already.
  	 */

  	r1_bio_write_done(r1_bio);

  	if (to_put)
  		bio_put(to_put);

  }
  
  
  /*
   * This routine returns the disk from which the requested read should
   * be done. There is a per-array 'next expected sequential IO' sector
   * number - if this matches on the next IO then we use the last disk.
   * There is also a per-disk 'last know head position' sector that is
   * maintained from IRQ contexts, both the normal and the resync IO
   * completion handlers update this position correctly. If there is no
   * perfect sequential match then we pick the disk whose head is closest.
   *
   * If there are 2 mirrors in the same 2 devices, performance degrades
   * because position is mirror, not device based.
   *
   * The rdev for the device selected will have nr_pending incremented.
   */

  static int read_balance(struct r1conf *conf, struct r1bio *r1_bio, int *max_sectors)

  {

  	const sector_t this_sector = r1_bio->sector;

  	int sectors;
  	int best_good_sectors;

  	int start_disk;

  	int best_disk;

  	int i;

  	sector_t best_dist;

  	struct md_rdev *rdev;

  	int choose_first;

  
  	rcu_read_lock();
  	/*

  	 * Check if we can balance. We can balance on the whole

  	 * device if no resync is going on, or below the resync window.
  	 * We take the first readable disk when above the resync window.
  	 */
   retry:

  	sectors = r1_bio->sectors;

  	best_disk = -1;
  	best_dist = MaxSector;

  	best_good_sectors = 0;

  	if (conf->mddev->recovery_cp < MaxSector &&
  	    (this_sector + sectors >= conf->next_resync)) {

  		choose_first = 1;
  		start_disk = 0;
  	} else {
  		choose_first = 0;
  		start_disk = conf->last_used;

  	}

  	for (i = 0 ; i < conf->raid_disks * 2 ; i++) {

  		sector_t dist;

  		sector_t first_bad;
  		int bad_sectors;

  		int disk = start_disk + i;
  		if (disk >= conf->raid_disks)
  			disk -= conf->raid_disks;
  
  		rdev = rcu_dereference(conf->mirrors[disk].rdev);
  		if (r1_bio->bios[disk] == IO_BLOCKED
  		    || rdev == NULL

  		    || test_bit(Faulty, &rdev->flags))

  			continue;

  		if (!test_bit(In_sync, &rdev->flags) &&
  		    rdev->recovery_offset < this_sector + sectors)

  			continue;

  		if (test_bit(WriteMostly, &rdev->flags)) {
  			/* Don't balance among write-mostly, just
  			 * use the first as a last resort */

  			if (best_disk < 0) {
  				if (is_badblock(rdev, this_sector, sectors,
  						&first_bad, &bad_sectors)) {
  					if (first_bad < this_sector)
  						/* Cannot use this */
  						continue;
  					best_good_sectors = first_bad - this_sector;
  				} else
  					best_good_sectors = sectors;

  				best_disk = disk;

  			}

  			continue;
  		}
  		/* This is a reasonable device to use.  It might
  		 * even be best.
  		 */

  		if (is_badblock(rdev, this_sector, sectors,
  				&first_bad, &bad_sectors)) {
  			if (best_dist < MaxSector)
  				/* already have a better device */
  				continue;
  			if (first_bad <= this_sector) {
  				/* cannot read here. If this is the 'primary'
  				 * device, then we must not read beyond
  				 * bad_sectors from another device..
  				 */
  				bad_sectors -= (this_sector - first_bad);
  				if (choose_first && sectors > bad_sectors)
  					sectors = bad_sectors;
  				if (best_good_sectors > sectors)
  					best_good_sectors = sectors;
  
  			} else {
  				sector_t good_sectors = first_bad - this_sector;
  				if (good_sectors > best_good_sectors) {
  					best_good_sectors = good_sectors;
  					best_disk = disk;
  				}
  				if (choose_first)
  					break;
  			}
  			continue;
  		} else
  			best_good_sectors = sectors;

  		dist = abs(this_sector - conf->mirrors[disk].head_position);
  		if (choose_first
  		    /* Don't change to another disk for sequential reads */
  		    || conf->next_seq_sect == this_sector
  		    || dist == 0
  		    /* If device is idle, use it */
  		    || atomic_read(&rdev->nr_pending) == 0) {
  			best_disk = disk;

  			break;
  		}

  		if (dist < best_dist) {
  			best_dist = dist;
  			best_disk = disk;

  		}

  	}

  	if (best_disk >= 0) {
  		rdev = rcu_dereference(conf->mirrors[best_disk].rdev);

  		if (!rdev)
  			goto retry;
  		atomic_inc(&rdev->nr_pending);

  		if (test_bit(Faulty, &rdev->flags)) {

  			/* cannot risk returning a device that failed
  			 * before we inc'ed nr_pending
  			 */

  			rdev_dec_pending(rdev, conf->mddev);

  			goto retry;
  		}

  		sectors = best_good_sectors;

  		conf->next_seq_sect = this_sector + sectors;

  		conf->last_used = best_disk;

  	}
  	rcu_read_unlock();

  	*max_sectors = sectors;

  	return best_disk;

  }

  int md_raid1_congested(struct mddev *mddev, int bits)

  {

  	struct r1conf *conf = mddev->private;

  	int i, ret = 0;

  	if ((bits & (1 << BDI_async_congested)) &&
  	    conf->pending_count >= max_queued_requests)
  		return 1;

  	rcu_read_lock();

  	for (i = 0; i < conf->raid_disks; i++) {

  		struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);

  		if (rdev && !test_bit(Faulty, &rdev->flags)) {

  			struct request_queue *q = bdev_get_queue(rdev->bdev);

  			BUG_ON(!q);

  			/* Note the '|| 1' - when read_balance prefers
  			 * non-congested targets, it can be removed
  			 */

  			if ((bits & (1<<BDI_async_congested)) || 1)

  				ret |= bdi_congested(&q->backing_dev_info, bits);
  			else
  				ret &= bdi_congested(&q->backing_dev_info, bits);
  		}
  	}
  	rcu_read_unlock();
  	return ret;
  }

  EXPORT_SYMBOL_GPL(md_raid1_congested);

  static int raid1_congested(void *data, int bits)
  {

  	struct mddev *mddev = data;

  
  	return mddev_congested(mddev, bits) ||
  		md_raid1_congested(mddev, bits);
  }

  static void flush_pending_writes(struct r1conf *conf)

  {
  	/* Any writes that have been queued but are awaiting
  	 * bitmap updates get flushed here.

  	 */

  	spin_lock_irq(&conf->device_lock);
  
  	if (conf->pending_bio_list.head) {
  		struct bio *bio;
  		bio = bio_list_get(&conf->pending_bio_list);

  		conf->pending_count = 0;

  		spin_unlock_irq(&conf->device_lock);
  		/* flush any pending bitmap writes to
  		 * disk before proceeding w/ I/O */
  		bitmap_unplug(conf->mddev->bitmap);

  		wake_up(&conf->wait_barrier);

  
  		while (bio) { /* submit pending writes */
  			struct bio *next = bio->bi_next;
  			bio->bi_next = NULL;
  			generic_make_request(bio);
  			bio = next;
  		}

  	} else
  		spin_unlock_irq(&conf->device_lock);

  }

  /* Barriers....
   * Sometimes we need to suspend IO while we do something else,
   * either some resync/recovery, or reconfigure the array.
   * To do this we raise a 'barrier'.
   * The 'barrier' is a counter that can be raised multiple times
   * to count how many activities are happening which preclude
   * normal IO.
   * We can only raise the barrier if there is no pending IO.
   * i.e. if nr_pending == 0.
   * We choose only to raise the barrier if no-one is waiting for the
   * barrier to go down.  This means that as soon as an IO request
   * is ready, no other operations which require a barrier will start
   * until the IO request has had a chance.
   *
   * So: regular IO calls 'wait_barrier'.  When that returns there
   *    is no backgroup IO happening,  It must arrange to call
   *    allow_barrier when it has finished its IO.
   * backgroup IO calls must call raise_barrier.  Once that returns
   *    there is no normal IO happeing.  It must arrange to call
   *    lower_barrier when the particular background IO completes.

   */
  #define RESYNC_DEPTH 32

  static void raise_barrier(struct r1conf *conf)

  {
  	spin_lock_irq(&conf->resync_lock);

  
  	/* Wait until no block IO is waiting */
  	wait_event_lock_irq(conf->wait_barrier, !conf->nr_waiting,

  			    conf->resync_lock, );

  
  	/* block any new IO from starting */
  	conf->barrier++;

  	/* Now wait for all pending IO to complete */

  	wait_event_lock_irq(conf->wait_barrier,
  			    !conf->nr_pending && conf->barrier < RESYNC_DEPTH,

  			    conf->resync_lock, );

  
  	spin_unlock_irq(&conf->resync_lock);
  }

  static void lower_barrier(struct r1conf *conf)

  {
  	unsigned long flags;

  	BUG_ON(conf->barrier <= 0);

  	spin_lock_irqsave(&conf->resync_lock, flags);
  	conf->barrier--;
  	spin_unlock_irqrestore(&conf->resync_lock, flags);
  	wake_up(&conf->wait_barrier);
  }

  static void wait_barrier(struct r1conf *conf)

  {
  	spin_lock_irq(&conf->resync_lock);
  	if (conf->barrier) {
  		conf->nr_waiting++;
  		wait_event_lock_irq(conf->wait_barrier, !conf->barrier,
  				    conf->resync_lock,

  				    );

  		conf->nr_waiting--;

  	}

  	conf->nr_pending++;

  	spin_unlock_irq(&conf->resync_lock);
  }

  static void allow_barrier(struct r1conf *conf)

  {
  	unsigned long flags;
  	spin_lock_irqsave(&conf->resync_lock, flags);
  	conf->nr_pending--;
  	spin_unlock_irqrestore(&conf->resync_lock, flags);
  	wake_up(&conf->wait_barrier);
  }

  static void freeze_array(struct r1conf *conf)

  {
  	/* stop syncio and normal IO and wait for everything to
  	 * go quite.
  	 * We increment barrier and nr_waiting, and then

  	 * wait until nr_pending match nr_queued+1
  	 * This is called in the context of one normal IO request
  	 * that has failed. Thus any sync request that might be pending
  	 * will be blocked by nr_pending, and we need to wait for
  	 * pending IO requests to complete or be queued for re-try.
  	 * Thus the number queued (nr_queued) plus this request (1)
  	 * must match the number of pending IOs (nr_pending) before
  	 * we continue.

  	 */
  	spin_lock_irq(&conf->resync_lock);
  	conf->barrier++;
  	conf->nr_waiting++;
  	wait_event_lock_irq(conf->wait_barrier,

  			    conf->nr_pending == conf->nr_queued+1,

  			    conf->resync_lock,

  			    flush_pending_writes(conf));

  	spin_unlock_irq(&conf->resync_lock);
  }

  static void unfreeze_array(struct r1conf *conf)

  {
  	/* reverse the effect of the freeze */
  	spin_lock_irq(&conf->resync_lock);
  	conf->barrier--;
  	conf->nr_waiting--;
  	wake_up(&conf->wait_barrier);
  	spin_unlock_irq(&conf->resync_lock);
  }

  /* duplicate the data pages for behind I/O 

   */

  static void alloc_behind_pages(struct bio *bio, struct r1bio *r1_bio)

  {
  	int i;
  	struct bio_vec *bvec;

  	struct bio_vec *bvecs = kzalloc(bio->bi_vcnt * sizeof(struct bio_vec),

  					GFP_NOIO);

  	if (unlikely(!bvecs))

  		return;

  	bio_for_each_segment(bvec, bio, i) {

  		bvecs[i] = *bvec;
  		bvecs[i].bv_page = alloc_page(GFP_NOIO);
  		if (unlikely(!bvecs[i].bv_page))

  			goto do_sync_io;

  		memcpy(kmap(bvecs[i].bv_page) + bvec->bv_offset,
  		       kmap(bvec->bv_page) + bvec->bv_offset, bvec->bv_len);
  		kunmap(bvecs[i].bv_page);

  		kunmap(bvec->bv_page);
  	}

  	r1_bio->behind_bvecs = bvecs;

  	r1_bio->behind_page_count = bio->bi_vcnt;
  	set_bit(R1BIO_BehindIO, &r1_bio->state);
  	return;

  
  do_sync_io:

  	for (i = 0; i < bio->bi_vcnt; i++)

  		if (bvecs[i].bv_page)
  			put_page(bvecs[i].bv_page);
  	kfree(bvecs);

  	pr_debug("%dB behind alloc failed, doing sync I/O
  ", bio->bi_size);

  }

  static void make_request(struct mddev *mddev, struct bio * bio)

  {

  	struct r1conf *conf = mddev->private;

  	struct mirror_info *mirror;

  	struct r1bio *r1_bio;

  	struct bio *read_bio;

  	int i, disks;

  	struct bitmap *bitmap;

  	unsigned long flags;

  	const int rw = bio_data_dir(bio);

  	const unsigned long do_sync = (bio->bi_rw & REQ_SYNC);

  	const unsigned long do_flush_fua = (bio->bi_rw & (REQ_FLUSH | REQ_FUA));

  	struct md_rdev *blocked_rdev;

  	int plugged;

  	int first_clone;
  	int sectors_handled;
  	int max_sectors;

  	/*
  	 * Register the new request and wait if the reconstruction
  	 * thread has put up a bar for new requests.
  	 * Continue immediately if no resync is active currently.
  	 */

  	md_write_start(mddev, bio); /* wait on superblock update early */

  	if (bio_data_dir(bio) == WRITE &&
  	    bio->bi_sector + bio->bi_size/512 > mddev->suspend_lo &&
  	    bio->bi_sector < mddev->suspend_hi) {
  		/* As the suspend_* range is controlled by
  		 * userspace, we want an interruptible
  		 * wait.
  		 */
  		DEFINE_WAIT(w);
  		for (;;) {
  			flush_signals(current);
  			prepare_to_wait(&conf->wait_barrier,
  					&w, TASK_INTERRUPTIBLE);
  			if (bio->bi_sector + bio->bi_size/512 <= mddev->suspend_lo ||
  			    bio->bi_sector >= mddev->suspend_hi)
  				break;
  			schedule();
  		}
  		finish_wait(&conf->wait_barrier, &w);
  	}

  	wait_barrier(conf);

  	bitmap = mddev->bitmap;

  	/*
  	 * make_request() can abort the operation when READA is being
  	 * used and no empty request is available.
  	 *
  	 */
  	r1_bio = mempool_alloc(conf->r1bio_pool, GFP_NOIO);
  
  	r1_bio->master_bio = bio;
  	r1_bio->sectors = bio->bi_size >> 9;

  	r1_bio->state = 0;

  	r1_bio->mddev = mddev;
  	r1_bio->sector = bio->bi_sector;

  	/* We might need to issue multiple reads to different
  	 * devices if there are bad blocks around, so we keep
  	 * track of the number of reads in bio->bi_phys_segments.
  	 * If this is 0, there is only one r1_bio and no locking
  	 * will be needed when requests complete.  If it is
  	 * non-zero, then it is the number of not-completed requests.
  	 */
  	bio->bi_phys_segments = 0;
  	clear_bit(BIO_SEG_VALID, &bio->bi_flags);

  	if (rw == READ) {

  		/*
  		 * read balancing logic:
  		 */

  		int rdisk;
  
  read_again:
  		rdisk = read_balance(conf, r1_bio, &max_sectors);

  
  		if (rdisk < 0) {
  			/* couldn't find anywhere to read from */
  			raid_end_bio_io(r1_bio);

  			return;

  		}
  		mirror = conf->mirrors + rdisk;

  		if (test_bit(WriteMostly, &mirror->rdev->flags) &&
  		    bitmap) {
  			/* Reading from a write-mostly device must
  			 * take care not to over-take any writes
  			 * that are 'behind'
  			 */
  			wait_event(bitmap->behind_wait,
  				   atomic_read(&bitmap->behind_writes) == 0);
  		}

  		r1_bio->read_disk = rdisk;

  		read_bio = bio_clone_mddev(bio, GFP_NOIO, mddev);

  		md_trim_bio(read_bio, r1_bio->sector - bio->bi_sector,
  			    max_sectors);

  
  		r1_bio->bios[rdisk] = read_bio;
  
  		read_bio->bi_sector = r1_bio->sector + mirror->rdev->data_offset;
  		read_bio->bi_bdev = mirror->rdev->bdev;
  		read_bio->bi_end_io = raid1_end_read_request;

  		read_bio->bi_rw = READ | do_sync;

  		read_bio->bi_private = r1_bio;

  		if (max_sectors < r1_bio->sectors) {
  			/* could not read all from this device, so we will
  			 * need another r1_bio.
  			 */

  
  			sectors_handled = (r1_bio->sector + max_sectors
  					   - bio->bi_sector);
  			r1_bio->sectors = max_sectors;
  			spin_lock_irq(&conf->device_lock);
  			if (bio->bi_phys_segments == 0)
  				bio->bi_phys_segments = 2;
  			else
  				bio->bi_phys_segments++;
  			spin_unlock_irq(&conf->device_lock);
  			/* Cannot call generic_make_request directly
  			 * as that will be queued in __make_request
  			 * and subsequent mempool_alloc might block waiting
  			 * for it.  So hand bio over to raid1d.
  			 */
  			reschedule_retry(r1_bio);
  
  			r1_bio = mempool_alloc(conf->r1bio_pool, GFP_NOIO);
  
  			r1_bio->master_bio = bio;
  			r1_bio->sectors = (bio->bi_size >> 9) - sectors_handled;
  			r1_bio->state = 0;
  			r1_bio->mddev = mddev;
  			r1_bio->sector = bio->bi_sector + sectors_handled;
  			goto read_again;
  		} else
  			generic_make_request(read_bio);

  		return;

  	}
  
  	/*
  	 * WRITE:
  	 */

  	if (conf->pending_count >= max_queued_requests) {
  		md_wakeup_thread(mddev->thread);
  		wait_event(conf->wait_barrier,
  			   conf->pending_count < max_queued_requests);
  	}

  	/* first select target devices under rcu_lock and

  	 * inc refcount on their rdev.  Record them by setting
  	 * bios[x] to bio

  	 * If there are known/acknowledged bad blocks on any device on
  	 * which we have seen a write error, we want to avoid writing those
  	 * blocks.
  	 * This potentially requires several writes to write around
  	 * the bad blocks.  Each set of writes gets it's own r1bio
  	 * with a set of bios attached.

  	 */

  	plugged = mddev_check_plugged(mddev);

  	disks = conf->raid_disks * 2;

   retry_write:
  	blocked_rdev = NULL;

  	rcu_read_lock();

  	max_sectors = r1_bio->sectors;

  	for (i = 0;  i < disks; i++) {

  		struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);

  		if (rdev && unlikely(test_bit(Blocked, &rdev->flags))) {
  			atomic_inc(&rdev->nr_pending);
  			blocked_rdev = rdev;
  			break;
  		}

  		r1_bio->bios[i] = NULL;
  		if (!rdev || test_bit(Faulty, &rdev->flags)) {

  			if (i < conf->raid_disks)
  				set_bit(R1BIO_Degraded, &r1_bio->state);

  			continue;
  		}
  
  		atomic_inc(&rdev->nr_pending);
  		if (test_bit(WriteErrorSeen, &rdev->flags)) {
  			sector_t first_bad;
  			int bad_sectors;
  			int is_bad;
  
  			is_bad = is_badblock(rdev, r1_bio->sector,
  					     max_sectors,
  					     &first_bad, &bad_sectors);
  			if (is_bad < 0) {
  				/* mustn't write here until the bad block is
  				 * acknowledged*/
  				set_bit(BlockedBadBlocks, &rdev->flags);
  				blocked_rdev = rdev;
  				break;
  			}
  			if (is_bad && first_bad <= r1_bio->sector) {
  				/* Cannot write here at all */
  				bad_sectors -= (r1_bio->sector - first_bad);
  				if (bad_sectors < max_sectors)
  					/* mustn't write more than bad_sectors
  					 * to other devices yet
  					 */
  					max_sectors = bad_sectors;

  				rdev_dec_pending(rdev, mddev);

  				/* We don't set R1BIO_Degraded as that
  				 * only applies if the disk is
  				 * missing, so it might be re-added,
  				 * and we want to know to recover this
  				 * chunk.
  				 * In this case the device is here,
  				 * and the fact that this chunk is not
  				 * in-sync is recorded in the bad
  				 * block log
  				 */
  				continue;

  			}

  			if (is_bad) {
  				int good_sectors = first_bad - r1_bio->sector;
  				if (good_sectors < max_sectors)
  					max_sectors = good_sectors;
  			}
  		}
  		r1_bio->bios[i] = bio;

  	}
  	rcu_read_unlock();

  	if (unlikely(blocked_rdev)) {
  		/* Wait for this device to become unblocked */
  		int j;
  
  		for (j = 0; j < i; j++)
  			if (r1_bio->bios[j])
  				rdev_dec_pending(conf->mirrors[j].rdev, mddev);

  		r1_bio->state = 0;

  		allow_barrier(conf);
  		md_wait_for_blocked_rdev(blocked_rdev, mddev);
  		wait_barrier(conf);
  		goto retry_write;
  	}

  	if (max_sectors < r1_bio->sectors) {
  		/* We are splitting this write into multiple parts, so
  		 * we need to prepare for allocating another r1_bio.
  		 */
  		r1_bio->sectors = max_sectors;
  		spin_lock_irq(&conf->device_lock);
  		if (bio->bi_phys_segments == 0)
  			bio->bi_phys_segments = 2;
  		else
  			bio->bi_phys_segments++;
  		spin_unlock_irq(&conf->device_lock);

  	}

  	sectors_handled = r1_bio->sector + max_sectors - bio->bi_sector;

  	atomic_set(&r1_bio->remaining, 1);

  	atomic_set(&r1_bio->behind_remaining, 0);

  	first_clone = 1;

  	for (i = 0; i < disks; i++) {
  		struct bio *mbio;
  		if (!r1_bio->bios[i])
  			continue;

  		mbio = bio_clone_mddev(bio, GFP_NOIO, mddev);

  		md_trim_bio(mbio, r1_bio->sector - bio->bi_sector, max_sectors);
  
  		if (first_clone) {
  			/* do behind I/O ?
  			 * Not if there are too many, or cannot
  			 * allocate memory, or a reader on WriteMostly
  			 * is waiting for behind writes to flush */
  			if (bitmap &&
  			    (atomic_read(&bitmap->behind_writes)
  			     < mddev->bitmap_info.max_write_behind) &&
  			    !waitqueue_active(&bitmap->behind_wait))
  				alloc_behind_pages(mbio, r1_bio);
  
  			bitmap_startwrite(bitmap, r1_bio->sector,
  					  r1_bio->sectors,
  					  test_bit(R1BIO_BehindIO,
  						   &r1_bio->state));
  			first_clone = 0;
  		}

  		if (r1_bio->behind_bvecs) {

  			struct bio_vec *bvec;
  			int j;
  
  			/* Yes, I really want the '__' version so that
  			 * we clear any unused pointer in the io_vec, rather
  			 * than leave them unchanged.  This is important
  			 * because when we come to free the pages, we won't

  			 * know the original bi_idx, so we just free

  			 * them all
  			 */
  			__bio_for_each_segment(bvec, mbio, j, 0)

  				bvec->bv_page = r1_bio->behind_bvecs[j].bv_page;

  			if (test_bit(WriteMostly, &conf->mirrors[i].rdev->flags))
  				atomic_inc(&r1_bio->behind_remaining);
  		}

  		r1_bio->bios[i] = mbio;
  
  		mbio->bi_sector	= (r1_bio->sector +
  				   conf->mirrors[i].rdev->data_offset);
  		mbio->bi_bdev = conf->mirrors[i].rdev->bdev;
  		mbio->bi_end_io	= raid1_end_write_request;
  		mbio->bi_rw = WRITE | do_flush_fua | do_sync;
  		mbio->bi_private = r1_bio;

  		atomic_inc(&r1_bio->remaining);

  		spin_lock_irqsave(&conf->device_lock, flags);
  		bio_list_add(&conf->pending_bio_list, mbio);

  		conf->pending_count++;

  		spin_unlock_irqrestore(&conf->device_lock, flags);

  	}

  	/* Mustn't call r1_bio_write_done before this next test,
  	 * as it could result in the bio being freed.
  	 */

  	if (sectors_handled < (bio->bi_size >> 9)) {

  		r1_bio_write_done(r1_bio);

  		/* We need another r1_bio.  It has already been counted
  		 * in bio->bi_phys_segments
  		 */
  		r1_bio = mempool_alloc(conf->r1bio_pool, GFP_NOIO);
  		r1_bio->master_bio = bio;
  		r1_bio->sectors = (bio->bi_size >> 9) - sectors_handled;
  		r1_bio->state = 0;
  		r1_bio->mddev = mddev;
  		r1_bio->sector = bio->bi_sector + sectors_handled;
  		goto retry_write;
  	}

  	r1_bio_write_done(r1_bio);
  
  	/* In case raid1d snuck in to freeze_array */
  	wake_up(&conf->wait_barrier);

  	if (do_sync || !bitmap || !plugged)

  		md_wakeup_thread(mddev->thread);

  }

  static void status(struct seq_file *seq, struct mddev *mddev)

  {

  	struct r1conf *conf = mddev->private;

  	int i;
  
  	seq_printf(seq, " [%d/%d] [", conf->raid_disks,

  		   conf->raid_disks - mddev->degraded);

  	rcu_read_lock();
  	for (i = 0; i < conf->raid_disks; i++) {

  		struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);

  		seq_printf(seq, "%s",

  			   rdev && test_bit(In_sync, &rdev->flags) ? "U" : "_");
  	}
  	rcu_read_unlock();

  	seq_printf(seq, "]");
  }

  static void error(struct mddev *mddev, struct md_rdev *rdev)

  {
  	char b[BDEVNAME_SIZE];

  	struct r1conf *conf = mddev->private;

  
  	/*
  	 * If it is not operational, then we have already marked it as dead
  	 * else if it is the last working disks, ignore the error, let the
  	 * next level up know.
  	 * else mark the drive as failed
  	 */

  	if (test_bit(In_sync, &rdev->flags)

  	    && (conf->raid_disks - mddev->degraded) == 1) {

  		/*
  		 * Don't fail the drive, act as though we were just a

  		 * normal single drive.
  		 * However don't try a recovery from this drive as
  		 * it is very likely to fail.

  		 */

  		conf->recovery_disabled = mddev->recovery_disabled;

  		return;

  	}

  	set_bit(Blocked, &rdev->flags);

  	if (test_and_clear_bit(In_sync, &rdev->flags)) {
  		unsigned long flags;
  		spin_lock_irqsave(&conf->device_lock, flags);

  		mddev->degraded++;

  		set_bit(Faulty, &rdev->flags);

  		spin_unlock_irqrestore(&conf->device_lock, flags);

  		/*
  		 * if recovery is running, make sure it aborts.
  		 */

  		set_bit(MD_RECOVERY_INTR, &mddev->recovery);

  	} else
  		set_bit(Faulty, &rdev->flags);

  	set_bit(MD_CHANGE_DEVS, &mddev->flags);

  	printk(KERN_ALERT
  	       "md/raid1:%s: Disk failure on %s, disabling device.
  "
  	       "md/raid1:%s: Operation continuing on %d devices.
  ",

  	       mdname(mddev), bdevname(rdev->bdev, b),
  	       mdname(mddev), conf->raid_disks - mddev->degraded);

  }

  static void print_conf(struct r1conf *conf)

  {
  	int i;

  	printk(KERN_DEBUG "RAID1 conf printout:
  ");

  	if (!conf) {

  		printk(KERN_DEBUG "(!conf)
  ");

  		return;
  	}

  	printk(KERN_DEBUG " --- wd:%d rd:%d
  ", conf->raid_disks - conf->mddev->degraded,

  		conf->raid_disks);

  	rcu_read_lock();

  	for (i = 0; i < conf->raid_disks; i++) {
  		char b[BDEVNAME_SIZE];

  		struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);

  		if (rdev)

  			printk(KERN_DEBUG " disk %d, wo:%d, o:%d, dev:%s
  ",

  			       i, !test_bit(In_sync, &rdev->flags),
  			       !test_bit(Faulty, &rdev->flags),
  			       bdevname(rdev->bdev,b));

  	}

  	rcu_read_unlock();

  }

  static void close_sync(struct r1conf *conf)

  {

  	wait_barrier(conf);
  	allow_barrier(conf);

  
  	mempool_destroy(conf->r1buf_pool);
  	conf->r1buf_pool = NULL;
  }

  static int raid1_spare_active(struct mddev *mddev)

  {
  	int i;

  	struct r1conf *conf = mddev->private;

  	int count = 0;
  	unsigned long flags;

  
  	/*
  	 * Find all failed disks within the RAID1 configuration 

  	 * and mark them readable.
  	 * Called under mddev lock, so rcu protection not needed.

  	 */
  	for (i = 0; i < conf->raid_disks; i++) {

  		struct md_rdev *rdev = conf->mirrors[i].rdev;

  		struct md_rdev *repl = conf->mirrors[conf->raid_disks + i].rdev;
  		if (repl
  		    && repl->recovery_offset == MaxSector
  		    && !test_bit(Faulty, &repl->flags)
  		    && !test_and_set_bit(In_sync, &repl->flags)) {
  			/* replacement has just become active */
  			if (!rdev ||
  			    !test_and_clear_bit(In_sync, &rdev->flags))
  				count++;
  			if (rdev) {
  				/* Replaced device not technically
  				 * faulty, but we need to be sure
  				 * it gets removed and never re-added
  				 */
  				set_bit(Faulty, &rdev->flags);
  				sysfs_notify_dirent_safe(
  					rdev->sysfs_state);
  			}
  		}

  		if (rdev
  		    && !test_bit(Faulty, &rdev->flags)

  		    && !test_and_set_bit(In_sync, &rdev->flags)) {

  			count++;

  			sysfs_notify_dirent_safe(rdev->sysfs_state);

  		}
  	}

  	spin_lock_irqsave(&conf->device_lock, flags);
  	mddev->degraded -= count;
  	spin_unlock_irqrestore(&conf->device_lock, flags);

  
  	print_conf(conf);

  	return count;

  }

  static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)

  {

  	struct r1conf *conf = mddev->private;

  	int err = -EEXIST;

  	int mirror = 0;

  	struct mirror_info *p;

  	int first = 0;

  	int last = conf->raid_disks - 1;

  	if (mddev->recovery_disabled == conf->recovery_disabled)
  		return -EBUSY;

  	if (rdev->raid_disk >= 0)
  		first = last = rdev->raid_disk;

  	for (mirror = first; mirror <= last; mirror++) {
  		p = conf->mirrors+mirror;
  		if (!p->rdev) {

  			disk_stack_limits(mddev->gendisk, rdev->bdev,
  					  rdev->data_offset << 9);

  			/* as we don't honour merge_bvec_fn, we must
  			 * never risk violating it, so limit
  			 * ->max_segments to one lying with a single
  			 * page, as a one page request is never in
  			 * violation.

  			 */

  			if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
  				blk_queue_max_segments(mddev->queue, 1);
  				blk_queue_segment_boundary(mddev->queue,
  							   PAGE_CACHE_SIZE - 1);
  			}

  
  			p->head_position = 0;
  			rdev->raid_disk = mirror;

  			err = 0;

  			/* As all devices are equivalent, we don't need a full recovery
  			 * if this was recently any drive of the array
  			 */
  			if (rdev->saved_raid_disk < 0)

  				conf->fullsync = 1;

  			rcu_assign_pointer(p->rdev, rdev);

  			break;
  		}

  		if (test_bit(WantReplacement, &p->rdev->flags) &&
  		    p[conf->raid_disks].rdev == NULL) {
  			/* Add this device as a replacement */
  			clear_bit(In_sync, &rdev->flags);
  			set_bit(Replacement, &rdev->flags);
  			rdev->raid_disk = mirror;
  			err = 0;
  			conf->fullsync = 1;
  			rcu_assign_pointer(p[conf->raid_disks].rdev, rdev);
  			break;
  		}
  	}

  	md_integrity_add_rdev(rdev, mddev);

  	print_conf(conf);

  	return err;

  }

  static int raid1_remove_disk(struct mddev *mddev, struct md_rdev *rdev)

  {

  	struct r1conf *conf = mddev->private;

  	int err = 0;

  	int number = rdev->raid_disk;

  	struct mirror_info *p = conf->mirrors+ number;

  	if (rdev != p->rdev)
  		p = conf->mirrors + conf->raid_disks + number;

  	print_conf(conf);

  	if (rdev == p->rdev) {

  		if (test_bit(In_sync, &rdev->flags) ||

  		    atomic_read(&rdev->nr_pending)) {
  			err = -EBUSY;
  			goto abort;
  		}

  		/* Only remove non-faulty devices if recovery

  		 * is not possible.
  		 */
  		if (!test_bit(Faulty, &rdev->flags) &&

  		    mddev->recovery_disabled != conf->recovery_disabled &&

  		    mddev->degraded < conf->raid_disks) {
  			err = -EBUSY;
  			goto abort;
  		}

  		p->rdev = NULL;

  		synchronize_rcu();

  		if (atomic_read(&rdev->nr_pending)) {
  			/* lost the race, try later */
  			err = -EBUSY;
  			p->rdev = rdev;

  			goto abort;

  		} else if (conf->mirrors[conf->raid_disks + number].rdev) {
  			/* We just removed a device that is being replaced.
  			 * Move down the replacement.  We drain all IO before
  			 * doing this to avoid confusion.
  			 */
  			struct md_rdev *repl =
  				conf->mirrors[conf->raid_disks + number].rdev;
  			raise_barrier(conf);
  			clear_bit(Replacement, &repl->flags);
  			p->rdev = repl;
  			conf->mirrors[conf->raid_disks + number].rdev = NULL;
  			lower_barrier(conf);
  			clear_bit(WantReplacement, &rdev->flags);
  		} else

  			clear_bit(WantReplacement, &rdev->flags);

  		err = md_integrity_register(mddev);

  	}
  abort:
  
  	print_conf(conf);
  	return err;
  }

  static void end_sync_read(struct bio *bio, int error)

  {

  	struct r1bio *r1_bio = bio->bi_private;

  	update_head_pos(r1_bio->read_disk, r1_bio);

  	/*
  	 * we have read a block, now it needs to be re-written,
  	 * or re-read if the read failed.
  	 * We don't do much here, just schedule handling by raid1d
  	 */

  	if (test_bit(BIO_UPTODATE, &bio->bi_flags))

  		set_bit(R1BIO_Uptodate, &r1_bio->state);

  
  	if (atomic_dec_and_test(&r1_bio->remaining))
  		reschedule_retry(r1_bio);

  }

  static void end_sync_write(struct bio *bio, int error)

  {
  	int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);

  	struct r1bio *r1_bio = bio->bi_private;

  	struct mddev *mddev = r1_bio->mddev;

  	struct r1conf *conf = mddev->private;

  	int mirror=0;

  	sector_t first_bad;
  	int bad_sectors;

  	mirror = find_bio_disk(r1_bio, bio);

  	if (!uptodate) {

  		sector_t sync_blocks = 0;

  		sector_t s = r1_bio->sector;
  		long sectors_to_go = r1_bio->sectors;
  		/* make sure these bits doesn't get cleared. */
  		do {

  			bitmap_end_sync(mddev->bitmap, s,

  					&sync_blocks, 1);
  			s += sync_blocks;
  			sectors_to_go -= sync_blocks;
  		} while (sectors_to_go > 0);

  		set_bit(WriteErrorSeen,
  			&conf->mirrors[mirror].rdev->flags);

  		if (!test_and_set_bit(WantReplacement,
  				      &conf->mirrors[mirror].rdev->flags))
  			set_bit(MD_RECOVERY_NEEDED, &
  				mddev->recovery);

  		set_bit(R1BIO_WriteError, &r1_bio->state);

  	} else if (is_badblock(conf->mirrors[mirror].rdev,
  			       r1_bio->sector,
  			       r1_bio->sectors,

  			       &first_bad, &bad_sectors) &&
  		   !is_badblock(conf->mirrors[r1_bio->read_disk].rdev,
  				r1_bio->sector,
  				r1_bio->sectors,
  				&first_bad, &bad_sectors)
  		)

  		set_bit(R1BIO_MadeGood, &r1_bio->state);

  	if (atomic_dec_and_test(&r1_bio->remaining)) {

  		int s = r1_bio->sectors;

  		if (test_bit(R1BIO_MadeGood, &r1_bio->state) ||
  		    test_bit(R1BIO_WriteError, &r1_bio->state))

  			reschedule_retry(r1_bio);
  		else {
  			put_buf(r1_bio);
  			md_done_sync(mddev, s, uptodate);
  		}

  	}

  }

  static int r1_sync_page_io(struct md_rdev *rdev, sector_t sector,

  			    int sectors, struct page *page, int rw)
  {
  	if (sync_page_io(rdev, sector, sectors << 9, page, rw, false))
  		/* success */
  		return 1;

  	if (rw == WRITE) {

  		set_bit(WriteErrorSeen, &rdev->flags);

  		if (!test_and_set_bit(WantReplacement,
  				      &rdev->flags))
  			set_bit(MD_RECOVERY_NEEDED, &
  				rdev->mddev->recovery);
  	}

  	/* need to record an error - either for the block or the device */
  	if (!rdev_set_badblocks(rdev, sector, sectors, 0))
  		md_error(rdev->mddev, rdev);
  	return 0;
  }

  static int fix_sync_read_error(struct r1bio *r1_bio)

  {

  	/* Try some synchronous reads of other devices to get
  	 * good data, much like with normal read errors.  Only
  	 * read into the pages we already have so we don't
  	 * need to re-issue the read request.
  	 * We don't need to freeze the array, because being in an
  	 * active sync request, there is no normal IO, and
  	 * no overlapping syncs.

  	 * We don't need to check is_badblock() again as we
  	 * made sure that anything with a bad block in range
  	 * will have bi_end_io clear.

  	 */

  	struct mddev *mddev = r1_bio->mddev;

  	struct r1conf *conf = mddev->private;

  	struct bio *bio = r1_bio->bios[r1_bio->read_disk];
  	sector_t sect = r1_bio->sector;
  	int sectors = r1_bio->sectors;
  	int idx = 0;
  
  	while(sectors) {
  		int s = sectors;
  		int d = r1_bio->read_disk;
  		int success = 0;

  		struct md_rdev *rdev;

  		int start;

  
  		if (s > (PAGE_SIZE>>9))
  			s = PAGE_SIZE >> 9;
  		do {
  			if (r1_bio->bios[d]->bi_end_io == end_sync_read) {
  				/* No rcu protection needed here devices
  				 * can only be removed when no resync is
  				 * active, and resync is currently active
  				 */
  				rdev = conf->mirrors[d].rdev;

  				if (sync_page_io(rdev, sect, s<<9,

  						 bio->bi_io_vec[idx].bv_page,
  						 READ, false)) {
  					success = 1;
  					break;
  				}
  			}
  			d++;

  			if (d == conf->raid_disks * 2)

  				d = 0;
  		} while (!success && d != r1_bio->read_disk);

  		if (!success) {

  			char b[BDEVNAME_SIZE];

  			int abort = 0;
  			/* Cannot read from anywhere, this block is lost.
  			 * Record a bad block on each device.  If that doesn't
  			 * work just disable and interrupt the recovery.
  			 * Don't fail devices as that won't really help.
  			 */

  			printk(KERN_ALERT "md/raid1:%s: %s: unrecoverable I/O read error"
  			       " for block %llu
  ",
  			       mdname(mddev),
  			       bdevname(bio->bi_bdev, b),
  			       (unsigned long long)r1_bio->sector);

  			for (d = 0; d < conf->raid_disks * 2; d++) {

  				rdev = conf->mirrors[d].rdev;
  				if (!rdev || test_bit(Faulty, &rdev->flags))
  					continue;
  				if (!rdev_set_badblocks(rdev, sect, s, 0))
  					abort = 1;
  			}
  			if (abort) {

  				conf->recovery_disabled =
  					mddev->recovery_disabled;

  				set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  				md_done_sync(mddev, r1_bio->sectors, 0);
  				put_buf(r1_bio);
  				return 0;
  			}
  			/* Try next page */
  			sectors -= s;
  			sect += s;
  			idx++;
  			continue;

  		}

  
  		start = d;
  		/* write it back and re-read */
  		while (d != r1_bio->read_disk) {
  			if (d == 0)

  				d = conf->raid_disks * 2;

  			d--;
  			if (r1_bio->bios[d]->bi_end_io != end_sync_read)
  				continue;
  			rdev = conf->mirrors[d].rdev;

  			if (r1_sync_page_io(rdev, sect, s,
  					    bio->bi_io_vec[idx].bv_page,
  					    WRITE) == 0) {

  				r1_bio->bios[d]->bi_end_io = NULL;
  				rdev_dec_pending(rdev, mddev);

  			}

  		}
  		d = start;
  		while (d != r1_bio->read_disk) {
  			if (d == 0)

  				d = conf->raid_disks * 2;

  			d--;
  			if (r1_bio->bios[d]->bi_end_io != end_sync_read)
  				continue;
  			rdev = conf->mirrors[d].rdev;

  			if (r1_sync_page_io(rdev, sect, s,
  					    bio->bi_io_vec[idx].bv_page,
  					    READ) != 0)

  				atomic_add(s, &rdev->corrected_errors);

  		}

  		sectors -= s;
  		sect += s;
  		idx ++;
  	}

  	set_bit(R1BIO_Uptodate, &r1_bio->state);

  	set_bit(BIO_UPTODATE, &bio->bi_flags);

  	return 1;
  }

  static int process_checks(struct r1bio *r1_bio)

  {
  	/* We have read all readable devices.  If we haven't
  	 * got the block, then there is no hope left.
  	 * If we have, then we want to do a comparison
  	 * and skip the write if everything is the same.
  	 * If any blocks failed to read, then we need to
  	 * attempt an over-write
  	 */

  	struct mddev *mddev = r1_bio->mddev;

  	struct r1conf *conf = mddev->private;

  	int primary;
  	int i;

  	for (primary = 0; primary < conf->raid_disks * 2; primary++)

  		if (r1_bio->bios[primary]->bi_end_io == end_sync_read &&
  		    test_bit(BIO_UPTODATE, &r1_bio->bios[primary]->bi_flags)) {
  			r1_bio->bios[primary]->bi_end_io = NULL;
  			rdev_dec_pending(conf->mirrors[primary].rdev, mddev);
  			break;
  		}
  	r1_bio->read_disk = primary;

  	for (i = 0; i < conf->raid_disks * 2; i++) {

  		int j;
  		int vcnt = r1_bio->sectors >> (PAGE_SHIFT- 9);
  		struct bio *pbio = r1_bio->bios[primary];
  		struct bio *sbio = r1_bio->bios[i];
  		int size;

  		if (r1_bio->bios[i]->bi_end_io != end_sync_read)
  			continue;
  
  		if (test_bit(BIO_UPTODATE, &sbio->bi_flags)) {
  			for (j = vcnt; j-- ; ) {
  				struct page *p, *s;
  				p = pbio->bi_io_vec[j].bv_page;
  				s = sbio->bi_io_vec[j].bv_page;
  				if (memcmp(page_address(p),
  					   page_address(s),
  					   PAGE_SIZE))
  					break;

  			}

  		} else
  			j = 0;
  		if (j >= 0)
  			mddev->resync_mismatches += r1_bio->sectors;
  		if (j < 0 || (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)
  			      && test_bit(BIO_UPTODATE, &sbio->bi_flags))) {
  			/* No need to write to this device. */
  			sbio->bi_end_io = NULL;
  			rdev_dec_pending(conf->mirrors[i].rdev, mddev);
  			continue;
  		}
  		/* fixup the bio for reuse */
  		sbio->bi_vcnt = vcnt;
  		sbio->bi_size = r1_bio->sectors << 9;
  		sbio->bi_idx = 0;
  		sbio->bi_phys_segments = 0;
  		sbio->bi_flags &= ~(BIO_POOL_MASK - 1);
  		sbio->bi_flags |= 1 << BIO_UPTODATE;
  		sbio->bi_next = NULL;
  		sbio->bi_sector = r1_bio->sector +
  			conf->mirrors[i].rdev->data_offset;
  		sbio->bi_bdev = conf->mirrors[i].rdev->bdev;
  		size = sbio->bi_size;
  		for (j = 0; j < vcnt ; j++) {
  			struct bio_vec *bi;
  			bi = &sbio->bi_io_vec[j];
  			bi->bv_offset = 0;
  			if (size > PAGE_SIZE)
  				bi->bv_len = PAGE_SIZE;
  			else
  				bi->bv_len = size;
  			size -= PAGE_SIZE;
  			memcpy(page_address(bi->bv_page),
  			       page_address(pbio->bi_io_vec[j].bv_page),
  			       PAGE_SIZE);

  		}

  	}

  	return 0;
  }

  static void sync_request_write(struct mddev *mddev, struct r1bio *r1_bio)

  {

  	struct r1conf *conf = mddev->private;

  	int i;

  	int disks = conf->raid_disks * 2;

  	struct bio *bio, *wbio;
  
  	bio = r1_bio->bios[r1_bio->read_disk];

  	if (!test_bit(R1BIO_Uptodate, &r1_bio->state))
  		/* ouch - failed to read all of that. */
  		if (!fix_sync_read_error(r1_bio))
  			return;

  
  	if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
  		if (process_checks(r1_bio) < 0)
  			return;

  	/*
  	 * schedule writes
  	 */

  	atomic_set(&r1_bio->remaining, 1);
  	for (i = 0; i < disks ; i++) {
  		wbio = r1_bio->bios[i];

  		if (wbio->bi_end_io == NULL ||
  		    (wbio->bi_end_io == end_sync_read &&
  		     (i == r1_bio->read_disk ||
  		      !test_bit(MD_RECOVERY_SYNC, &mddev->recovery))))

  			continue;

  		wbio->bi_rw = WRITE;
  		wbio->bi_end_io = end_sync_write;

  		atomic_inc(&r1_bio->remaining);
  		md_sync_acct(conf->mirrors[i].rdev->bdev, wbio->bi_size >> 9);

  		generic_make_request(wbio);
  	}
  
  	if (atomic_dec_and_test(&r1_bio->remaining)) {

  		/* if we're here, all write(s) have completed, so clean up */

  		md_done_sync(mddev, r1_bio->sectors, 1);
  		put_buf(r1_bio);
  	}
  }
  
  /*
   * This is a kernel thread which:
   *
   *	1.	Retries failed read operations on working mirrors.
   *	2.	Updates the raid superblock when problems encounter.

   *	3.	Performs writes following reads for array synchronising.

   */

  static void fix_read_error(struct r1conf *conf, int read_disk,

  			   sector_t sect, int sectors)
  {

  	struct mddev *mddev = conf->mddev;

  	while(sectors) {
  		int s = sectors;
  		int d = read_disk;
  		int success = 0;
  		int start;

  		struct md_rdev *rdev;

  
  		if (s > (PAGE_SIZE>>9))
  			s = PAGE_SIZE >> 9;
  
  		do {
  			/* Note: no rcu protection needed here
  			 * as this is synchronous in the raid1d thread
  			 * which is the thread that might remove
  			 * a device.  If raid1d ever becomes multi-threaded....
  			 */

  			sector_t first_bad;
  			int bad_sectors;

  			rdev = conf->mirrors[d].rdev;
  			if (rdev &&
  			    test_bit(In_sync, &rdev->flags) &&

  			    is_badblock(rdev, sect, s,
  					&first_bad, &bad_sectors) == 0 &&

  			    sync_page_io(rdev, sect, s<<9,
  					 conf->tmppage, READ, false))