/*
     md.c : Multiple Devices driver for Linux
  	  Copyright (C) 1998, 1999, 2000 Ingo Molnar
  
       completely rewritten, based on the MD driver code from Marc Zyngier
  
     Changes:
  
     - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
     - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
     - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
     - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
     - kmod support by: Cyrus Durgin
     - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
     - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
  
     - lots of fixes and improvements to the RAID1/RAID5 and generic
       RAID code (such as request based resynchronization):
  
       Neil Brown <neilb@cse.unsw.edu.au>.

     - persistent bitmap code
       Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.

     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/kthread.h>

  #include <linux/blkdev.h>

  #include <linux/sysctl.h>

  #include <linux/seq_file.h>

  #include <linux/mutex.h>

  #include <linux/buffer_head.h> /* for invalidate_bdev */

  #include <linux/poll.h>

  #include <linux/ctype.h>

  #include <linux/string.h>

  #include <linux/hdreg.h>
  #include <linux/proc_fs.h>
  #include <linux/random.h>

  #include <linux/module.h>

  #include <linux/reboot.h>

  #include <linux/file.h>

  #include <linux/compat.h>

  #include <linux/delay.h>

  #include <linux/raid/md_p.h>
  #include <linux/raid/md_u.h>

  #include <linux/slab.h>

  #include "md.h"

  #include "bitmap.h"

  #ifndef MODULE

  static void autostart_arrays(int part);

  #endif

  /* pers_list is a list of registered personalities protected
   * by pers_lock.
   * pers_lock does extra service to protect accesses to
   * mddev->thread when the mutex cannot be held.
   */

  static LIST_HEAD(pers_list);

  static DEFINE_SPINLOCK(pers_lock);

  static void md_print_devices(void);

  static DECLARE_WAIT_QUEUE_HEAD(resync_wait);

  static struct workqueue_struct *md_wq;
  static struct workqueue_struct *md_misc_wq;

  #define MD_BUG(x...) { printk("md: bug in file %s, line %d
  ", __FILE__, __LINE__); md_print_devices(); }

  /*

   * Default number of read corrections we'll attempt on an rdev
   * before ejecting it from the array. We divide the read error
   * count by 2 for every hour elapsed between read errors.
   */
  #define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
  /*

   * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
   * is 1000 KB/sec, so the extra system load does not show up that much.
   * Increase it if you want to have more _guaranteed_ speed. Note that

   * the RAID driver will use the maximum available bandwidth if the IO

   * subsystem is idle. There is also an 'absolute maximum' reconstruction
   * speed limit - in case reconstruction slows down your system despite
   * idle IO detection.
   *
   * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.

   * or /sys/block/mdX/md/sync_speed_{min,max}

   */
  
  static int sysctl_speed_limit_min = 1000;
  static int sysctl_speed_limit_max = 200000;

  static inline int speed_min(struct mddev *mddev)

  {
  	return mddev->sync_speed_min ?
  		mddev->sync_speed_min : sysctl_speed_limit_min;
  }

  static inline int speed_max(struct mddev *mddev)

  {
  	return mddev->sync_speed_max ?
  		mddev->sync_speed_max : sysctl_speed_limit_max;
  }

  
  static struct ctl_table_header *raid_table_header;
  
  static ctl_table raid_table[] = {
  	{

  		.procname	= "speed_limit_min",
  		.data		= &sysctl_speed_limit_min,
  		.maxlen		= sizeof(int),

  		.mode		= S_IRUGO|S_IWUSR,

  		.proc_handler	= proc_dointvec,

  	},
  	{

  		.procname	= "speed_limit_max",
  		.data		= &sysctl_speed_limit_max,
  		.maxlen		= sizeof(int),

  		.mode		= S_IRUGO|S_IWUSR,

  		.proc_handler	= proc_dointvec,

  	},

  	{ }

  };
  
  static ctl_table raid_dir_table[] = {
  	{

  		.procname	= "raid",
  		.maxlen		= 0,

  		.mode		= S_IRUGO|S_IXUGO,

  		.child		= raid_table,
  	},

  	{ }

  };
  
  static ctl_table raid_root_table[] = {
  	{

  		.procname	= "dev",
  		.maxlen		= 0,
  		.mode		= 0555,
  		.child		= raid_dir_table,
  	},

  	{  }

  };

  static const struct block_device_operations md_fops;

  static int start_readonly;

  /* bio_clone_mddev
   * like bio_clone, but with a local bio set
   */
  
  static void mddev_bio_destructor(struct bio *bio)
  {

  	struct mddev *mddev, **mddevp;

  
  	mddevp = (void*)bio;
  	mddev = mddevp[-1];
  
  	bio_free(bio, mddev->bio_set);
  }
  
  struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,

  			    struct mddev *mddev)

  {
  	struct bio *b;

  	struct mddev **mddevp;

  
  	if (!mddev || !mddev->bio_set)
  		return bio_alloc(gfp_mask, nr_iovecs);
  
  	b = bio_alloc_bioset(gfp_mask, nr_iovecs,
  			     mddev->bio_set);
  	if (!b)
  		return NULL;
  	mddevp = (void*)b;
  	mddevp[-1] = mddev;
  	b->bi_destructor = mddev_bio_destructor;
  	return b;
  }
  EXPORT_SYMBOL_GPL(bio_alloc_mddev);
  
  struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,

  			    struct mddev *mddev)

  {
  	struct bio *b;

  	struct mddev **mddevp;

  
  	if (!mddev || !mddev->bio_set)
  		return bio_clone(bio, gfp_mask);
  
  	b = bio_alloc_bioset(gfp_mask, bio->bi_max_vecs,
  			     mddev->bio_set);
  	if (!b)
  		return NULL;
  	mddevp = (void*)b;
  	mddevp[-1] = mddev;
  	b->bi_destructor = mddev_bio_destructor;
  	__bio_clone(b, bio);
  	if (bio_integrity(bio)) {
  		int ret;
  
  		ret = bio_integrity_clone(b, bio, gfp_mask, mddev->bio_set);
  
  		if (ret < 0) {
  			bio_put(b);
  			return NULL;
  		}
  	}
  
  	return b;
  }
  EXPORT_SYMBOL_GPL(bio_clone_mddev);

  void md_trim_bio(struct bio *bio, int offset, int size)
  {
  	/* 'bio' is a cloned bio which we need to trim to match
  	 * the given offset and size.
  	 * This requires adjusting bi_sector, bi_size, and bi_io_vec
  	 */
  	int i;
  	struct bio_vec *bvec;
  	int sofar = 0;
  
  	size <<= 9;
  	if (offset == 0 && size == bio->bi_size)
  		return;
  
  	bio->bi_sector += offset;
  	bio->bi_size = size;
  	offset <<= 9;
  	clear_bit(BIO_SEG_VALID, &bio->bi_flags);
  
  	while (bio->bi_idx < bio->bi_vcnt &&
  	       bio->bi_io_vec[bio->bi_idx].bv_len <= offset) {
  		/* remove this whole bio_vec */
  		offset -= bio->bi_io_vec[bio->bi_idx].bv_len;
  		bio->bi_idx++;
  	}
  	if (bio->bi_idx < bio->bi_vcnt) {
  		bio->bi_io_vec[bio->bi_idx].bv_offset += offset;
  		bio->bi_io_vec[bio->bi_idx].bv_len -= offset;
  	}
  	/* avoid any complications with bi_idx being non-zero*/
  	if (bio->bi_idx) {
  		memmove(bio->bi_io_vec, bio->bi_io_vec+bio->bi_idx,
  			(bio->bi_vcnt - bio->bi_idx) * sizeof(struct bio_vec));
  		bio->bi_vcnt -= bio->bi_idx;
  		bio->bi_idx = 0;
  	}
  	/* Make sure vcnt and last bv are not too big */
  	bio_for_each_segment(bvec, bio, i) {
  		if (sofar + bvec->bv_len > size)
  			bvec->bv_len = size - sofar;
  		if (bvec->bv_len == 0) {
  			bio->bi_vcnt = i;
  			break;
  		}
  		sofar += bvec->bv_len;
  	}
  }
  EXPORT_SYMBOL_GPL(md_trim_bio);

  /*

   * We have a system wide 'event count' that is incremented
   * on any 'interesting' event, and readers of /proc/mdstat
   * can use 'poll' or 'select' to find out when the event
   * count increases.
   *
   * Events are:
   *  start array, stop array, error, add device, remove device,
   *  start build, activate spare
   */

  static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);

  static atomic_t md_event_count;

  void md_new_event(struct mddev *mddev)

  {
  	atomic_inc(&md_event_count);
  	wake_up(&md_event_waiters);
  }

  EXPORT_SYMBOL_GPL(md_new_event);

  /* Alternate version that can be called from interrupts
   * when calling sysfs_notify isn't needed.
   */

  static void md_new_event_inintr(struct mddev *mddev)

  {
  	atomic_inc(&md_event_count);
  	wake_up(&md_event_waiters);
  }

  /*

   * Enables to iterate over all existing md arrays
   * all_mddevs_lock protects this list.
   */
  static LIST_HEAD(all_mddevs);
  static DEFINE_SPINLOCK(all_mddevs_lock);
  
  
  /*
   * iterates through all used mddevs in the system.
   * We take care to grab the all_mddevs_lock whenever navigating
   * the list, and to always hold a refcount when unlocked.
   * Any code which breaks out of this loop while own
   * a reference to the current mddev and must mddev_put it.
   */

  #define for_each_mddev(_mddev,_tmp)					\

  									\
  	for (({ spin_lock(&all_mddevs_lock); 				\

  		_tmp = all_mddevs.next;					\
  		_mddev = NULL;});					\
  	     ({ if (_tmp != &all_mddevs)				\
  			mddev_get(list_entry(_tmp, struct mddev, all_mddevs));\

  		spin_unlock(&all_mddevs_lock);				\

  		if (_mddev) mddev_put(_mddev);				\
  		_mddev = list_entry(_tmp, struct mddev, all_mddevs);	\
  		_tmp != &all_mddevs;});					\

  	     ({ spin_lock(&all_mddevs_lock);				\

  		_tmp = _tmp->next;})					\

  		)

  /* Rather than calling directly into the personality make_request function,
   * IO requests come here first so that we can check if the device is
   * being suspended pending a reconfiguration.
   * We hold a refcount over the call to ->make_request.  By the time that
   * call has finished, the bio has been linked into some internal structure
   * and so is visible to ->quiesce(), so we don't need the refcount any more.
   */

  static void md_make_request(struct request_queue *q, struct bio *bio)

  {

  	const int rw = bio_data_dir(bio);

  	struct mddev *mddev = q->queuedata;

  	int cpu;

  	unsigned int sectors;

  	if (mddev == NULL || mddev->pers == NULL
  	    || !mddev->ready) {

  		bio_io_error(bio);

  		return;

  	}

  	smp_rmb(); /* Ensure implications of  'active' are visible */

  	rcu_read_lock();

  	if (mddev->suspended) {

  		DEFINE_WAIT(__wait);
  		for (;;) {
  			prepare_to_wait(&mddev->sb_wait, &__wait,
  					TASK_UNINTERRUPTIBLE);

  			if (!mddev->suspended)

  				break;
  			rcu_read_unlock();
  			schedule();
  			rcu_read_lock();
  		}
  		finish_wait(&mddev->sb_wait, &__wait);
  	}
  	atomic_inc(&mddev->active_io);
  	rcu_read_unlock();

  	/*
  	 * save the sectors now since our bio can
  	 * go away inside make_request
  	 */
  	sectors = bio_sectors(bio);

  	mddev->pers->make_request(mddev, bio);

  
  	cpu = part_stat_lock();
  	part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);

  	part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors);

  	part_stat_unlock();

  	if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
  		wake_up(&mddev->sb_wait);

  }

  /* mddev_suspend makes sure no new requests are submitted
   * to the device, and that any requests that have been submitted
   * are completely handled.
   * Once ->stop is called and completes, the module will be completely
   * unused.
   */

  void mddev_suspend(struct mddev *mddev)

  {
  	BUG_ON(mddev->suspended);
  	mddev->suspended = 1;
  	synchronize_rcu();
  	wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
  	mddev->pers->quiesce(mddev, 1);

  }

  EXPORT_SYMBOL_GPL(mddev_suspend);

  void mddev_resume(struct mddev *mddev)

  {
  	mddev->suspended = 0;
  	wake_up(&mddev->sb_wait);
  	mddev->pers->quiesce(mddev, 0);

  
  	md_wakeup_thread(mddev->thread);
  	md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */

  }

  EXPORT_SYMBOL_GPL(mddev_resume);

  int mddev_congested(struct mddev *mddev, int bits)

  {
  	return mddev->suspended;
  }
  EXPORT_SYMBOL(mddev_congested);

  /*

   * Generic flush handling for md

   */

  static void md_end_flush(struct bio *bio, int err)

  {

  	struct md_rdev *rdev = bio->bi_private;

  	struct mddev *mddev = rdev->mddev;

  
  	rdev_dec_pending(rdev, mddev);
  
  	if (atomic_dec_and_test(&mddev->flush_pending)) {

  		/* The pre-request flush has finished */

  		queue_work(md_wq, &mddev->flush_work);

  	}
  	bio_put(bio);
  }

  static void md_submit_flush_data(struct work_struct *ws);

  static void submit_flushes(struct work_struct *ws)

  {

  	struct mddev *mddev = container_of(ws, struct mddev, flush_work);

  	struct md_rdev *rdev;

  	INIT_WORK(&mddev->flush_work, md_submit_flush_data);
  	atomic_set(&mddev->flush_pending, 1);

  	rcu_read_lock();
  	list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
  		if (rdev->raid_disk >= 0 &&
  		    !test_bit(Faulty, &rdev->flags)) {
  			/* Take two references, one is dropped
  			 * when request finishes, one after
  			 * we reclaim rcu_read_lock
  			 */
  			struct bio *bi;
  			atomic_inc(&rdev->nr_pending);
  			atomic_inc(&rdev->nr_pending);
  			rcu_read_unlock();

  			bi = bio_alloc_mddev(GFP_KERNEL, 0, mddev);

  			bi->bi_end_io = md_end_flush;

  			bi->bi_private = rdev;
  			bi->bi_bdev = rdev->bdev;
  			atomic_inc(&mddev->flush_pending);

  			submit_bio(WRITE_FLUSH, bi);

  			rcu_read_lock();
  			rdev_dec_pending(rdev, mddev);
  		}
  	rcu_read_unlock();

  	if (atomic_dec_and_test(&mddev->flush_pending))
  		queue_work(md_wq, &mddev->flush_work);

  }

  static void md_submit_flush_data(struct work_struct *ws)

  {

  	struct mddev *mddev = container_of(ws, struct mddev, flush_work);

  	struct bio *bio = mddev->flush_bio;

  	if (bio->bi_size == 0)

  		/* an empty barrier - all done */
  		bio_endio(bio, 0);
  	else {

  		bio->bi_rw &= ~REQ_FLUSH;

  		mddev->pers->make_request(mddev, bio);

  	}

  
  	mddev->flush_bio = NULL;
  	wake_up(&mddev->sb_wait);

  }

  void md_flush_request(struct mddev *mddev, struct bio *bio)

  {
  	spin_lock_irq(&mddev->write_lock);
  	wait_event_lock_irq(mddev->sb_wait,

  			    !mddev->flush_bio,

  			    mddev->write_lock, /*nothing*/);

  	mddev->flush_bio = bio;

  	spin_unlock_irq(&mddev->write_lock);

  	INIT_WORK(&mddev->flush_work, submit_flushes);
  	queue_work(md_wq, &mddev->flush_work);

  }

  EXPORT_SYMBOL(md_flush_request);

  /* Support for plugging.
   * This mirrors the plugging support in request_queue, but does not
   * require having a whole queue or request structures.
   * We allocate an md_plug_cb for each md device and each thread it gets
   * plugged on.  This links tot the private plug_handle structure in the
   * personality data where we keep a count of the number of outstanding
   * plugs so other code can see if a plug is active.
   */
  struct md_plug_cb {
  	struct blk_plug_cb cb;

  	struct mddev *mddev;

  };
  
  static void plugger_unplug(struct blk_plug_cb *cb)
  {
  	struct md_plug_cb *mdcb = container_of(cb, struct md_plug_cb, cb);
  	if (atomic_dec_and_test(&mdcb->mddev->plug_cnt))
  		md_wakeup_thread(mdcb->mddev->thread);
  	kfree(mdcb);
  }
  
  /* Check that an unplug wakeup will come shortly.
   * If not, wakeup the md thread immediately
   */

  int mddev_check_plugged(struct mddev *mddev)

  {
  	struct blk_plug *plug = current->plug;
  	struct md_plug_cb *mdcb;
  
  	if (!plug)
  		return 0;
  
  	list_for_each_entry(mdcb, &plug->cb_list, cb.list) {
  		if (mdcb->cb.callback == plugger_unplug &&
  		    mdcb->mddev == mddev) {
  			/* Already on the list, move to top */
  			if (mdcb != list_first_entry(&plug->cb_list,
  						    struct md_plug_cb,
  						    cb.list))
  				list_move(&mdcb->cb.list, &plug->cb_list);
  			return 1;
  		}
  	}
  	/* Not currently on the callback list */
  	mdcb = kmalloc(sizeof(*mdcb), GFP_ATOMIC);
  	if (!mdcb)
  		return 0;
  
  	mdcb->mddev = mddev;
  	mdcb->cb.callback = plugger_unplug;
  	atomic_inc(&mddev->plug_cnt);
  	list_add(&mdcb->cb.list, &plug->cb_list);
  	return 1;
  }
  EXPORT_SYMBOL_GPL(mddev_check_plugged);

  static inline struct mddev *mddev_get(struct mddev *mddev)

  {
  	atomic_inc(&mddev->active);
  	return mddev;
  }

  static void mddev_delayed_delete(struct work_struct *ws);

  static void mddev_put(struct mddev *mddev)

  {

  	struct bio_set *bs = NULL;

  	if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
  		return;

  	if (!mddev->raid_disks && list_empty(&mddev->disks) &&

  	    mddev->ctime == 0 && !mddev->hold_active) {
  		/* Array is not configured at all, and not held active,
  		 * so destroy it */

  		list_del_init(&mddev->all_mddevs);

  		bs = mddev->bio_set;
  		mddev->bio_set = NULL;

  		if (mddev->gendisk) {

  			/* We did a probe so need to clean up.  Call
  			 * queue_work inside the spinlock so that
  			 * flush_workqueue() after mddev_find will
  			 * succeed in waiting for the work to be done.

  			 */
  			INIT_WORK(&mddev->del_work, mddev_delayed_delete);

  			queue_work(md_misc_wq, &mddev->del_work);

  		} else
  			kfree(mddev);
  	}
  	spin_unlock(&all_mddevs_lock);

  	if (bs)
  		bioset_free(bs);

  }

  void mddev_init(struct mddev *mddev)

  {
  	mutex_init(&mddev->open_mutex);
  	mutex_init(&mddev->reconfig_mutex);
  	mutex_init(&mddev->bitmap_info.mutex);
  	INIT_LIST_HEAD(&mddev->disks);
  	INIT_LIST_HEAD(&mddev->all_mddevs);
  	init_timer(&mddev->safemode_timer);
  	atomic_set(&mddev->active, 1);
  	atomic_set(&mddev->openers, 0);
  	atomic_set(&mddev->active_io, 0);

  	atomic_set(&mddev->plug_cnt, 0);

  	spin_lock_init(&mddev->write_lock);
  	atomic_set(&mddev->flush_pending, 0);
  	init_waitqueue_head(&mddev->sb_wait);
  	init_waitqueue_head(&mddev->recovery_wait);
  	mddev->reshape_position = MaxSector;
  	mddev->resync_min = 0;
  	mddev->resync_max = MaxSector;
  	mddev->level = LEVEL_NONE;
  }

  EXPORT_SYMBOL_GPL(mddev_init);

  static struct mddev * mddev_find(dev_t unit)

  {

  	struct mddev *mddev, *new = NULL;

  	if (unit && MAJOR(unit) != MD_MAJOR)
  		unit &= ~((1<<MdpMinorShift)-1);

   retry:
  	spin_lock(&all_mddevs_lock);

  
  	if (unit) {
  		list_for_each_entry(mddev, &all_mddevs, all_mddevs)
  			if (mddev->unit == unit) {
  				mddev_get(mddev);
  				spin_unlock(&all_mddevs_lock);
  				kfree(new);
  				return mddev;
  			}
  
  		if (new) {
  			list_add(&new->all_mddevs, &all_mddevs);

  			spin_unlock(&all_mddevs_lock);

  			new->hold_active = UNTIL_IOCTL;
  			return new;

  		}

  	} else if (new) {
  		/* find an unused unit number */
  		static int next_minor = 512;
  		int start = next_minor;
  		int is_free = 0;
  		int dev = 0;
  		while (!is_free) {
  			dev = MKDEV(MD_MAJOR, next_minor);
  			next_minor++;
  			if (next_minor > MINORMASK)
  				next_minor = 0;
  			if (next_minor == start) {
  				/* Oh dear, all in use. */
  				spin_unlock(&all_mddevs_lock);
  				kfree(new);
  				return NULL;
  			}
  				
  			is_free = 1;
  			list_for_each_entry(mddev, &all_mddevs, all_mddevs)
  				if (mddev->unit == dev) {
  					is_free = 0;
  					break;
  				}
  		}
  		new->unit = dev;
  		new->md_minor = MINOR(dev);
  		new->hold_active = UNTIL_STOP;

  		list_add(&new->all_mddevs, &all_mddevs);
  		spin_unlock(&all_mddevs_lock);
  		return new;
  	}
  	spin_unlock(&all_mddevs_lock);

  	new = kzalloc(sizeof(*new), GFP_KERNEL);

  	if (!new)
  		return NULL;

  	new->unit = unit;
  	if (MAJOR(unit) == MD_MAJOR)
  		new->md_minor = MINOR(unit);
  	else
  		new->md_minor = MINOR(unit) >> MdpMinorShift;

  	mddev_init(new);

  	goto retry;
  }

  static inline int mddev_lock(struct mddev * mddev)

  {

  	return mutex_lock_interruptible(&mddev->reconfig_mutex);

  }

  static inline int mddev_is_locked(struct mddev *mddev)

  {
  	return mutex_is_locked(&mddev->reconfig_mutex);
  }

  static inline int mddev_trylock(struct mddev * mddev)

  {

  	return mutex_trylock(&mddev->reconfig_mutex);

  }

  static struct attribute_group md_redundancy_group;

  static void mddev_unlock(struct mddev * mddev)

  {

  	if (mddev->to_remove) {

  		/* These cannot be removed under reconfig_mutex as
  		 * an access to the files will try to take reconfig_mutex
  		 * while holding the file unremovable, which leads to
  		 * a deadlock.

  		 * So hold set sysfs_active while the remove in happeing,
  		 * and anything else which might set ->to_remove or my
  		 * otherwise change the sysfs namespace will fail with
  		 * -EBUSY if sysfs_active is still set.
  		 * We set sysfs_active under reconfig_mutex and elsewhere
  		 * test it under the same mutex to ensure its correct value
  		 * is seen.

  		 */

  		struct attribute_group *to_remove = mddev->to_remove;
  		mddev->to_remove = NULL;

  		mddev->sysfs_active = 1;

  		mutex_unlock(&mddev->reconfig_mutex);

  		if (mddev->kobj.sd) {
  			if (to_remove != &md_redundancy_group)
  				sysfs_remove_group(&mddev->kobj, to_remove);
  			if (mddev->pers == NULL ||
  			    mddev->pers->sync_request == NULL) {
  				sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
  				if (mddev->sysfs_action)
  					sysfs_put(mddev->sysfs_action);
  				mddev->sysfs_action = NULL;
  			}

  		}

  		mddev->sysfs_active = 0;

  	} else
  		mutex_unlock(&mddev->reconfig_mutex);

  	/* As we've dropped the mutex we need a spinlock to
  	 * make sure the thread doesn't disappear

  	 */
  	spin_lock(&pers_lock);

  	md_wakeup_thread(mddev->thread);

  	spin_unlock(&pers_lock);

  }

  static struct md_rdev * find_rdev_nr(struct mddev *mddev, int nr)

  {

  	struct md_rdev *rdev;

  	list_for_each_entry(rdev, &mddev->disks, same_set)

  		if (rdev->desc_nr == nr)
  			return rdev;

  	return NULL;
  }

  static struct md_rdev * find_rdev(struct mddev * mddev, dev_t dev)

  {

  	struct md_rdev *rdev;

  	list_for_each_entry(rdev, &mddev->disks, same_set)

  		if (rdev->bdev->bd_dev == dev)
  			return rdev;

  	return NULL;
  }

  static struct md_personality *find_pers(int level, char *clevel)

  {

  	struct md_personality *pers;

  	list_for_each_entry(pers, &pers_list, list) {
  		if (level != LEVEL_NONE && pers->level == level)

  			return pers;

  		if (strcmp(pers->name, clevel)==0)
  			return pers;
  	}

  	return NULL;
  }

  /* return the offset of the super block in 512byte sectors */

  static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)

  {

  	sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;

  	return MD_NEW_SIZE_SECTORS(num_sectors);

  }

  static int alloc_disk_sb(struct md_rdev * rdev)

  {
  	if (rdev->sb_page)
  		MD_BUG();
  
  	rdev->sb_page = alloc_page(GFP_KERNEL);
  	if (!rdev->sb_page) {
  		printk(KERN_ALERT "md: out of memory.
  ");

  		return -ENOMEM;

  	}
  
  	return 0;
  }

  static void free_disk_sb(struct md_rdev * rdev)

  {
  	if (rdev->sb_page) {

  		put_page(rdev->sb_page);

  		rdev->sb_loaded = 0;
  		rdev->sb_page = NULL;

  		rdev->sb_start = 0;

  		rdev->sectors = 0;

  	}

  	if (rdev->bb_page) {
  		put_page(rdev->bb_page);
  		rdev->bb_page = NULL;
  	}

  }

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

  {

  	struct md_rdev *rdev = bio->bi_private;

  	struct mddev *mddev = rdev->mddev;

  	if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags)) {
  		printk("md: super_written gets error=%d, uptodate=%d
  ",
  		       error, test_bit(BIO_UPTODATE, &bio->bi_flags));
  		WARN_ON(test_bit(BIO_UPTODATE, &bio->bi_flags));

  		md_error(mddev, rdev);

  	}

  	if (atomic_dec_and_test(&mddev->pending_writes))
  		wake_up(&mddev->sb_wait);

  	bio_put(bio);

  }

  void md_super_write(struct mddev *mddev, struct md_rdev *rdev,

  		   sector_t sector, int size, struct page *page)
  {
  	/* write first size bytes of page to sector of rdev
  	 * Increment mddev->pending_writes before returning
  	 * and decrement it on completion, waking up sb_wait
  	 * if zero is reached.
  	 * If an error occurred, call md_error
  	 */

  	struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, mddev);

  	bio->bi_bdev = rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev;

  	bio->bi_sector = sector;
  	bio_add_page(bio, page, size, 0);
  	bio->bi_private = rdev;
  	bio->bi_end_io = super_written;

  	atomic_inc(&mddev->pending_writes);

  	submit_bio(WRITE_FLUSH_FUA, bio);

  }

  void md_super_wait(struct mddev *mddev)

  {

  	/* wait for all superblock writes that were scheduled to complete */

  	DEFINE_WAIT(wq);
  	for(;;) {
  		prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE);
  		if (atomic_read(&mddev->pending_writes)==0)
  			break;

  		schedule();
  	}
  	finish_wait(&mddev->sb_wait, &wq);

  }

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

  {

  	complete((struct completion*)bio->bi_private);

  }

  int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,

  		 struct page *page, int rw, bool metadata_op)

  {

  	struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, rdev->mddev);

  	struct completion event;
  	int ret;

  	rw |= REQ_SYNC;

  	bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
  		rdev->meta_bdev : rdev->bdev;

  	if (metadata_op)
  		bio->bi_sector = sector + rdev->sb_start;
  	else
  		bio->bi_sector = sector + rdev->data_offset;

  	bio_add_page(bio, page, size, 0);
  	init_completion(&event);
  	bio->bi_private = &event;
  	bio->bi_end_io = bi_complete;
  	submit_bio(rw, bio);
  	wait_for_completion(&event);
  
  	ret = test_bit(BIO_UPTODATE, &bio->bi_flags);
  	bio_put(bio);
  	return ret;
  }

  EXPORT_SYMBOL_GPL(sync_page_io);

  static int read_disk_sb(struct md_rdev * rdev, int size)

  {
  	char b[BDEVNAME_SIZE];
  	if (!rdev->sb_page) {
  		MD_BUG();
  		return -EINVAL;
  	}
  	if (rdev->sb_loaded)
  		return 0;

  	if (!sync_page_io(rdev, 0, size, rdev->sb_page, READ, true))

  		goto fail;
  	rdev->sb_loaded = 1;
  	return 0;
  
  fail:
  	printk(KERN_WARNING "md: disabled device %s, could not read superblock.
  ",
  		bdevname(rdev->bdev,b));
  	return -EINVAL;
  }
  
  static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
  {

  	return 	sb1->set_uuid0 == sb2->set_uuid0 &&
  		sb1->set_uuid1 == sb2->set_uuid1 &&
  		sb1->set_uuid2 == sb2->set_uuid2 &&
  		sb1->set_uuid3 == sb2->set_uuid3;

  }

  static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
  {
  	int ret;
  	mdp_super_t *tmp1, *tmp2;
  
  	tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
  	tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
  
  	if (!tmp1 || !tmp2) {
  		ret = 0;

  		printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!
  ");

  		goto abort;
  	}
  
  	*tmp1 = *sb1;
  	*tmp2 = *sb2;
  
  	/*
  	 * nr_disks is not constant
  	 */
  	tmp1->nr_disks = 0;
  	tmp2->nr_disks = 0;

  	ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);

  abort:

  	kfree(tmp1);
  	kfree(tmp2);

  	return ret;
  }

  
  static u32 md_csum_fold(u32 csum)
  {
  	csum = (csum & 0xffff) + (csum >> 16);
  	return (csum & 0xffff) + (csum >> 16);
  }

  static unsigned int calc_sb_csum(mdp_super_t * sb)
  {

  	u64 newcsum = 0;
  	u32 *sb32 = (u32*)sb;
  	int i;

  	unsigned int disk_csum, csum;
  
  	disk_csum = sb->sb_csum;
  	sb->sb_csum = 0;

  
  	for (i = 0; i < MD_SB_BYTES/4 ; i++)
  		newcsum += sb32[i];
  	csum = (newcsum & 0xffffffff) + (newcsum>>32);
  
  
  #ifdef CONFIG_ALPHA
  	/* This used to use csum_partial, which was wrong for several
  	 * reasons including that different results are returned on
  	 * different architectures.  It isn't critical that we get exactly
  	 * the same return value as before (we always csum_fold before
  	 * testing, and that removes any differences).  However as we
  	 * know that csum_partial always returned a 16bit value on
  	 * alphas, do a fold to maximise conformity to previous behaviour.
  	 */
  	sb->sb_csum = md_csum_fold(disk_csum);
  #else

  	sb->sb_csum = disk_csum;

  #endif

  	return csum;
  }
  
  
  /*
   * Handle superblock details.
   * We want to be able to handle multiple superblock formats
   * so we have a common interface to them all, and an array of
   * different handlers.
   * We rely on user-space to write the initial superblock, and support
   * reading and updating of superblocks.
   * Interface methods are:

   *   int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)

   *      loads and validates a superblock on dev.
   *      if refdev != NULL, compare superblocks on both devices
   *    Return:
   *      0 - dev has a superblock that is compatible with refdev
   *      1 - dev has a superblock that is compatible and newer than refdev
   *          so dev should be used as the refdev in future
   *     -EINVAL superblock incompatible or invalid
   *     -othererror e.g. -EIO
   *

   *   int validate_super(struct mddev *mddev, struct md_rdev *dev)

   *      Verify that dev is acceptable into mddev.
   *       The first time, mddev->raid_disks will be 0, and data from
   *       dev should be merged in.  Subsequent calls check that dev
   *       is new enough.  Return 0 or -EINVAL
   *

   *   void sync_super(struct mddev *mddev, struct md_rdev *dev)

   *     Update the superblock for rdev with data in mddev
   *     This does not write to disc.
   *
   */
  
  struct super_type  {

  	char		    *name;
  	struct module	    *owner;

  	int		    (*load_super)(struct md_rdev *rdev, struct md_rdev *refdev,

  					  int minor_version);

  	int		    (*validate_super)(struct mddev *mddev, struct md_rdev *rdev);
  	void		    (*sync_super)(struct mddev *mddev, struct md_rdev *rdev);

  	unsigned long long  (*rdev_size_change)(struct md_rdev *rdev,

  						sector_t num_sectors);

  };
  
  /*

   * Check that the given mddev has no bitmap.
   *
   * This function is called from the run method of all personalities that do not
   * support bitmaps. It prints an error message and returns non-zero if mddev
   * has a bitmap. Otherwise, it returns 0.
   *
   */

  int md_check_no_bitmap(struct mddev *mddev)

  {

  	if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)

  		return 0;
  	printk(KERN_ERR "%s: bitmaps are not supported for %s
  ",
  		mdname(mddev), mddev->pers->name);
  	return 1;
  }
  EXPORT_SYMBOL(md_check_no_bitmap);
  
  /*

   * load_super for 0.90.0 
   */

  static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)

  {
  	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  	mdp_super_t *sb;
  	int ret;

  
  	/*

  	 * Calculate the position of the superblock (512byte sectors),

  	 * it's at the end of the disk.
  	 *
  	 * It also happens to be a multiple of 4Kb.
  	 */

  	rdev->sb_start = calc_dev_sboffset(rdev);

  	ret = read_disk_sb(rdev, MD_SB_BYTES);

  	if (ret) return ret;
  
  	ret = -EINVAL;
  
  	bdevname(rdev->bdev, b);

  	sb = page_address(rdev->sb_page);

  
  	if (sb->md_magic != MD_SB_MAGIC) {
  		printk(KERN_ERR "md: invalid raid superblock magic on %s
  ",
  		       b);
  		goto abort;
  	}
  
  	if (sb->major_version != 0 ||

  	    sb->minor_version < 90 ||
  	    sb->minor_version > 91) {

  		printk(KERN_WARNING "Bad version number %d.%d on %s
  ",
  			sb->major_version, sb->minor_version,
  			b);
  		goto abort;
  	}
  
  	if (sb->raid_disks <= 0)
  		goto abort;

  	if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {

  		printk(KERN_WARNING "md: invalid superblock checksum on %s
  ",
  			b);
  		goto abort;
  	}
  
  	rdev->preferred_minor = sb->md_minor;
  	rdev->data_offset = 0;

  	rdev->sb_size = MD_SB_BYTES;

  	rdev->badblocks.shift = -1;

  
  	if (sb->level == LEVEL_MULTIPATH)
  		rdev->desc_nr = -1;
  	else
  		rdev->desc_nr = sb->this_disk.number;

  	if (!refdev) {

  		ret = 1;

  	} else {

  		__u64 ev1, ev2;

  		mdp_super_t *refsb = page_address(refdev->sb_page);

  		if (!uuid_equal(refsb, sb)) {
  			printk(KERN_WARNING "md: %s has different UUID to %s
  ",
  				b, bdevname(refdev->bdev,b2));
  			goto abort;
  		}
  		if (!sb_equal(refsb, sb)) {
  			printk(KERN_WARNING "md: %s has same UUID"
  			       " but different superblock to %s
  ",
  			       b, bdevname(refdev->bdev, b2));
  			goto abort;
  		}
  		ev1 = md_event(sb);
  		ev2 = md_event(refsb);
  		if (ev1 > ev2)
  			ret = 1;
  		else 
  			ret = 0;
  	}

  	rdev->sectors = rdev->sb_start;

  	/* Limit to 4TB as metadata cannot record more than that */
  	if (rdev->sectors >= (2ULL << 32))
  		rdev->sectors = (2ULL << 32) - 2;

  	if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)

  		/* "this cannot possibly happen" ... */
  		ret = -EINVAL;

   abort:
  	return ret;
  }
  
  /*
   * validate_super for 0.90.0
   */

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

  {
  	mdp_disk_t *desc;

  	mdp_super_t *sb = page_address(rdev->sb_page);

  	__u64 ev1 = md_event(sb);

  	rdev->raid_disk = -1;

  	clear_bit(Faulty, &rdev->flags);
  	clear_bit(In_sync, &rdev->flags);
  	clear_bit(WriteMostly, &rdev->flags);

  	if (mddev->raid_disks == 0) {
  		mddev->major_version = 0;
  		mddev->minor_version = sb->minor_version;
  		mddev->patch_version = sb->patch_version;

  		mddev->external = 0;

  		mddev->chunk_sectors = sb->chunk_size >> 9;

  		mddev->ctime = sb->ctime;
  		mddev->utime = sb->utime;
  		mddev->level = sb->level;

  		mddev->clevel[0] = 0;

  		mddev->layout = sb->layout;
  		mddev->raid_disks = sb->raid_disks;

  		mddev->dev_sectors = ((sector_t)sb->size) * 2;

  		mddev->events = ev1;

  		mddev->bitmap_info.offset = 0;
  		mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;

  		if (mddev->minor_version >= 91) {
  			mddev->reshape_position = sb->reshape_position;
  			mddev->delta_disks = sb->delta_disks;
  			mddev->new_level = sb->new_level;
  			mddev->new_layout = sb->new_layout;

  			mddev->new_chunk_sectors = sb->new_chunk >> 9;

  		} else {
  			mddev->reshape_position = MaxSector;
  			mddev->delta_disks = 0;
  			mddev->new_level = mddev->level;
  			mddev->new_layout = mddev->layout;

  			mddev->new_chunk_sectors = mddev->chunk_sectors;

  		}

  		if (sb->state & (1<<MD_SB_CLEAN))
  			mddev->recovery_cp = MaxSector;
  		else {
  			if (sb->events_hi == sb->cp_events_hi && 
  				sb->events_lo == sb->cp_events_lo) {
  				mddev->recovery_cp = sb->recovery_cp;
  			} else
  				mddev->recovery_cp = 0;
  		}
  
  		memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
  		memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
  		memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
  		memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
  
  		mddev->max_disks = MD_SB_DISKS;

  
  		if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&

  		    mddev->bitmap_info.file == NULL)
  			mddev->bitmap_info.offset =
  				mddev->bitmap_info.default_offset;

  	} else if (mddev->pers == NULL) {

  		/* Insist on good event counter while assembling, except
  		 * for spares (which don't need an event count) */

  		++ev1;

  		if (sb->disks[rdev->desc_nr].state & (
  			    (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
  			if (ev1 < mddev->events) 
  				return -EINVAL;

  	} else if (mddev->bitmap) {
  		/* if adding to array with a bitmap, then we can accept an
  		 * older device ... but not too old.
  		 */

  		if (ev1 < mddev->bitmap->events_cleared)
  			return 0;

  	} else {
  		if (ev1 < mddev->events)
  			/* just a hot-add of a new device, leave raid_disk at -1 */
  			return 0;
  	}

  	if (mddev->level != LEVEL_MULTIPATH) {

  		desc = sb->disks + rdev->desc_nr;
  
  		if (desc->state & (1<<MD_DISK_FAULTY))

  			set_bit(Faulty, &rdev->flags);

  		else if (desc->state & (1<<MD_DISK_SYNC) /* &&
  			    desc->raid_disk < mddev->raid_disks */) {

  			set_bit(In_sync, &rdev->flags);

  			rdev->raid_disk = desc->raid_disk;

  		} else if (desc->state & (1<<MD_DISK_ACTIVE)) {
  			/* active but not in sync implies recovery up to
  			 * reshape position.  We don't know exactly where
  			 * that is, so set to zero for now */
  			if (mddev->minor_version >= 91) {
  				rdev->recovery_offset = 0;
  				rdev->raid_disk = desc->raid_disk;
  			}

  		}

  		if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
  			set_bit(WriteMostly, &rdev->flags);

  	} else /* MULTIPATH are always insync */

  		set_bit(In_sync, &rdev->flags);

  	return 0;
  }
  
  /*
   * sync_super for 0.90.0
   */

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

  {
  	mdp_super_t *sb;

  	struct md_rdev *rdev2;

  	int next_spare = mddev->raid_disks;

  
  	/* make rdev->sb match mddev data..
  	 *
  	 * 1/ zero out disks
  	 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
  	 * 3/ any empty disks < next_spare become removed
  	 *
  	 * disks[0] gets initialised to REMOVED because
  	 * we cannot be sure from other fields if it has
  	 * been initialised or not.
  	 */
  	int i;
  	int active=0, working=0,failed=0,spare=0,nr_disks=0;

  	rdev->sb_size = MD_SB_BYTES;

  	sb = page_address(rdev->sb_page);

  
  	memset(sb, 0, sizeof(*sb));
  
  	sb->md_magic = MD_SB_MAGIC;
  	sb->major_version = mddev->major_version;

  	sb->patch_version = mddev->patch_version;
  	sb->gvalid_words  = 0; /* ignored */
  	memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
  	memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
  	memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
  	memcpy(&sb->set_uuid3, mddev->uuid+12,4);
  
  	sb->ctime = mddev->ctime;
  	sb->level = mddev->level;

  	sb->size = mddev->dev_sectors / 2;

  	sb->raid_disks = mddev->raid_disks;
  	sb->md_minor = mddev->md_minor;

  	sb->not_persistent = 0;

  	sb->utime = mddev->utime;
  	sb->state = 0;
  	sb->events_hi = (mddev->events>>32);
  	sb->events_lo = (u32)mddev->events;

  	if (mddev->reshape_position == MaxSector)
  		sb->minor_version = 90;
  	else {
  		sb->minor_version = 91;
  		sb->reshape_position = mddev->reshape_position;
  		sb->new_level = mddev->new_level;
  		sb->delta_disks = mddev->delta_disks;
  		sb->new_layout = mddev->new_layout;

  		sb->new_chunk = mddev->new_chunk_sectors << 9;

  	}
  	mddev->minor_version = sb->minor_version;

  	if (mddev->in_sync)
  	{
  		sb->recovery_cp = mddev->recovery_cp;
  		sb->cp_events_hi = (mddev->events>>32);
  		sb->cp_events_lo = (u32)mddev->events;
  		if (mddev->recovery_cp == MaxSector)
  			sb->state = (1<< MD_SB_CLEAN);
  	} else
  		sb->recovery_cp = 0;
  
  	sb->layout = mddev->layout;

  	sb->chunk_size = mddev->chunk_sectors << 9;

  	if (mddev->bitmap && mddev->bitmap_info.file == NULL)

  		sb->state |= (1<<MD_SB_BITMAP_PRESENT);

  	sb->disks[0].state = (1<<MD_DISK_REMOVED);

  	list_for_each_entry(rdev2, &mddev->disks, same_set) {

  		mdp_disk_t *d;

  		int desc_nr;

  		int is_active = test_bit(In_sync, &rdev2->flags);
  
  		if (rdev2->raid_disk >= 0 &&
  		    sb->minor_version >= 91)
  			/* we have nowhere to store the recovery_offset,
  			 * but if it is not below the reshape_position,
  			 * we can piggy-back on that.
  			 */
  			is_active = 1;
  		if (rdev2->raid_disk < 0 ||
  		    test_bit(Faulty, &rdev2->flags))
  			is_active = 0;
  		if (is_active)

  			desc_nr = rdev2->raid_disk;

  		else

  			desc_nr = next_spare++;

  		rdev2->desc_nr = desc_nr;

  		d = &sb->disks[rdev2->desc_nr];
  		nr_disks++;
  		d->number = rdev2->desc_nr;
  		d->major = MAJOR(rdev2->bdev->bd_dev);
  		d->minor = MINOR(rdev2->bdev->bd_dev);

  		if (is_active)

  			d->raid_disk = rdev2->raid_disk;
  		else
  			d->raid_disk = rdev2->desc_nr; /* compatibility */

  		if (test_bit(Faulty, &rdev2->flags))

  			d->state = (1<<MD_DISK_FAULTY);

  		else if (is_active) {

  			d->state = (1<<MD_DISK_ACTIVE);

  			if (test_bit(In_sync, &rdev2->flags))
  				d->state |= (1<<MD_DISK_SYNC);

  			active++;
  			working++;
  		} else {
  			d->state = 0;
  			spare++;
  			working++;
  		}

  		if (test_bit(WriteMostly, &rdev2->flags))
  			d->state |= (1<<MD_DISK_WRITEMOSTLY);

  	}

  	/* now set the "removed" and "faulty" bits on any missing devices */
  	for (i=0 ; i < mddev->raid_disks ; i++) {
  		mdp_disk_t *d = &sb->disks[i];
  		if (d->state == 0 && d->number == 0) {
  			d->number = i;
  			d->raid_disk = i;
  			d->state = (1<<MD_DISK_REMOVED);
  			d->state |= (1<<MD_DISK_FAULTY);
  			failed++;
  		}
  	}
  	sb->nr_disks = nr_disks;
  	sb->active_disks = active;
  	sb->working_disks = working;
  	sb->failed_disks = failed;
  	sb->spare_disks = spare;
  
  	sb->this_disk = sb->disks[rdev->desc_nr];
  	sb->sb_csum = calc_sb_csum(sb);
  }
  
  /*

   * rdev_size_change for 0.90.0
   */
  static unsigned long long

  super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)

  {

  	if (num_sectors && num_sectors < rdev->mddev->dev_sectors)

  		return 0; /* component must fit device */

  	if (rdev->mddev->bitmap_info.offset)

  		return 0; /* can't move bitmap */

  	rdev->sb_start = calc_dev_sboffset(rdev);

  	if (!num_sectors || num_sectors > rdev->sb_start)
  		num_sectors = rdev->sb_start;

  	/* Limit to 4TB as metadata cannot record more than that.
  	 * 4TB == 2^32 KB, or 2*2^32 sectors.
  	 */
  	if (num_sectors >= (2ULL << 32))
  		num_sectors = (2ULL << 32) - 2;

  	md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,

  		       rdev->sb_page);
  	md_super_wait(rdev->mddev);

  	return num_sectors;

  }
  
  
  /*

   * version 1 superblock
   */

  static __le32 calc_sb_1_csum(struct mdp_superblock_1 * sb)

  {

  	__le32 disk_csum;
  	u32 csum;

  	unsigned long long newcsum;
  	int size = 256 + le32_to_cpu(sb->max_dev)*2;

  	__le32 *isuper = (__le32*)sb;

  	int i;
  
  	disk_csum = sb->sb_csum;
  	sb->sb_csum = 0;
  	newcsum = 0;
  	for (i=0; size>=4; size -= 4 )
  		newcsum += le32_to_cpu(*isuper++);
  
  	if (size == 2)

  		newcsum += le16_to_cpu(*(__le16*) isuper);

  
  	csum = (newcsum & 0xffffffff) + (newcsum >> 32);
  	sb->sb_csum = disk_csum;
  	return cpu_to_le32(csum);
  }

  static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors,
  			    int acknowledged);

  static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)

  {
  	struct mdp_superblock_1 *sb;
  	int ret;

  	sector_t sb_start;

  	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];

  	int bmask;

  
  	/*

  	 * Calculate the position of the superblock in 512byte sectors.

  	 * It is always aligned to a 4K boundary and
  	 * depeding on minor_version, it can be:
  	 * 0: At least 8K, but less than 12K, from end of device
  	 * 1: At start of device
  	 * 2: 4K from start of device.
  	 */
  	switch(minor_version) {
  	case 0:

  		sb_start = i_size_read(rdev->bdev->bd_inode) >> 9;

  		sb_start -= 8*2;
  		sb_start &= ~(sector_t)(4*2-1);

  		break;
  	case 1:

  		sb_start = 0;

  		break;
  	case 2:

  		sb_start = 8;

  		break;
  	default:
  		return -EINVAL;
  	}

  	rdev->sb_start = sb_start;

  	/* superblock is rarely larger than 1K, but it can be larger,
  	 * and it is safe to read 4k, so we do that
  	 */
  	ret = read_disk_sb(rdev, 4096);

  	if (ret) return ret;

  	sb = page_address(rdev->sb_page);

  
  	if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
  	    sb->major_version != cpu_to_le32(1) ||
  	    le32_to_cpu(sb->max_dev) > (4096-256)/2 ||

  	    le64_to_cpu(sb->super_offset) != rdev->sb_start ||

  	    (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)

  		return -EINVAL;
  
  	if (calc_sb_1_csum(sb) != sb->sb_csum) {
  		printk("md: invalid superblock checksum on %s
  ",
  			bdevname(rdev->bdev,b));
  		return -EINVAL;
  	}
  	if (le64_to_cpu(sb->data_size) < 10) {
  		printk("md: data_size too small on %s
  ",
  		       bdevname(rdev->bdev,b));
  		return -EINVAL;
  	}

  	rdev->preferred_minor = 0xffff;
  	rdev->data_offset = le64_to_cpu(sb->data_offset);

  	atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));

  	rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;

  	bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;

  	if (rdev->sb_size & bmask)

  		rdev->sb_size = (rdev->sb_size | bmask) + 1;
  
  	if (minor_version

  	    && rdev->data_offset < sb_start + (rdev->sb_size/512))

  		return -EINVAL;

  	if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
  		rdev->desc_nr = -1;
  	else
  		rdev->desc_nr = le32_to_cpu(sb->dev_number);

  	if (!rdev->bb_page) {
  		rdev->bb_page = alloc_page(GFP_KERNEL);
  		if (!rdev->bb_page)
  			return -ENOMEM;
  	}
  	if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) &&
  	    rdev->badblocks.count == 0) {
  		/* need to load the bad block list.
  		 * Currently we limit it to one page.
  		 */
  		s32 offset;
  		sector_t bb_sector;
  		u64 *bbp;
  		int i;
  		int sectors = le16_to_cpu(sb->bblog_size);
  		if (sectors > (PAGE_SIZE / 512))
  			return -EINVAL;
  		offset = le32_to_cpu(sb->bblog_offset);
  		if (offset == 0)
  			return -EINVAL;
  		bb_sector = (long long)offset;
  		if (!sync_page_io(rdev, bb_sector, sectors << 9,
  				  rdev->bb_page, READ, true))
  			return -EIO;
  		bbp = (u64 *)page_address(rdev->bb_page);
  		rdev->badblocks.shift = sb->bblog_shift;
  		for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
  			u64 bb = le64_to_cpu(*bbp);
  			int count = bb & (0x3ff);
  			u64 sector = bb >> 10;
  			sector <<= sb->bblog_shift;
  			count <<= sb->bblog_shift;
  			if (bb + 1 == 0)
  				break;
  			if (md_set_badblocks(&rdev->badblocks,
  					     sector, count, 1) == 0)
  				return -EINVAL;
  		}
  	} else if (sb->bblog_offset == 0)
  		rdev->badblocks.shift = -1;

  	if (!refdev) {

  		ret = 1;

  	} else {

  		__u64 ev1, ev2;

  		struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);

  
  		if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
  		    sb->level != refsb->level ||
  		    sb->layout != refsb->layout ||
  		    sb->chunksize != refsb->chunksize) {
  			printk(KERN_WARNING "md: %s has strangely different"
  				" superblock to %s
  ",
  				bdevname(rdev->bdev,b),
  				bdevname(refdev->bdev,b2));
  			return -EINVAL;
  		}
  		ev1 = le64_to_cpu(sb->events);
  		ev2 = le64_to_cpu(refsb->events);
  
  		if (ev1 > ev2)

  			ret = 1;
  		else
  			ret = 0;

  	}

  	if (minor_version)

  		rdev->sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -

  			le64_to_cpu(sb->data_offset);

  	else

  		rdev->sectors = rdev->sb_start;
  	if (rdev->sectors < le64_to_cpu(sb->data_size))

  		return -EINVAL;

  	rdev->sectors = le64_to_cpu(sb->data_size);

  	if (le64_to_cpu(sb->size) > rdev->sectors)

  		return -EINVAL;

  	return ret;

  }

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

  {

  	struct mdp_superblock_1 *sb = page_address(rdev->sb_page);

  	__u64 ev1 = le64_to_cpu(sb->events);

  	rdev->raid_disk = -1;

  	clear_bit(Faulty, &rdev->flags);
  	clear_bit(In_sync, &rdev->flags);
  	clear_bit(WriteMostly, &rdev->flags);

  	if (mddev->raid_disks == 0) {
  		mddev->major_version = 1;
  		mddev->patch_version = 0;

  		mddev->external = 0;

  		mddev->chunk_sectors = le32_to_cpu(sb->chunksize);

  		mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
  		mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
  		mddev->level = le32_to_cpu(sb->level);

  		mddev->clevel[0] = 0;

  		mddev->layout = le32_to_cpu(sb->layout);
  		mddev->raid_disks = le32_to_cpu(sb->raid_disks);

  		mddev->dev_sectors = le64_to_cpu(sb->size);

  		mddev->events = ev1;

  		mddev->bitmap_info.offset = 0;
  		mddev->bitmap_info.default_offset = 1024 >> 9;

  		
  		mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
  		memcpy(mddev->uuid, sb->set_uuid, 16);
  
  		mddev->max_disks =  (4096-256)/2;

  		if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&

  		    mddev->bitmap_info.file == NULL )
  			mddev->bitmap_info.offset =
  				(__s32)le32_to_cpu(sb->bitmap_offset);

  		if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
  			mddev->reshape_position = le64_to_cpu(sb->reshape_position);
  			mddev->delta_disks = le32_to_cpu(sb->delta_disks);
  			mddev->new_level = le32_to_cpu(sb->new_level);
  			mddev->new_layout = le32_to_cpu(sb->new_layout);

  			mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);

  		} else {
  			mddev->reshape_position = MaxSector;
  			mddev->delta_disks = 0;
  			mddev->new_level = mddev->level;
  			mddev->new_layout = mddev->layout;

  			mddev->new_chunk_sectors = mddev->chunk_sectors;

  		}

  	} else if (mddev->pers == NULL) {

  		/* Insist of good event counter while assembling, except for
  		 * spares (which don't need an event count) */

  		++ev1;

  		if (rdev->desc_nr >= 0 &&
  		    rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
  		    le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < 0xfffe)
  			if (ev1 < mddev->events)
  				return -EINVAL;

  	} else if (mddev->bitmap) {
  		/* If adding to array with a bitmap, then we can accept an
  		 * older device, but not too old.
  		 */

  		if (ev1 < mddev->bitmap->events_cleared)
  			return 0;

  	} else {
  		if (ev1 < mddev->events)
  			/* just a hot-add of a new device, leave raid_disk at -1 */
  			return 0;
  	}

  	if (mddev->level != LEVEL_MULTIPATH) {
  		int role;

  		if (rdev->desc_nr < 0 ||
  		    rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
  			role = 0xffff;
  			rdev->desc_nr = -1;
  		} else
  			role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);

  		switch(role) {
  		case 0xffff: /* spare */

  			break;
  		case 0xfffe: /* faulty */

  			set_bit(Faulty, &rdev->flags);

  			break;
  		default:

  			if ((le32_to_cpu(sb->feature_map) &
  			     MD_FEATURE_RECOVERY_OFFSET))
  				rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
  			else
  				set_bit(In_sync, &rdev->flags);

  			rdev->raid_disk = role;
  			break;
  		}

  		if (sb->devflags & WriteMostly1)
  			set_bit(WriteMostly, &rdev->flags);

  	} else /* MULTIPATH are always insync */

  		set_bit(In_sync, &rdev->flags);

  	return 0;
  }

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

  {
  	struct mdp_superblock_1 *sb;

  	struct md_rdev *rdev2;

  	int max_dev, i;
  	/* make rdev->sb match mddev and rdev data. */

  	sb = page_address(rdev->sb_page);

  
  	sb->feature_map = 0;
  	sb->pad0 = 0;

  	sb->recovery_offset = cpu_to_le64(0);

  	memset(sb->pad1, 0, sizeof(sb->pad1));

  	memset(sb->pad3, 0, sizeof(sb->pad3));
  
  	sb->utime = cpu_to_le64((__u64)mddev->utime);
  	sb->events = cpu_to_le64(mddev->events);
  	if (mddev->in_sync)
  		sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
  	else
  		sb->resync_offset = cpu_to_le64(0);

  	sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));

  	sb->raid_disks = cpu_to_le32(mddev->raid_disks);

  	sb->size = cpu_to_le64(mddev->dev_sectors);

  	sb->chunksize = cpu_to_le32(mddev->chunk_sectors);

  	sb->level = cpu_to_le32(mddev->level);
  	sb->layout = cpu_to_le32(mddev->layout);

  	if (test_bit(WriteMostly, &rdev->flags))
  		sb->devflags |= WriteMostly1;
  	else
  		sb->devflags &= ~WriteMostly1;

  	if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
  		sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);

  		sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);

  	}

  
  	if (rdev->raid_disk >= 0 &&

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

  		sb->feature_map |=
  			cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
  		sb->recovery_offset =
  			cpu_to_le64(rdev->recovery_offset);