1/*
   2 * raid10.c : Multiple Devices driver for Linux
   3 *
   4 * Copyright (C) 2000-2004 Neil Brown
   5 *
   6 * RAID-10 support for md.
   7 *
   8 * Base on code in raid1.c.  See raid1.c for further copyright information.
   9 *
  10 *
  11 * This program is free software; you can redistribute it and/or modify
  12 * it under the terms of the GNU General Public License as published by
  13 * the Free Software Foundation; either version 2, or (at your option)
  14 * any later version.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * (for example /usr/src/linux/COPYING); if not, write to the Free
  18 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21#include <linux/slab.h>
  22#include <linux/delay.h>
  23#include <linux/blkdev.h>
  24#include <linux/module.h>
  25#include <linux/seq_file.h>
  26#include <linux/ratelimit.h>
  27#include <linux/kthread.h>
 
 
  28#include "md.h"
 
 
  29#include "raid10.h"
  30#include "raid0.h"
  31#include "bitmap.h"
  32
  33/*
  34 * RAID10 provides a combination of RAID0 and RAID1 functionality.
  35 * The layout of data is defined by
  36 *    chunk_size
  37 *    raid_disks
  38 *    near_copies (stored in low byte of layout)
  39 *    far_copies (stored in second byte of layout)
  40 *    far_offset (stored in bit 16 of layout )
 
 
  41 *
  42 * The data to be stored is divided into chunks using chunksize.
  43 * Each device is divided into far_copies sections.
  44 * In each section, chunks are laid out in a style similar to raid0, but
  45 * near_copies copies of each chunk is stored (each on a different drive).
  46 * The starting device for each section is offset near_copies from the starting
  47 * device of the previous section.
  48 * Thus they are (near_copies*far_copies) of each chunk, and each is on a different
  49 * drive.
  50 * near_copies and far_copies must be at least one, and their product is at most
  51 * raid_disks.
  52 *
  53 * If far_offset is true, then the far_copies are handled a bit differently.
  54 * The copies are still in different stripes, but instead of be very far apart
  55 * on disk, there are adjacent stripes.
  56 */
  57
  58/*
  59 * Number of guaranteed r10bios in case of extreme VM load:
  60 */
  61#define	NR_RAID10_BIOS 256
  62
  63/* When there are this many requests queue to be written by
  64 * the raid10 thread, we become 'congested' to provide back-pressure
  65 * for writeback.
 
 
 
 
 
 
  66 */
  67static int max_queued_requests = 1024;
  68
  69static void allow_barrier(struct r10conf *conf);
  70static void lower_barrier(struct r10conf *conf);
 
  71static int enough(struct r10conf *conf, int ignore);
  72static sector_t reshape_request(struct mddev *mddev, sector_t sector_nr,
  73				int *skipped);
  74static void reshape_request_write(struct mddev *mddev, struct r10bio *r10_bio);
  75static void end_reshape_write(struct bio *bio, int error);
  76static void end_reshape(struct r10conf *conf);
  77
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  78static void * r10bio_pool_alloc(gfp_t gfp_flags, void *data)
  79{
  80	struct r10conf *conf = data;
  81	int size = offsetof(struct r10bio, devs[conf->copies]);
  82
  83	/* allocate a r10bio with room for raid_disks entries in the
  84	 * bios array */
  85	return kzalloc(size, gfp_flags);
  86}
  87
  88static void r10bio_pool_free(void *r10_bio, void *data)
  89{
  90	kfree(r10_bio);
  91}
  92
  93/* Maximum size of each resync request */
  94#define RESYNC_BLOCK_SIZE (64*1024)
  95#define RESYNC_PAGES ((RESYNC_BLOCK_SIZE + PAGE_SIZE-1) / PAGE_SIZE)
  96/* amount of memory to reserve for resync requests */
  97#define RESYNC_WINDOW (1024*1024)
  98/* maximum number of concurrent requests, memory permitting */
  99#define RESYNC_DEPTH (32*1024*1024/RESYNC_BLOCK_SIZE)
 
 
 100
 101/*
 102 * When performing a resync, we need to read and compare, so
 103 * we need as many pages are there are copies.
 104 * When performing a recovery, we need 2 bios, one for read,
 105 * one for write (we recover only one drive per r10buf)
 106 *
 107 */
 108static void * r10buf_pool_alloc(gfp_t gfp_flags, void *data)
 109{
 110	struct r10conf *conf = data;
 111	struct page *page;
 112	struct r10bio *r10_bio;
 113	struct bio *bio;
 114	int i, j;
 115	int nalloc;
 
 116
 117	r10_bio = r10bio_pool_alloc(gfp_flags, conf);
 118	if (!r10_bio)
 119		return NULL;
 120
 121	if (test_bit(MD_RECOVERY_SYNC, &conf->mddev->recovery) ||
 122	    test_bit(MD_RECOVERY_RESHAPE, &conf->mddev->recovery))
 123		nalloc = conf->copies; /* resync */
 124	else
 125		nalloc = 2; /* recovery */
 126
 
 
 
 
 
 
 
 
 
 127	/*
 128	 * Allocate bios.
 129	 */
 130	for (j = nalloc ; j-- ; ) {
 131		bio = bio_kmalloc(gfp_flags, RESYNC_PAGES);
 132		if (!bio)
 133			goto out_free_bio;
 
 134		r10_bio->devs[j].bio = bio;
 135		if (!conf->have_replacement)
 136			continue;
 137		bio = bio_kmalloc(gfp_flags, RESYNC_PAGES);
 138		if (!bio)
 139			goto out_free_bio;
 
 140		r10_bio->devs[j].repl_bio = bio;
 141	}
 142	/*
 143	 * Allocate RESYNC_PAGES data pages and attach them
 144	 * where needed.
 145	 */
 146	for (j = 0 ; j < nalloc; j++) {
 147		struct bio *rbio = r10_bio->devs[j].repl_bio;
 
 
 
 
 
 
 148		bio = r10_bio->devs[j].bio;
 149		for (i = 0; i < RESYNC_PAGES; i++) {
 150			if (j > 0 && !test_bit(MD_RECOVERY_SYNC,
 151					       &conf->mddev->recovery)) {
 152				/* we can share bv_page's during recovery
 153				 * and reshape */
 154				struct bio *rbio = r10_bio->devs[0].bio;
 155				page = rbio->bi_io_vec[i].bv_page;
 156				get_page(page);
 157			} else
 158				page = alloc_page(gfp_flags);
 159			if (unlikely(!page))
 160				goto out_free_pages;
 
 
 
 
 161
 162			bio->bi_io_vec[i].bv_page = page;
 163			if (rbio)
 164				rbio->bi_io_vec[i].bv_page = page;
 
 
 165		}
 166	}
 167
 168	return r10_bio;
 169
 170out_free_pages:
 171	for ( ; i > 0 ; i--)
 172		safe_put_page(bio->bi_io_vec[i-1].bv_page);
 173	while (j--)
 174		for (i = 0; i < RESYNC_PAGES ; i++)
 175			safe_put_page(r10_bio->devs[j].bio->bi_io_vec[i].bv_page);
 176	j = 0;
 177out_free_bio:
 178	for ( ; j < nalloc; j++) {
 179		if (r10_bio->devs[j].bio)
 180			bio_put(r10_bio->devs[j].bio);
 
 181		if (r10_bio->devs[j].repl_bio)
 182			bio_put(r10_bio->devs[j].repl_bio);
 
 183	}
 184	r10bio_pool_free(r10_bio, conf);
 
 
 185	return NULL;
 186}
 187
 188static void r10buf_pool_free(void *__r10_bio, void *data)
 189{
 190	int i;
 191	struct r10conf *conf = data;
 192	struct r10bio *r10bio = __r10_bio;
 193	int j;
 
 194
 195	for (j=0; j < conf->copies; j++) {
 196		struct bio *bio = r10bio->devs[j].bio;
 
 197		if (bio) {
 198			for (i = 0; i < RESYNC_PAGES; i++) {
 199				safe_put_page(bio->bi_io_vec[i].bv_page);
 200				bio->bi_io_vec[i].bv_page = NULL;
 201			}
 202			bio_put(bio);
 203		}
 
 204		bio = r10bio->devs[j].repl_bio;
 205		if (bio)
 206			bio_put(bio);
 
 
 207	}
 208	r10bio_pool_free(r10bio, conf);
 
 
 
 
 209}
 210
 211static void put_all_bios(struct r10conf *conf, struct r10bio *r10_bio)
 212{
 213	int i;
 214
 215	for (i = 0; i < conf->copies; i++) {
 216		struct bio **bio = & r10_bio->devs[i].bio;
 217		if (!BIO_SPECIAL(*bio))
 218			bio_put(*bio);
 219		*bio = NULL;
 220		bio = &r10_bio->devs[i].repl_bio;
 221		if (r10_bio->read_slot < 0 && !BIO_SPECIAL(*bio))
 222			bio_put(*bio);
 223		*bio = NULL;
 224	}
 225}
 226
 227static void free_r10bio(struct r10bio *r10_bio)
 228{
 229	struct r10conf *conf = r10_bio->mddev->private;
 230
 231	put_all_bios(conf, r10_bio);
 232	mempool_free(r10_bio, conf->r10bio_pool);
 233}
 234
 235static void put_buf(struct r10bio *r10_bio)
 236{
 237	struct r10conf *conf = r10_bio->mddev->private;
 238
 239	mempool_free(r10_bio, conf->r10buf_pool);
 240
 241	lower_barrier(conf);
 242}
 243
 
 
 
 
 
 
 244static void reschedule_retry(struct r10bio *r10_bio)
 245{
 246	unsigned long flags;
 247	struct mddev *mddev = r10_bio->mddev;
 248	struct r10conf *conf = mddev->private;
 249
 250	spin_lock_irqsave(&conf->device_lock, flags);
 251	list_add(&r10_bio->retry_list, &conf->retry_list);
 252	conf->nr_queued ++;
 253	spin_unlock_irqrestore(&conf->device_lock, flags);
 254
 255	/* wake up frozen array... */
 256	wake_up(&conf->wait_barrier);
 257
 258	md_wakeup_thread(mddev->thread);
 259}
 260
 261/*
 262 * raid_end_bio_io() is called when we have finished servicing a mirrored
 263 * operation and are ready to return a success/failure code to the buffer
 264 * cache layer.
 265 */
 266static void raid_end_bio_io(struct r10bio *r10_bio)
 267{
 268	struct bio *bio = r10_bio->master_bio;
 269	int done;
 270	struct r10conf *conf = r10_bio->mddev->private;
 271
 272	if (bio->bi_phys_segments) {
 273		unsigned long flags;
 274		spin_lock_irqsave(&conf->device_lock, flags);
 275		bio->bi_phys_segments--;
 276		done = (bio->bi_phys_segments == 0);
 277		spin_unlock_irqrestore(&conf->device_lock, flags);
 278	} else
 279		done = 1;
 280	if (!test_bit(R10BIO_Uptodate, &r10_bio->state))
 281		clear_bit(BIO_UPTODATE, &bio->bi_flags);
 282	if (done) {
 283		bio_endio(bio, 0);
 284		/*
 285		 * Wake up any possible resync thread that waits for the device
 286		 * to go idle.
 287		 */
 288		allow_barrier(conf);
 289	}
 290	free_r10bio(r10_bio);
 291}
 292
 293/*
 294 * Update disk head position estimator based on IRQ completion info.
 295 */
 296static inline void update_head_pos(int slot, struct r10bio *r10_bio)
 297{
 298	struct r10conf *conf = r10_bio->mddev->private;
 299
 300	conf->mirrors[r10_bio->devs[slot].devnum].head_position =
 301		r10_bio->devs[slot].addr + (r10_bio->sectors);
 302}
 303
 304/*
 305 * Find the disk number which triggered given bio
 306 */
 307static int find_bio_disk(struct r10conf *conf, struct r10bio *r10_bio,
 308			 struct bio *bio, int *slotp, int *replp)
 309{
 310	int slot;
 311	int repl = 0;
 312
 313	for (slot = 0; slot < conf->copies; slot++) {
 314		if (r10_bio->devs[slot].bio == bio)
 315			break;
 316		if (r10_bio->devs[slot].repl_bio == bio) {
 317			repl = 1;
 318			break;
 319		}
 320	}
 321
 322	BUG_ON(slot == conf->copies);
 323	update_head_pos(slot, r10_bio);
 324
 325	if (slotp)
 326		*slotp = slot;
 327	if (replp)
 328		*replp = repl;
 329	return r10_bio->devs[slot].devnum;
 330}
 331
 332static void raid10_end_read_request(struct bio *bio, int error)
 333{
 334	int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
 335	struct r10bio *r10_bio = bio->bi_private;
 336	int slot, dev;
 337	struct md_rdev *rdev;
 338	struct r10conf *conf = r10_bio->mddev->private;
 339
 340
 341	slot = r10_bio->read_slot;
 342	dev = r10_bio->devs[slot].devnum;
 343	rdev = r10_bio->devs[slot].rdev;
 344	/*
 345	 * this branch is our 'one mirror IO has finished' event handler:
 346	 */
 347	update_head_pos(slot, r10_bio);
 348
 349	if (uptodate) {
 350		/*
 351		 * Set R10BIO_Uptodate in our master bio, so that
 352		 * we will return a good error code to the higher
 353		 * levels even if IO on some other mirrored buffer fails.
 354		 *
 355		 * The 'master' represents the composite IO operation to
 356		 * user-side. So if something waits for IO, then it will
 357		 * wait for the 'master' bio.
 358		 */
 359		set_bit(R10BIO_Uptodate, &r10_bio->state);
 360	} else {
 361		/* If all other devices that store this block have
 362		 * failed, we want to return the error upwards rather
 363		 * than fail the last device.  Here we redefine
 364		 * "uptodate" to mean "Don't want to retry"
 365		 */
 366		unsigned long flags;
 367		spin_lock_irqsave(&conf->device_lock, flags);
 368		if (!enough(conf, rdev->raid_disk))
 369			uptodate = 1;
 370		spin_unlock_irqrestore(&conf->device_lock, flags);
 371	}
 372	if (uptodate) {
 373		raid_end_bio_io(r10_bio);
 374		rdev_dec_pending(rdev, conf->mddev);
 375	} else {
 376		/*
 377		 * oops, read error - keep the refcount on the rdev
 378		 */
 379		char b[BDEVNAME_SIZE];
 380		printk_ratelimited(KERN_ERR
 381				   "md/raid10:%s: %s: rescheduling sector %llu\n",
 382				   mdname(conf->mddev),
 383				   bdevname(rdev->bdev, b),
 384				   (unsigned long long)r10_bio->sector);
 385		set_bit(R10BIO_ReadError, &r10_bio->state);
 386		reschedule_retry(r10_bio);
 387	}
 388}
 389
 390static void close_write(struct r10bio *r10_bio)
 391{
 392	/* clear the bitmap if all writes complete successfully */
 393	bitmap_endwrite(r10_bio->mddev->bitmap, r10_bio->sector,
 394			r10_bio->sectors,
 395			!test_bit(R10BIO_Degraded, &r10_bio->state),
 396			0);
 397	md_write_end(r10_bio->mddev);
 398}
 399
 400static void one_write_done(struct r10bio *r10_bio)
 401{
 402	if (atomic_dec_and_test(&r10_bio->remaining)) {
 403		if (test_bit(R10BIO_WriteError, &r10_bio->state))
 404			reschedule_retry(r10_bio);
 405		else {
 406			close_write(r10_bio);
 407			if (test_bit(R10BIO_MadeGood, &r10_bio->state))
 408				reschedule_retry(r10_bio);
 409			else
 410				raid_end_bio_io(r10_bio);
 411		}
 412	}
 413}
 414
 415static void raid10_end_write_request(struct bio *bio, int error)
 416{
 417	int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
 418	struct r10bio *r10_bio = bio->bi_private;
 419	int dev;
 420	int dec_rdev = 1;
 421	struct r10conf *conf = r10_bio->mddev->private;
 422	int slot, repl;
 423	struct md_rdev *rdev = NULL;
 
 
 
 
 424
 425	dev = find_bio_disk(conf, r10_bio, bio, &slot, &repl);
 426
 427	if (repl)
 428		rdev = conf->mirrors[dev].replacement;
 429	if (!rdev) {
 430		smp_rmb();
 431		repl = 0;
 432		rdev = conf->mirrors[dev].rdev;
 433	}
 434	/*
 435	 * this branch is our 'one mirror IO has finished' event handler:
 436	 */
 437	if (!uptodate) {
 438		if (repl)
 439			/* Never record new bad blocks to replacement,
 440			 * just fail it.
 441			 */
 442			md_error(rdev->mddev, rdev);
 443		else {
 444			set_bit(WriteErrorSeen,	&rdev->flags);
 445			if (!test_and_set_bit(WantReplacement, &rdev->flags))
 446				set_bit(MD_RECOVERY_NEEDED,
 447					&rdev->mddev->recovery);
 448			set_bit(R10BIO_WriteError, &r10_bio->state);
 449			dec_rdev = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 450		}
 451	} else {
 452		/*
 453		 * Set R10BIO_Uptodate in our master bio, so that
 454		 * we will return a good error code for to the higher
 455		 * levels even if IO on some other mirrored buffer fails.
 456		 *
 457		 * The 'master' represents the composite IO operation to
 458		 * user-side. So if something waits for IO, then it will
 459		 * wait for the 'master' bio.
 460		 */
 461		sector_t first_bad;
 462		int bad_sectors;
 463
 464		set_bit(R10BIO_Uptodate, &r10_bio->state);
 
 
 
 
 
 
 
 
 
 
 465
 466		/* Maybe we can clear some bad blocks. */
 467		if (is_badblock(rdev,
 468				r10_bio->devs[slot].addr,
 469				r10_bio->sectors,
 470				&first_bad, &bad_sectors)) {
 471			bio_put(bio);
 472			if (repl)
 473				r10_bio->devs[slot].repl_bio = IO_MADE_GOOD;
 474			else
 475				r10_bio->devs[slot].bio = IO_MADE_GOOD;
 476			dec_rdev = 0;
 477			set_bit(R10BIO_MadeGood, &r10_bio->state);
 478		}
 479	}
 480
 481	/*
 482	 *
 483	 * Let's see if all mirrored write operations have finished
 484	 * already.
 485	 */
 486	one_write_done(r10_bio);
 487	if (dec_rdev)
 488		rdev_dec_pending(conf->mirrors[dev].rdev, conf->mddev);
 
 
 489}
 490
 491/*
 492 * RAID10 layout manager
 493 * As well as the chunksize and raid_disks count, there are two
 494 * parameters: near_copies and far_copies.
 495 * near_copies * far_copies must be <= raid_disks.
 496 * Normally one of these will be 1.
 497 * If both are 1, we get raid0.
 498 * If near_copies == raid_disks, we get raid1.
 499 *
 500 * Chunks are laid out in raid0 style with near_copies copies of the
 501 * first chunk, followed by near_copies copies of the next chunk and
 502 * so on.
 503 * If far_copies > 1, then after 1/far_copies of the array has been assigned
 504 * as described above, we start again with a device offset of near_copies.
 505 * So we effectively have another copy of the whole array further down all
 506 * the drives, but with blocks on different drives.
 507 * With this layout, and block is never stored twice on the one device.
 508 *
 509 * raid10_find_phys finds the sector offset of a given virtual sector
 510 * on each device that it is on.
 511 *
 512 * raid10_find_virt does the reverse mapping, from a device and a
 513 * sector offset to a virtual address
 514 */
 515
 516static void __raid10_find_phys(struct geom *geo, struct r10bio *r10bio)
 517{
 518	int n,f;
 519	sector_t sector;
 520	sector_t chunk;
 521	sector_t stripe;
 522	int dev;
 523	int slot = 0;
 
 
 
 
 
 
 
 524
 525	/* now calculate first sector/dev */
 526	chunk = r10bio->sector >> geo->chunk_shift;
 527	sector = r10bio->sector & geo->chunk_mask;
 528
 529	chunk *= geo->near_copies;
 530	stripe = chunk;
 531	dev = sector_div(stripe, geo->raid_disks);
 532	if (geo->far_offset)
 533		stripe *= geo->far_copies;
 534
 535	sector += stripe << geo->chunk_shift;
 536
 537	/* and calculate all the others */
 538	for (n = 0; n < geo->near_copies; n++) {
 539		int d = dev;
 
 540		sector_t s = sector;
 541		r10bio->devs[slot].addr = sector;
 542		r10bio->devs[slot].devnum = d;
 
 543		slot++;
 544
 545		for (f = 1; f < geo->far_copies; f++) {
 
 546			d += geo->near_copies;
 547			if (d >= geo->raid_disks)
 548				d -= geo->raid_disks;
 
 
 
 
 
 
 
 
 549			s += geo->stride;
 550			r10bio->devs[slot].devnum = d;
 551			r10bio->devs[slot].addr = s;
 552			slot++;
 553		}
 554		dev++;
 555		if (dev >= geo->raid_disks) {
 556			dev = 0;
 557			sector += (geo->chunk_mask + 1);
 558		}
 559	}
 560}
 561
 562static void raid10_find_phys(struct r10conf *conf, struct r10bio *r10bio)
 563{
 564	struct geom *geo = &conf->geo;
 565
 566	if (conf->reshape_progress != MaxSector &&
 567	    ((r10bio->sector >= conf->reshape_progress) !=
 568	     conf->mddev->reshape_backwards)) {
 569		set_bit(R10BIO_Previous, &r10bio->state);
 570		geo = &conf->prev;
 571	} else
 572		clear_bit(R10BIO_Previous, &r10bio->state);
 573
 574	__raid10_find_phys(geo, r10bio);
 575}
 576
 577static sector_t raid10_find_virt(struct r10conf *conf, sector_t sector, int dev)
 578{
 579	sector_t offset, chunk, vchunk;
 580	/* Never use conf->prev as this is only called during resync
 581	 * or recovery, so reshape isn't happening
 582	 */
 583	struct geom *geo = &conf->geo;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 584
 585	offset = sector & geo->chunk_mask;
 586	if (geo->far_offset) {
 587		int fc;
 588		chunk = sector >> geo->chunk_shift;
 589		fc = sector_div(chunk, geo->far_copies);
 590		dev -= fc * geo->near_copies;
 591		if (dev < 0)
 592			dev += geo->raid_disks;
 593	} else {
 594		while (sector >= geo->stride) {
 595			sector -= geo->stride;
 596			if (dev < geo->near_copies)
 597				dev += geo->raid_disks - geo->near_copies;
 598			else
 599				dev -= geo->near_copies;
 600		}
 601		chunk = sector >> geo->chunk_shift;
 602	}
 603	vchunk = chunk * geo->raid_disks + dev;
 604	sector_div(vchunk, geo->near_copies);
 605	return (vchunk << geo->chunk_shift) + offset;
 606}
 607
 608/**
 609 *	raid10_mergeable_bvec -- tell bio layer if a two requests can be merged
 610 *	@q: request queue
 611 *	@bvm: properties of new bio
 612 *	@biovec: the request that could be merged to it.
 613 *
 614 *	Return amount of bytes we can accept at this offset
 615 *	This requires checking for end-of-chunk if near_copies != raid_disks,
 616 *	and for subordinate merge_bvec_fns if merge_check_needed.
 617 */
 618static int raid10_mergeable_bvec(struct request_queue *q,
 619				 struct bvec_merge_data *bvm,
 620				 struct bio_vec *biovec)
 621{
 622	struct mddev *mddev = q->queuedata;
 623	struct r10conf *conf = mddev->private;
 624	sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
 625	int max;
 626	unsigned int chunk_sectors;
 627	unsigned int bio_sectors = bvm->bi_size >> 9;
 628	struct geom *geo = &conf->geo;
 629
 630	chunk_sectors = (conf->geo.chunk_mask & conf->prev.chunk_mask) + 1;
 631	if (conf->reshape_progress != MaxSector &&
 632	    ((sector >= conf->reshape_progress) !=
 633	     conf->mddev->reshape_backwards))
 634		geo = &conf->prev;
 635
 636	if (geo->near_copies < geo->raid_disks) {
 637		max = (chunk_sectors - ((sector & (chunk_sectors - 1))
 638					+ bio_sectors)) << 9;
 639		if (max < 0)
 640			/* bio_add cannot handle a negative return */
 641			max = 0;
 642		if (max <= biovec->bv_len && bio_sectors == 0)
 643			return biovec->bv_len;
 644	} else
 645		max = biovec->bv_len;
 646
 647	if (mddev->merge_check_needed) {
 648		struct {
 649			struct r10bio r10_bio;
 650			struct r10dev devs[conf->copies];
 651		} on_stack;
 652		struct r10bio *r10_bio = &on_stack.r10_bio;
 653		int s;
 654		if (conf->reshape_progress != MaxSector) {
 655			/* Cannot give any guidance during reshape */
 656			if (max <= biovec->bv_len && bio_sectors == 0)
 657				return biovec->bv_len;
 658			return 0;
 659		}
 660		r10_bio->sector = sector;
 661		raid10_find_phys(conf, r10_bio);
 662		rcu_read_lock();
 663		for (s = 0; s < conf->copies; s++) {
 664			int disk = r10_bio->devs[s].devnum;
 665			struct md_rdev *rdev = rcu_dereference(
 666				conf->mirrors[disk].rdev);
 667			if (rdev && !test_bit(Faulty, &rdev->flags)) {
 668				struct request_queue *q =
 669					bdev_get_queue(rdev->bdev);
 670				if (q->merge_bvec_fn) {
 671					bvm->bi_sector = r10_bio->devs[s].addr
 672						+ rdev->data_offset;
 673					bvm->bi_bdev = rdev->bdev;
 674					max = min(max, q->merge_bvec_fn(
 675							  q, bvm, biovec));
 676				}
 677			}
 678			rdev = rcu_dereference(conf->mirrors[disk].replacement);
 679			if (rdev && !test_bit(Faulty, &rdev->flags)) {
 680				struct request_queue *q =
 681					bdev_get_queue(rdev->bdev);
 682				if (q->merge_bvec_fn) {
 683					bvm->bi_sector = r10_bio->devs[s].addr
 684						+ rdev->data_offset;
 685					bvm->bi_bdev = rdev->bdev;
 686					max = min(max, q->merge_bvec_fn(
 687							  q, bvm, biovec));
 688				}
 689			}
 690		}
 691		rcu_read_unlock();
 692	}
 693	return max;
 694}
 695
 696/*
 697 * This routine returns the disk from which the requested read should
 698 * be done. There is a per-array 'next expected sequential IO' sector
 699 * number - if this matches on the next IO then we use the last disk.
 700 * There is also a per-disk 'last know head position' sector that is
 701 * maintained from IRQ contexts, both the normal and the resync IO
 702 * completion handlers update this position correctly. If there is no
 703 * perfect sequential match then we pick the disk whose head is closest.
 704 *
 705 * If there are 2 mirrors in the same 2 devices, performance degrades
 706 * because position is mirror, not device based.
 707 *
 708 * The rdev for the device selected will have nr_pending incremented.
 709 */
 710
 711/*
 712 * FIXME: possibly should rethink readbalancing and do it differently
 713 * depending on near_copies / far_copies geometry.
 714 */
 715static struct md_rdev *read_balance(struct r10conf *conf,
 716				    struct r10bio *r10_bio,
 717				    int *max_sectors)
 718{
 719	const sector_t this_sector = r10_bio->sector;
 720	int disk, slot;
 721	int sectors = r10_bio->sectors;
 722	int best_good_sectors;
 723	sector_t new_distance, best_dist;
 724	struct md_rdev *rdev, *best_rdev;
 725	int do_balance;
 726	int best_slot;
 
 
 727	struct geom *geo = &conf->geo;
 728
 729	raid10_find_phys(conf, r10_bio);
 730	rcu_read_lock();
 731retry:
 732	sectors = r10_bio->sectors;
 733	best_slot = -1;
 734	best_rdev = NULL;
 735	best_dist = MaxSector;
 736	best_good_sectors = 0;
 737	do_balance = 1;
 
 738	/*
 739	 * Check if we can balance. We can balance on the whole
 740	 * device if no resync is going on (recovery is ok), or below
 741	 * the resync window. We take the first readable disk when
 742	 * above the resync window.
 743	 */
 744	if (conf->mddev->recovery_cp < MaxSector
 745	    && (this_sector + sectors >= conf->next_resync))
 
 
 
 746		do_balance = 0;
 747
 748	for (slot = 0; slot < conf->copies ; slot++) {
 749		sector_t first_bad;
 750		int bad_sectors;
 751		sector_t dev_sector;
 
 
 752
 753		if (r10_bio->devs[slot].bio == IO_BLOCKED)
 754			continue;
 755		disk = r10_bio->devs[slot].devnum;
 756		rdev = rcu_dereference(conf->mirrors[disk].replacement);
 757		if (rdev == NULL || test_bit(Faulty, &rdev->flags) ||
 758		    test_bit(Unmerged, &rdev->flags) ||
 759		    r10_bio->devs[slot].addr + sectors > rdev->recovery_offset)
 760			rdev = rcu_dereference(conf->mirrors[disk].rdev);
 761		if (rdev == NULL ||
 762		    test_bit(Faulty, &rdev->flags) ||
 763		    test_bit(Unmerged, &rdev->flags))
 764			continue;
 765		if (!test_bit(In_sync, &rdev->flags) &&
 766		    r10_bio->devs[slot].addr + sectors > rdev->recovery_offset)
 767			continue;
 768
 769		dev_sector = r10_bio->devs[slot].addr;
 770		if (is_badblock(rdev, dev_sector, sectors,
 771				&first_bad, &bad_sectors)) {
 772			if (best_dist < MaxSector)
 773				/* Already have a better slot */
 774				continue;
 775			if (first_bad <= dev_sector) {
 776				/* Cannot read here.  If this is the
 777				 * 'primary' device, then we must not read
 778				 * beyond 'bad_sectors' from another device.
 779				 */
 780				bad_sectors -= (dev_sector - first_bad);
 781				if (!do_balance && sectors > bad_sectors)
 782					sectors = bad_sectors;
 783				if (best_good_sectors > sectors)
 784					best_good_sectors = sectors;
 785			} else {
 786				sector_t good_sectors =
 787					first_bad - dev_sector;
 788				if (good_sectors > best_good_sectors) {
 789					best_good_sectors = good_sectors;
 790					best_slot = slot;
 791					best_rdev = rdev;
 792				}
 793				if (!do_balance)
 794					/* Must read from here */
 795					break;
 796			}
 797			continue;
 798		} else
 799			best_good_sectors = sectors;
 800
 801		if (!do_balance)
 802			break;
 803
 
 
 
 
 
 
 
 
 
 
 
 
 804		/* This optimisation is debatable, and completely destroys
 805		 * sequential read speed for 'far copies' arrays.  So only
 806		 * keep it for 'near' arrays, and review those later.
 807		 */
 808		if (geo->near_copies > 1 && !atomic_read(&rdev->nr_pending))
 809			break;
 810
 811		/* for far > 1 always use the lowest address */
 812		if (geo->far_copies > 1)
 813			new_distance = r10_bio->devs[slot].addr;
 814		else
 815			new_distance = abs(r10_bio->devs[slot].addr -
 816					   conf->mirrors[disk].head_position);
 
 817		if (new_distance < best_dist) {
 818			best_dist = new_distance;
 819			best_slot = slot;
 820			best_rdev = rdev;
 821		}
 822	}
 823	if (slot >= conf->copies) {
 824		slot = best_slot;
 825		rdev = best_rdev;
 
 
 
 
 
 826	}
 827
 828	if (slot >= 0) {
 829		atomic_inc(&rdev->nr_pending);
 830		if (test_bit(Faulty, &rdev->flags)) {
 831			/* Cannot risk returning a device that failed
 832			 * before we inc'ed nr_pending
 833			 */
 834			rdev_dec_pending(rdev, conf->mddev);
 835			goto retry;
 836		}
 837		r10_bio->read_slot = slot;
 838	} else
 839		rdev = NULL;
 840	rcu_read_unlock();
 841	*max_sectors = best_good_sectors;
 842
 843	return rdev;
 844}
 845
 846static int raid10_congested(void *data, int bits)
 847{
 848	struct mddev *mddev = data;
 849	struct r10conf *conf = mddev->private;
 850	int i, ret = 0;
 851
 852	if ((bits & (1 << BDI_async_congested)) &&
 853	    conf->pending_count >= max_queued_requests)
 854		return 1;
 855
 856	if (mddev_congested(mddev, bits))
 857		return 1;
 858	rcu_read_lock();
 859	for (i = 0;
 860	     (i < conf->geo.raid_disks || i < conf->prev.raid_disks)
 861		     && ret == 0;
 862	     i++) {
 863		struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
 864		if (rdev && !test_bit(Faulty, &rdev->flags)) {
 865			struct request_queue *q = bdev_get_queue(rdev->bdev);
 866
 867			ret |= bdi_congested(&q->backing_dev_info, bits);
 868		}
 869	}
 870	rcu_read_unlock();
 871	return ret;
 872}
 873
 874static void flush_pending_writes(struct r10conf *conf)
 875{
 876	/* Any writes that have been queued but are awaiting
 877	 * bitmap updates get flushed here.
 878	 */
 879	spin_lock_irq(&conf->device_lock);
 880
 881	if (conf->pending_bio_list.head) {
 
 882		struct bio *bio;
 
 883		bio = bio_list_get(&conf->pending_bio_list);
 884		conf->pending_count = 0;
 885		spin_unlock_irq(&conf->device_lock);
 886		/* flush any pending bitmap writes to disk
 887		 * before proceeding w/ I/O */
 888		bitmap_unplug(conf->mddev->bitmap);
 
 
 
 
 
 
 
 
 
 
 
 889		wake_up(&conf->wait_barrier);
 890
 891		while (bio) { /* submit pending writes */
 892			struct bio *next = bio->bi_next;
 893			bio->bi_next = NULL;
 894			generic_make_request(bio);
 895			bio = next;
 
 896		}
 
 897	} else
 898		spin_unlock_irq(&conf->device_lock);
 899}
 900
 901/* Barriers....
 902 * Sometimes we need to suspend IO while we do something else,
 903 * either some resync/recovery, or reconfigure the array.
 904 * To do this we raise a 'barrier'.
 905 * The 'barrier' is a counter that can be raised multiple times
 906 * to count how many activities are happening which preclude
 907 * normal IO.
 908 * We can only raise the barrier if there is no pending IO.
 909 * i.e. if nr_pending == 0.
 910 * We choose only to raise the barrier if no-one is waiting for the
 911 * barrier to go down.  This means that as soon as an IO request
 912 * is ready, no other operations which require a barrier will start
 913 * until the IO request has had a chance.
 914 *
 915 * So: regular IO calls 'wait_barrier'.  When that returns there
 916 *    is no backgroup IO happening,  It must arrange to call
 917 *    allow_barrier when it has finished its IO.
 918 * backgroup IO calls must call raise_barrier.  Once that returns
 919 *    there is no normal IO happeing.  It must arrange to call
 920 *    lower_barrier when the particular background IO completes.
 921 */
 922
 923static void raise_barrier(struct r10conf *conf, int force)
 924{
 925	BUG_ON(force && !conf->barrier);
 926	spin_lock_irq(&conf->resync_lock);
 
 
 927
 928	/* Wait until no block IO is waiting (unless 'force') */
 929	wait_event_lock_irq(conf->wait_barrier, force || !conf->nr_waiting,
 930			    conf->resync_lock, );
 931
 932	/* block any new IO from starting */
 933	conf->barrier++;
 934
 935	/* Now wait for all pending IO to complete */
 936	wait_event_lock_irq(conf->wait_barrier,
 937			    !conf->nr_pending && conf->barrier < RESYNC_DEPTH,
 938			    conf->resync_lock, );
 939
 940	spin_unlock_irq(&conf->resync_lock);
 941}
 942
 943static void lower_barrier(struct r10conf *conf)
 944{
 945	unsigned long flags;
 946	spin_lock_irqsave(&conf->resync_lock, flags);
 947	conf->barrier--;
 948	spin_unlock_irqrestore(&conf->resync_lock, flags);
 
 949	wake_up(&conf->wait_barrier);
 950}
 951
 952static void wait_barrier(struct r10conf *conf)
 953{
 954	spin_lock_irq(&conf->resync_lock);
 955	if (conf->barrier) {
 956		conf->nr_waiting++;
 957		/* Wait for the barrier to drop.
 958		 * However if there are already pending
 959		 * requests (preventing the barrier from
 960		 * rising completely), and the
 961		 * pre-process bio queue isn't empty,
 962		 * then don't wait, as we need to empty
 963		 * that queue to get the nr_pending
 964		 * count down.
 965		 */
 966		wait_event_lock_irq(conf->wait_barrier,
 967				    !conf->barrier ||
 968				    (conf->nr_pending &&
 969				     current->bio_list &&
 970				     !bio_list_empty(current->bio_list)),
 971				    conf->resync_lock,
 972			);
 973		conf->nr_waiting--;
 
 
 
 
 
 
 
 974	}
 975	conf->nr_pending++;
 976	spin_unlock_irq(&conf->resync_lock);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 977}
 978
 979static void allow_barrier(struct r10conf *conf)
 980{
 981	unsigned long flags;
 982	spin_lock_irqsave(&conf->resync_lock, flags);
 983	conf->nr_pending--;
 984	spin_unlock_irqrestore(&conf->resync_lock, flags);
 985	wake_up(&conf->wait_barrier);
 986}
 987
 988static void freeze_array(struct r10conf *conf)
 989{
 990	/* stop syncio and normal IO and wait for everything to
 991	 * go quiet.
 992	 * We increment barrier and nr_waiting, and then
 993	 * wait until nr_pending match nr_queued+1
 994	 * This is called in the context of one normal IO request
 995	 * that has failed. Thus any sync request that might be pending
 996	 * will be blocked by nr_pending, and we need to wait for
 997	 * pending IO requests to complete or be queued for re-try.
 998	 * Thus the number queued (nr_queued) plus this request (1)
 999	 * must match the number of pending IOs (nr_pending) before
1000	 * we continue.
1001	 */
1002	spin_lock_irq(&conf->resync_lock);
1003	conf->barrier++;
 
1004	conf->nr_waiting++;
1005	wait_event_lock_irq(conf->wait_barrier,
1006			    conf->nr_pending == conf->nr_queued+1,
1007			    conf->resync_lock,
1008			    flush_pending_writes(conf));
1009
1010	spin_unlock_irq(&conf->resync_lock);
1011}
1012
1013static void unfreeze_array(struct r10conf *conf)
1014{
1015	/* reverse the effect of the freeze */
1016	spin_lock_irq(&conf->resync_lock);
1017	conf->barrier--;
1018	conf->nr_waiting--;
1019	wake_up(&conf->wait_barrier);
1020	spin_unlock_irq(&conf->resync_lock);
1021}
1022
1023static sector_t choose_data_offset(struct r10bio *r10_bio,
1024				   struct md_rdev *rdev)
1025{
1026	if (!test_bit(MD_RECOVERY_RESHAPE, &rdev->mddev->recovery) ||
1027	    test_bit(R10BIO_Previous, &r10_bio->state))
1028		return rdev->data_offset;
1029	else
1030		return rdev->new_data_offset;
1031}
1032
1033static void make_request(struct mddev *mddev, struct bio * bio)
1034{
 
 
1035	struct r10conf *conf = mddev->private;
1036	struct r10bio *r10_bio;
1037	struct bio *read_bio;
1038	int i;
1039	sector_t chunk_mask = (conf->geo.chunk_mask & conf->prev.chunk_mask);
1040	int chunk_sects = chunk_mask + 1;
1041	const int rw = bio_data_dir(bio);
1042	const unsigned long do_sync = (bio->bi_rw & REQ_SYNC);
1043	const unsigned long do_fua = (bio->bi_rw & REQ_FUA);
1044	unsigned long flags;
1045	struct md_rdev *blocked_rdev;
1046	int sectors_handled;
1047	int max_sectors;
1048	int sectors;
1049
1050	if (unlikely(bio->bi_rw & REQ_FLUSH)) {
1051		md_flush_request(mddev, bio);
 
 
 
 
 
1052		return;
1053	}
1054
1055	/* If this request crosses a chunk boundary, we need to
1056	 * split it.  This will only happen for 1 PAGE (or less) requests.
1057	 */
1058	if (unlikely((bio->bi_sector & chunk_mask) + (bio->bi_size >> 9)
1059		     > chunk_sects
1060		     && (conf->geo.near_copies < conf->geo.raid_disks
1061			 || conf->prev.near_copies < conf->prev.raid_disks))) {
1062		struct bio_pair *bp;
1063		/* Sanity check -- queue functions should prevent this happening */
1064		if (bio->bi_vcnt != 1 ||
1065		    bio->bi_idx != 0)
1066			goto bad_map;
1067		/* This is a one page bio that upper layers
1068		 * refuse to split for us, so we need to split it.
1069		 */
1070		bp = bio_split(bio,
1071			       chunk_sects - (bio->bi_sector & (chunk_sects - 1)) );
1072
1073		/* Each of these 'make_request' calls will call 'wait_barrier'.
1074		 * If the first succeeds but the second blocks due to the resync
1075		 * thread raising the barrier, we will deadlock because the
1076		 * IO to the underlying device will be queued in generic_make_request
1077		 * and will never complete, so will never reduce nr_pending.
1078		 * So increment nr_waiting here so no new raise_barriers will
1079		 * succeed, and so the second wait_barrier cannot block.
1080		 */
1081		spin_lock_irq(&conf->resync_lock);
1082		conf->nr_waiting++;
1083		spin_unlock_irq(&conf->resync_lock);
1084
1085		make_request(mddev, &bp->bio1);
1086		make_request(mddev, &bp->bio2);
1087
1088		spin_lock_irq(&conf->resync_lock);
1089		conf->nr_waiting--;
1090		wake_up(&conf->wait_barrier);
1091		spin_unlock_irq(&conf->resync_lock);
1092
1093		bio_pair_release(bp);
1094		return;
1095	bad_map:
1096		printk("md/raid10:%s: make_request bug: can't convert block across chunks"
1097		       " or bigger than %dk %llu %d\n", mdname(mddev), chunk_sects/2,
1098		       (unsigned long long)bio->bi_sector, bio->bi_size >> 10);
1099
1100		bio_io_error(bio);
1101		return;
1102	}
 
 
1103
1104	md_write_start(mddev, bio);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1105
1106	/*
1107	 * Register the new request and wait if the reconstruction
1108	 * thread has put up a bar for new requests.
1109	 * Continue immediately if no resync is active currently.
1110	 */
1111	wait_barrier(conf);
 
 
 
 
 
 
 
1112
1113	sectors = bio->bi_size >> 9;
1114	while (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
1115	    bio->bi_sector < conf->reshape_progress &&
1116	    bio->bi_sector + sectors > conf->reshape_progress) {
1117		/* IO spans the reshape position.  Need to wait for
1118		 * reshape to pass
 
1119		 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1120		allow_barrier(conf);
1121		wait_event(conf->wait_barrier,
1122			   conf->reshape_progress <= bio->bi_sector ||
1123			   conf->reshape_progress >= bio->bi_sector + sectors);
1124		wait_barrier(conf);
 
1125	}
1126	if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
1127	    bio_data_dir(bio) == WRITE &&
1128	    (mddev->reshape_backwards
1129	     ? (bio->bi_sector < conf->reshape_safe &&
1130		bio->bi_sector + sectors > conf->reshape_progress)
1131	     : (bio->bi_sector + sectors > conf->reshape_safe &&
1132		bio->bi_sector < conf->reshape_progress))) {
1133		/* Need to update reshape_position in metadata */
1134		mddev->reshape_position = conf->reshape_progress;
1135		set_bit(MD_CHANGE_DEVS, &mddev->flags);
1136		set_bit(MD_CHANGE_PENDING, &mddev->flags);
1137		md_wakeup_thread(mddev->thread);
1138		wait_event(mddev->sb_wait,
1139			   !test_bit(MD_CHANGE_PENDING, &mddev->flags));
1140
1141		conf->reshape_safe = mddev->reshape_position;
 
 
1142	}
 
1143
1144	r10_bio = mempool_alloc(conf->r10bio_pool, GFP_NOIO);
 
1145
1146	r10_bio->master_bio = bio;
1147	r10_bio->sectors = sectors;
 
 
 
 
 
 
1148
1149	r10_bio->mddev = mddev;
1150	r10_bio->sector = bio->bi_sector;
1151	r10_bio->state = 0;
 
 
 
1152
1153	/* We might need to issue multiple reads to different
1154	 * devices if there are bad blocks around, so we keep
1155	 * track of the number of reads in bio->bi_phys_segments.
1156	 * If this is 0, there is only one r10_bio and no locking
1157	 * will be needed when the request completes.  If it is
1158	 * non-zero, then it is the number of not-completed requests.
1159	 */
1160	bio->bi_phys_segments = 0;
1161	clear_bit(BIO_SEG_VALID, &bio->bi_flags);
 
 
 
1162
1163	if (rw == READ) {
1164		/*
1165		 * read balancing logic:
1166		 */
1167		struct md_rdev *rdev;
1168		int slot;
1169
1170read_again:
1171		rdev = read_balance(conf, r10_bio, &max_sectors);
1172		if (!rdev) {
1173			raid_end_bio_io(r10_bio);
1174			return;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1175		}
1176		slot = r10_bio->read_slot;
1177
1178		read_bio = bio_clone_mddev(bio, GFP_NOIO, mddev);
1179		md_trim_bio(read_bio, r10_bio->sector - bio->bi_sector,
1180			    max_sectors);
1181
1182		r10_bio->devs[slot].bio = read_bio;
1183		r10_bio->devs[slot].rdev = rdev;
1184
1185		read_bio->bi_sector = r10_bio->devs[slot].addr +
1186			choose_data_offset(r10_bio, rdev);
1187		read_bio->bi_bdev = rdev->bdev;
1188		read_bio->bi_end_io = raid10_end_read_request;
1189		read_bio->bi_rw = READ | do_sync;
1190		read_bio->bi_private = r10_bio;
1191
1192		if (max_sectors < r10_bio->sectors) {
1193			/* Could not read all from this device, so we will
1194			 * need another r10_bio.
1195			 */
1196			sectors_handled = (r10_bio->sectors + max_sectors
1197					   - bio->bi_sector);
1198			r10_bio->sectors = max_sectors;
1199			spin_lock_irq(&conf->device_lock);
1200			if (bio->bi_phys_segments == 0)
1201				bio->bi_phys_segments = 2;
1202			else
1203				bio->bi_phys_segments++;
1204			spin_unlock(&conf->device_lock);
1205			/* Cannot call generic_make_request directly
1206			 * as that will be queued in __generic_make_request
1207			 * and subsequent mempool_alloc might block
1208			 * waiting for it.  so hand bio over to raid10d.
1209			 */
1210			reschedule_retry(r10_bio);
 
1211
1212			r10_bio = mempool_alloc(conf->r10bio_pool, GFP_NOIO);
 
 
 
 
 
 
 
 
 
 
 
 
 
1213
1214			r10_bio->master_bio = bio;
1215			r10_bio->sectors = ((bio->bi_size >> 9)
1216					    - sectors_handled);
1217			r10_bio->state = 0;
1218			r10_bio->mddev = mddev;
1219			r10_bio->sector = bio->bi_sector + sectors_handled;
1220			goto read_again;
1221		} else
1222			generic_make_request(read_bio);
1223		return;
1224	}
 
1225
1226	/*
1227	 * WRITE:
1228	 */
1229	if (conf->pending_count >= max_queued_requests) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1230		md_wakeup_thread(mddev->thread);
1231		wait_event(conf->wait_barrier,
1232			   conf->pending_count < max_queued_requests);
 
 
 
 
 
 
 
 
1233	}
 
1234	/* first select target devices under rcu_lock and
1235	 * inc refcount on their rdev.  Record them by setting
1236	 * bios[x] to bio
1237	 * If there are known/acknowledged bad blocks on any device
1238	 * on which we have seen a write error, we want to avoid
1239	 * writing to those blocks.  This potentially requires several
1240	 * writes to write around the bad blocks.  Each set of writes
1241	 * gets its own r10_bio with a set of bios attached.  The number
1242	 * of r10_bios is recored in bio->bi_phys_segments just as with
1243	 * the read case.
1244	 */
1245
1246	r10_bio->read_slot = -1; /* make sure repl_bio gets freed */
1247	raid10_find_phys(conf, r10_bio);
1248retry_write:
1249	blocked_rdev = NULL;
1250	rcu_read_lock();
1251	max_sectors = r10_bio->sectors;
1252
1253	for (i = 0;  i < conf->copies; i++) {
1254		int d = r10_bio->devs[i].devnum;
1255		struct md_rdev *rdev = rcu_dereference(conf->mirrors[d].rdev);
1256		struct md_rdev *rrdev = rcu_dereference(
1257			conf->mirrors[d].replacement);
1258		if (rdev == rrdev)
1259			rrdev = NULL;
1260		if (rdev && unlikely(test_bit(Blocked, &rdev->flags))) {
1261			atomic_inc(&rdev->nr_pending);
1262			blocked_rdev = rdev;
1263			break;
1264		}
1265		if (rrdev && unlikely(test_bit(Blocked, &rrdev->flags))) {
1266			atomic_inc(&rrdev->nr_pending);
1267			blocked_rdev = rrdev;
1268			break;
1269		}
1270		if (rrdev && (test_bit(Faulty, &rrdev->flags)
1271			      || test_bit(Unmerged, &rrdev->flags)))
1272			rrdev = NULL;
1273
1274		r10_bio->devs[i].bio = NULL;
1275		r10_bio->devs[i].repl_bio = NULL;
1276		if (!rdev || test_bit(Faulty, &rdev->flags) ||
1277		    test_bit(Unmerged, &rdev->flags)) {
1278			set_bit(R10BIO_Degraded, &r10_bio->state);
1279			continue;
1280		}
1281		if (test_bit(WriteErrorSeen, &rdev->flags)) {
1282			sector_t first_bad;
1283			sector_t dev_sector = r10_bio->devs[i].addr;
1284			int bad_sectors;
1285			int is_bad;
1286
1287			is_bad = is_badblock(rdev, dev_sector,
1288					     max_sectors,
1289					     &first_bad, &bad_sectors);
1290			if (is_bad < 0) {
1291				/* Mustn't write here until the bad block
1292				 * is acknowledged
1293				 */
1294				atomic_inc(&rdev->nr_pending);
1295				set_bit(BlockedBadBlocks, &rdev->flags);
1296				blocked_rdev = rdev;
1297				break;
1298			}
1299			if (is_bad && first_bad <= dev_sector) {
1300				/* Cannot write here at all */
1301				bad_sectors -= (dev_sector - first_bad);
1302				if (bad_sectors < max_sectors)
1303					/* Mustn't write more than bad_sectors
1304					 * to other devices yet
1305					 */
1306					max_sectors = bad_sectors;
1307				/* We don't set R10BIO_Degraded as that
1308				 * only applies if the disk is missing,
1309				 * so it might be re-added, and we want to
1310				 * know to recover this chunk.
1311				 * In this case the device is here, and the
1312				 * fact that this chunk is not in-sync is
1313				 * recorded in the bad block log.
1314				 */
1315				continue;
1316			}
1317			if (is_bad) {
1318				int good_sectors = first_bad - dev_sector;
1319				if (good_sectors < max_sectors)
1320					max_sectors = good_sectors;
1321			}
1322		}
1323		r10_bio->devs[i].bio = bio;
1324		atomic_inc(&rdev->nr_pending);
 
 
1325		if (rrdev) {
1326			r10_bio->devs[i].repl_bio = bio;
1327			atomic_inc(&rrdev->nr_pending);
1328		}
1329	}
1330	rcu_read_unlock();
1331
1332	if (unlikely(blocked_rdev)) {
1333		/* Have to wait for this device to get unblocked, then retry */
1334		int j;
1335		int d;
1336
1337		for (j = 0; j < i; j++) {
1338			if (r10_bio->devs[j].bio) {
1339				d = r10_bio->devs[j].devnum;
1340				rdev_dec_pending(conf->mirrors[d].rdev, mddev);
1341			}
1342			if (r10_bio->devs[j].repl_bio) {
1343				struct md_rdev *rdev;
1344				d = r10_bio->devs[j].devnum;
1345				rdev = conf->mirrors[d].replacement;
1346				if (!rdev) {
1347					/* Race with remove_disk */
1348					smp_mb();
1349					rdev = conf->mirrors[d].rdev;
1350				}
1351				rdev_dec_pending(rdev, mddev);
1352			}
1353		}
1354		allow_barrier(conf);
1355		md_wait_for_blocked_rdev(blocked_rdev, mddev);
1356		wait_barrier(conf);
1357		goto retry_write;
1358	}
1359
1360	if (max_sectors < r10_bio->sectors) {
1361		/* We are splitting this into multiple parts, so
1362		 * we need to prepare for allocating another r10_bio.
1363		 */
1364		r10_bio->sectors = max_sectors;
1365		spin_lock_irq(&conf->device_lock);
1366		if (bio->bi_phys_segments == 0)
1367			bio->bi_phys_segments = 2;
1368		else
1369			bio->bi_phys_segments++;
1370		spin_unlock_irq(&conf->device_lock);
1371	}
1372	sectors_handled = r10_bio->sector + max_sectors - bio->bi_sector;
1373
 
 
1374	atomic_set(&r10_bio->remaining, 1);
1375	bitmap_startwrite(mddev->bitmap, r10_bio->sector, r10_bio->sectors, 0);
1376
1377	for (i = 0; i < conf->copies; i++) {
1378		struct bio *mbio;
1379		int d = r10_bio->devs[i].devnum;
1380		if (!r10_bio->devs[i].bio)
1381			continue;
 
 
 
1382
1383		mbio = bio_clone_mddev(bio, GFP_NOIO, mddev);
1384		md_trim_bio(mbio, r10_bio->sector - bio->bi_sector,
1385			    max_sectors);
1386		r10_bio->devs[i].bio = mbio;
1387
1388		mbio->bi_sector	= (r10_bio->devs[i].addr+
1389				   choose_data_offset(r10_bio,
1390						      conf->mirrors[d].rdev));
1391		mbio->bi_bdev = conf->mirrors[d].rdev->bdev;
1392		mbio->bi_end_io	= raid10_end_write_request;
1393		mbio->bi_rw = WRITE | do_sync | do_fua;
1394		mbio->bi_private = r10_bio;
1395
1396		atomic_inc(&r10_bio->remaining);
1397		spin_lock_irqsave(&conf->device_lock, flags);
1398		bio_list_add(&conf->pending_bio_list, mbio);
1399		conf->pending_count++;
1400		spin_unlock_irqrestore(&conf->device_lock, flags);
1401		if (!mddev_check_plugged(mddev))
1402			md_wakeup_thread(mddev->thread);
1403
1404		if (!r10_bio->devs[i].repl_bio)
1405			continue;
1406
1407		mbio = bio_clone_mddev(bio, GFP_NOIO, mddev);
1408		md_trim_bio(mbio, r10_bio->sector - bio->bi_sector,
1409			    max_sectors);
1410		r10_bio->devs[i].repl_bio = mbio;
1411
1412		/* We are actively writing to the original device
1413		 * so it cannot disappear, so the replacement cannot
1414		 * become NULL here
1415		 */
1416		mbio->bi_sector	= (r10_bio->devs[i].addr +
1417				   choose_data_offset(
1418					   r10_bio,
1419					   conf->mirrors[d].replacement));
1420		mbio->bi_bdev = conf->mirrors[d].replacement->bdev;
1421		mbio->bi_end_io	= raid10_end_write_request;
1422		mbio->bi_rw = WRITE | do_sync | do_fua;
1423		mbio->bi_private = r10_bio;
1424
1425		atomic_inc(&r10_bio->remaining);
1426		spin_lock_irqsave(&conf->device_lock, flags);
1427		bio_list_add(&conf->pending_bio_list, mbio);
1428		conf->pending_count++;
1429		spin_unlock_irqrestore(&conf->device_lock, flags);
1430		if (!mddev_check_plugged(mddev))
1431			md_wakeup_thread(mddev->thread);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1432	}
 
 
 
 
 
 
 
 
 
1433
1434	/* Don't remove the bias on 'remaining' (one_write_done) until
1435	 * after checking if we need to go around again.
1436	 */
 
 
1437
1438	if (sectors_handled < (bio->bi_size >> 9)) {
1439		one_write_done(r10_bio);
1440		/* We need another r10_bio.  It has already been counted
1441		 * in bio->bi_phys_segments.
1442		 */
1443		r10_bio = mempool_alloc(conf->r10bio_pool, GFP_NOIO);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1444
 
 
 
 
 
 
 
 
1445		r10_bio->master_bio = bio;
1446		r10_bio->sectors = (bio->bi_size >> 9) - sectors_handled;
 
 
 
 
1447
1448		r10_bio->mddev = mddev;
1449		r10_bio->sector = bio->bi_sector + sectors_handled;
1450		r10_bio->state = 0;
1451		goto retry_write;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1452	}
1453	one_write_done(r10_bio);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1454
1455	/* In case raid10d snuck in to freeze_array */
1456	wake_up(&conf->wait_barrier);
 
1457}
1458
1459static void status(struct seq_file *seq, struct mddev *mddev)
1460{
1461	struct r10conf *conf = mddev->private;
1462	int i;
1463
 
 
1464	if (conf->geo.near_copies < conf->geo.raid_disks)
1465		seq_printf(seq, " %dK chunks", mddev->chunk_sectors / 2);
1466	if (conf->geo.near_copies > 1)
1467		seq_printf(seq, " %d near-copies", conf->geo.near_copies);
1468	if (conf->geo.far_copies > 1) {
1469		if (conf->geo.far_offset)
1470			seq_printf(seq, " %d offset-copies", conf->geo.far_copies);
1471		else
1472			seq_printf(seq, " %d far-copies", conf->geo.far_copies);
 
 
1473	}
1474	seq_printf(seq, " [%d/%d] [", conf->geo.raid_disks,
1475					conf->geo.raid_disks - mddev->degraded);
1476	for (i = 0; i < conf->geo.raid_disks; i++)
1477		seq_printf(seq, "%s",
1478			      conf->mirrors[i].rdev &&
1479			      test_bit(In_sync, &conf->mirrors[i].rdev->flags) ? "U" : "_");
 
1480	seq_printf(seq, "]");
1481}
1482
1483/* check if there are enough drives for
1484 * every block to appear on atleast one.
1485 * Don't consider the device numbered 'ignore'
1486 * as we might be about to remove it.
1487 */
1488static int _enough(struct r10conf *conf, struct geom *geo, int ignore)
1489{
1490	int first = 0;
 
 
 
 
 
 
 
 
 
1491
1492	do {
1493		int n = conf->copies;
1494		int cnt = 0;
1495		int this = first;
1496		while (n--) {
1497			if (conf->mirrors[this].rdev &&
1498			    this != ignore)
 
 
1499				cnt++;
1500			this = (this+1) % geo->raid_disks;
1501		}
1502		if (cnt == 0)
1503			return 0;
1504		first = (first + geo->near_copies) % geo->raid_disks;
1505	} while (first != 0);
1506	return 1;
 
 
1507}
1508
1509static int enough(struct r10conf *conf, int ignore)
1510{
1511	return _enough(conf, &conf->geo, ignore) &&
1512		_enough(conf, &conf->prev, ignore);
 
 
 
 
 
1513}
1514
1515static void error(struct mddev *mddev, struct md_rdev *rdev)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1516{
1517	char b[BDEVNAME_SIZE];
1518	struct r10conf *conf = mddev->private;
 
1519
1520	/*
1521	 * If it is not operational, then we have already marked it as dead
1522	 * else if it is the last working disks, ignore the error, let the
1523	 * next level up know.
1524	 * else mark the drive as failed
1525	 */
1526	if (test_bit(In_sync, &rdev->flags)
1527	    && !enough(conf, rdev->raid_disk))
1528		/*
1529		 * Don't fail the drive, just return an IO error.
1530		 */
1531		return;
1532	if (test_and_clear_bit(In_sync, &rdev->flags)) {
1533		unsigned long flags;
1534		spin_lock_irqsave(&conf->device_lock, flags);
1535		mddev->degraded++;
1536		spin_unlock_irqrestore(&conf->device_lock, flags);
1537		/*
1538		 * if recovery is running, make sure it aborts.
1539		 */
1540		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
1541	}
 
 
 
 
1542	set_bit(Blocked, &rdev->flags);
1543	set_bit(Faulty, &rdev->flags);
1544	set_bit(MD_CHANGE_DEVS, &mddev->flags);
1545	printk(KERN_ALERT
1546	       "md/raid10:%s: Disk failure on %s, disabling device.\n"
1547	       "md/raid10:%s: Operation continuing on %d devices.\n",
1548	       mdname(mddev), bdevname(rdev->bdev, b),
1549	       mdname(mddev), conf->geo.raid_disks - mddev->degraded);
 
1550}
1551
1552static void print_conf(struct r10conf *conf)
1553{
1554	int i;
1555	struct mirror_info *tmp;
1556
1557	printk(KERN_DEBUG "RAID10 conf printout:\n");
1558	if (!conf) {
1559		printk(KERN_DEBUG "(!conf)\n");
1560		return;
1561	}
1562	printk(KERN_DEBUG " --- wd:%d rd:%d\n", conf->geo.raid_disks - conf->mddev->degraded,
1563		conf->geo.raid_disks);
1564
 
1565	for (i = 0; i < conf->geo.raid_disks; i++) {
1566		char b[BDEVNAME_SIZE];
1567		tmp = conf->mirrors + i;
1568		if (tmp->rdev)
1569			printk(KERN_DEBUG " disk %d, wo:%d, o:%d, dev:%s\n",
1570				i, !test_bit(In_sync, &tmp->rdev->flags),
1571			        !test_bit(Faulty, &tmp->rdev->flags),
1572				bdevname(tmp->rdev->bdev,b));
1573	}
1574}
1575
1576static void close_sync(struct r10conf *conf)
1577{
1578	wait_barrier(conf);
1579	allow_barrier(conf);
1580
1581	mempool_destroy(conf->r10buf_pool);
1582	conf->r10buf_pool = NULL;
1583}
1584
1585static int raid10_spare_active(struct mddev *mddev)
1586{
1587	int i;
1588	struct r10conf *conf = mddev->private;
1589	struct mirror_info *tmp;
1590	int count = 0;
1591	unsigned long flags;
1592
1593	/*
1594	 * Find all non-in_sync disks within the RAID10 configuration
1595	 * and mark them in_sync
1596	 */
1597	for (i = 0; i < conf->geo.raid_disks; i++) {
1598		tmp = conf->mirrors + i;
1599		if (tmp->replacement
1600		    && tmp->replacement->recovery_offset == MaxSector
1601		    && !test_bit(Faulty, &tmp->replacement->flags)
1602		    && !test_and_set_bit(In_sync, &tmp->replacement->flags)) {
1603			/* Replacement has just become active */
1604			if (!tmp->rdev
1605			    || !test_and_clear_bit(In_sync, &tmp->rdev->flags))
1606				count++;
1607			if (tmp->rdev) {
1608				/* Replaced device not technically faulty,
1609				 * but we need to be sure it gets removed
1610				 * and never re-added.
1611				 */
1612				set_bit(Faulty, &tmp->rdev->flags);
1613				sysfs_notify_dirent_safe(
1614					tmp->rdev->sysfs_state);
1615			}
1616			sysfs_notify_dirent_safe(tmp->replacement->sysfs_state);
1617		} else if (tmp->rdev
 
1618			   && !test_bit(Faulty, &tmp->rdev->flags)
1619			   && !test_and_set_bit(In_sync, &tmp->rdev->flags)) {
1620			count++;
1621			sysfs_notify_dirent(tmp->rdev->sysfs_state);
1622		}
1623	}
1624	spin_lock_irqsave(&conf->device_lock, flags);
1625	mddev->degraded -= count;
1626	spin_unlock_irqrestore(&conf->device_lock, flags);
1627
1628	print_conf(conf);
1629	return count;
1630}
1631
1632
1633static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
1634{
1635	struct r10conf *conf = mddev->private;
1636	int err = -EEXIST;
1637	int mirror;
1638	int first = 0;
1639	int last = conf->geo.raid_disks - 1;
1640	struct request_queue *q = bdev_get_queue(rdev->bdev);
1641
1642	if (mddev->recovery_cp < MaxSector)
1643		/* only hot-add to in-sync arrays, as recovery is
1644		 * very different from resync
1645		 */
1646		return -EBUSY;
1647	if (rdev->saved_raid_disk < 0 && !_enough(conf, &conf->prev, -1))
1648		return -EINVAL;
1649
 
 
 
1650	if (rdev->raid_disk >= 0)
1651		first = last = rdev->raid_disk;
1652
1653	if (q->merge_bvec_fn) {
1654		set_bit(Unmerged, &rdev->flags);
1655		mddev->merge_check_needed = 1;
1656	}
1657
1658	if (rdev->saved_raid_disk >= first &&
 
1659	    conf->mirrors[rdev->saved_raid_disk].rdev == NULL)
1660		mirror = rdev->saved_raid_disk;
1661	else
1662		mirror = first;
1663	for ( ; mirror <= last ; mirror++) {
1664		struct mirror_info *p = &conf->mirrors[mirror];
1665		if (p->recovery_disabled == mddev->recovery_disabled)
1666			continue;
1667		if (p->rdev) {
1668			if (!test_bit(WantReplacement, &p->rdev->flags) ||
1669			    p->replacement != NULL)
1670				continue;
1671			clear_bit(In_sync, &rdev->flags);
1672			set_bit(Replacement, &rdev->flags);
1673			rdev->raid_disk = mirror;
1674			err = 0;
1675			disk_stack_limits(mddev->gendisk, rdev->bdev,
1676					  rdev->data_offset << 9);
1677			conf->fullsync = 1;
1678			rcu_assign_pointer(p->replacement, rdev);
1679			break;
1680		}
1681
1682		disk_stack_limits(mddev->gendisk, rdev->bdev,
1683				  rdev->data_offset << 9);
 
1684
1685		p->head_position = 0;
1686		p->recovery_disabled = mddev->recovery_disabled - 1;
1687		rdev->raid_disk = mirror;
1688		err = 0;
1689		if (rdev->saved_raid_disk != mirror)
1690			conf->fullsync = 1;
1691		rcu_assign_pointer(p->rdev, rdev);
1692		break;
1693	}
1694	if (err == 0 && test_bit(Unmerged, &rdev->flags)) {
1695		/* Some requests might not have seen this new
1696		 * merge_bvec_fn.  We must wait for them to complete
1697		 * before merging the device fully.
1698		 * First we make sure any code which has tested
1699		 * our function has submitted the request, then
1700		 * we wait for all outstanding requests to complete.
1701		 */
1702		synchronize_sched();
1703		raise_barrier(conf, 0);
1704		lower_barrier(conf);
1705		clear_bit(Unmerged, &rdev->flags);
1706	}
1707	md_integrity_add_rdev(rdev, mddev);
1708	print_conf(conf);
1709	return err;
1710}
1711
1712static int raid10_remove_disk(struct mddev *mddev, struct md_rdev *rdev)
1713{
1714	struct r10conf *conf = mddev->private;
1715	int err = 0;
1716	int number = rdev->raid_disk;
1717	struct md_rdev **rdevp;
1718	struct mirror_info *p = conf->mirrors + number;
1719
1720	print_conf(conf);
 
 
 
1721	if (rdev == p->rdev)
1722		rdevp = &p->rdev;
1723	else if (rdev == p->replacement)
1724		rdevp = &p->replacement;
1725	else
1726		return 0;
1727
1728	if (test_bit(In_sync, &rdev->flags) ||
1729	    atomic_read(&rdev->nr_pending)) {
1730		err = -EBUSY;
1731		goto abort;
1732	}
1733	/* Only remove faulty devices if recovery
1734	 * is not possible.
1735	 */
1736	if (!test_bit(Faulty, &rdev->flags) &&
1737	    mddev->recovery_disabled != p->recovery_disabled &&
1738	    (!p->replacement || p->replacement == rdev) &&
1739	    number < conf->geo.raid_disks &&
1740	    enough(conf, -1)) {
1741		err = -EBUSY;
1742		goto abort;
1743	}
1744	*rdevp = NULL;
1745	synchronize_rcu();
1746	if (atomic_read(&rdev->nr_pending)) {
1747		/* lost the race, try later */
1748		err = -EBUSY;
1749		*rdevp = rdev;
1750		goto abort;
1751	} else if (p->replacement) {
1752		/* We must have just cleared 'rdev' */
1753		p->rdev = p->replacement;
1754		clear_bit(Replacement, &p->replacement->flags);
1755		smp_mb(); /* Make sure other CPUs may see both as identical
1756			   * but will never see neither -- if they are careful.
1757			   */
1758		p->replacement = NULL;
1759		clear_bit(WantReplacement, &rdev->flags);
1760	} else
1761		/* We might have just remove the Replacement as faulty
1762		 * Clear the flag just in case
1763		 */
1764		clear_bit(WantReplacement, &rdev->flags);
1765
 
1766	err = md_integrity_register(mddev);
1767
1768abort:
1769
1770	print_conf(conf);
1771	return err;
1772}
1773
1774
1775static void end_sync_read(struct bio *bio, int error)
1776{
1777	struct r10bio *r10_bio = bio->bi_private;
1778	struct r10conf *conf = r10_bio->mddev->private;
1779	int d;
1780
1781	if (bio == r10_bio->master_bio) {
1782		/* this is a reshape read */
1783		d = r10_bio->read_slot; /* really the read dev */
1784	} else
1785		d = find_bio_disk(conf, r10_bio, bio, NULL, NULL);
1786
1787	if (test_bit(BIO_UPTODATE, &bio->bi_flags))
1788		set_bit(R10BIO_Uptodate, &r10_bio->state);
1789	else
1790		/* The write handler will notice the lack of
1791		 * R10BIO_Uptodate and record any errors etc
1792		 */
1793		atomic_add(r10_bio->sectors,
1794			   &conf->mirrors[d].rdev->corrected_errors);
1795
1796	/* for reconstruct, we always reschedule after a read.
1797	 * for resync, only after all reads
1798	 */
1799	rdev_dec_pending(conf->mirrors[d].rdev, conf->mddev);
1800	if (test_bit(R10BIO_IsRecover, &r10_bio->state) ||
1801	    atomic_dec_and_test(&r10_bio->remaining)) {
1802		/* we have read all the blocks,
1803		 * do the comparison in process context in raid10d
1804		 */
1805		reschedule_retry(r10_bio);
1806	}
1807}
1808
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1809static void end_sync_request(struct r10bio *r10_bio)
1810{
1811	struct mddev *mddev = r10_bio->mddev;
1812
1813	while (atomic_dec_and_test(&r10_bio->remaining)) {
1814		if (r10_bio->master_bio == NULL) {
1815			/* the primary of several recovery bios */
1816			sector_t s = r10_bio->sectors;
1817			if (test_bit(R10BIO_MadeGood, &r10_bio->state) ||
1818			    test_bit(R10BIO_WriteError, &r10_bio->state))
1819				reschedule_retry(r10_bio);
1820			else
1821				put_buf(r10_bio);
1822			md_done_sync(mddev, s, 1);
1823			break;
1824		} else {
1825			struct r10bio *r10_bio2 = (struct r10bio *)r10_bio->master_bio;
1826			if (test_bit(R10BIO_MadeGood, &r10_bio->state) ||
1827			    test_bit(R10BIO_WriteError, &r10_bio->state))
1828				reschedule_retry(r10_bio);
1829			else
1830				put_buf(r10_bio);
1831			r10_bio = r10_bio2;
1832		}
1833	}
1834}
1835
1836static void end_sync_write(struct bio *bio, int error)
1837{
1838	int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
1839	struct r10bio *r10_bio = bio->bi_private;
1840	struct mddev *mddev = r10_bio->mddev;
1841	struct r10conf *conf = mddev->private;
1842	int d;
1843	sector_t first_bad;
1844	int bad_sectors;
1845	int slot;
1846	int repl;
1847	struct md_rdev *rdev = NULL;
1848
1849	d = find_bio_disk(conf, r10_bio, bio, &slot, &repl);
1850	if (repl)
1851		rdev = conf->mirrors[d].replacement;
1852	else
1853		rdev = conf->mirrors[d].rdev;
1854
1855	if (!uptodate) {
1856		if (repl)
1857			md_error(mddev, rdev);
1858		else {
1859			set_bit(WriteErrorSeen, &rdev->flags);
1860			if (!test_and_set_bit(WantReplacement, &rdev->flags))
1861				set_bit(MD_RECOVERY_NEEDED,
1862					&rdev->mddev->recovery);
1863			set_bit(R10BIO_WriteError, &r10_bio->state);
1864		}
1865	} else if (is_badblock(rdev,
1866			     r10_bio->devs[slot].addr,
1867			     r10_bio->sectors,
1868			     &first_bad, &bad_sectors))
1869		set_bit(R10BIO_MadeGood, &r10_bio->state);
1870
1871	rdev_dec_pending(rdev, mddev);
1872
1873	end_sync_request(r10_bio);
1874}
1875
1876/*
1877 * Note: sync and recover and handled very differently for raid10
1878 * This code is for resync.
1879 * For resync, we read through virtual addresses and read all blocks.
1880 * If there is any error, we schedule a write.  The lowest numbered
1881 * drive is authoritative.
1882 * However requests come for physical address, so we need to map.
1883 * For every physical address there are raid_disks/copies virtual addresses,
1884 * which is always are least one, but is not necessarly an integer.
1885 * This means that a physical address can span multiple chunks, so we may
1886 * have to submit multiple io requests for a single sync request.
1887 */
1888/*
1889 * We check if all blocks are in-sync and only write to blocks that
1890 * aren't in sync
1891 */
1892static void sync_request_write(struct mddev *mddev, struct r10bio *r10_bio)
1893{
1894	struct r10conf *conf = mddev->private;
1895	int i, first;
1896	struct bio *tbio, *fbio;
1897	int vcnt;
 
1898
1899	atomic_set(&r10_bio->remaining, 1);
1900
1901	/* find the first device with a block */
1902	for (i=0; i<conf->copies; i++)
1903		if (test_bit(BIO_UPTODATE, &r10_bio->devs[i].bio->bi_flags))
1904			break;
1905
1906	if (i == conf->copies)
1907		goto done;
1908
1909	first = i;
1910	fbio = r10_bio->devs[i].bio;
 
 
 
1911
1912	vcnt = (r10_bio->sectors + (PAGE_SIZE >> 9) - 1) >> (PAGE_SHIFT - 9);
1913	/* now find blocks with errors */
1914	for (i=0 ; i < conf->copies ; i++) {
1915		int  j, d;
 
 
1916
1917		tbio = r10_bio->devs[i].bio;
1918
1919		if (tbio->bi_end_io != end_sync_read)
1920			continue;
1921		if (i == first)
1922			continue;
1923		if (test_bit(BIO_UPTODATE, &r10_bio->devs[i].bio->bi_flags)) {
 
 
 
 
1924			/* We know that the bi_io_vec layout is the same for
1925			 * both 'first' and 'i', so we just compare them.
1926			 * All vec entries are PAGE_SIZE;
1927			 */
1928			for (j = 0; j < vcnt; j++)
1929				if (memcmp(page_address(fbio->bi_io_vec[j].bv_page),
1930					   page_address(tbio->bi_io_vec[j].bv_page),
1931					   fbio->bi_io_vec[j].bv_len))
 
 
 
 
1932					break;
 
 
1933			if (j == vcnt)
1934				continue;
1935			mddev->resync_mismatches += r10_bio->sectors;
1936			if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
1937				/* Don't fix anything. */
1938				continue;
 
 
 
 
1939		}
1940		/* Ok, we need to write this bio, either to correct an
1941		 * inconsistency or to correct an unreadable block.
1942		 * First we need to fixup bv_offset, bv_len and
1943		 * bi_vecs, as the read request might have corrupted these
1944		 */
1945		tbio->bi_vcnt = vcnt;
1946		tbio->bi_size = r10_bio->sectors << 9;
1947		tbio->bi_idx = 0;
1948		tbio->bi_phys_segments = 0;
1949		tbio->bi_flags &= ~(BIO_POOL_MASK - 1);
1950		tbio->bi_flags |= 1 << BIO_UPTODATE;
1951		tbio->bi_next = NULL;
1952		tbio->bi_rw = WRITE;
1953		tbio->bi_private = r10_bio;
1954		tbio->bi_sector = r10_bio->devs[i].addr;
1955
1956		for (j=0; j < vcnt ; j++) {
1957			tbio->bi_io_vec[j].bv_offset = 0;
1958			tbio->bi_io_vec[j].bv_len = PAGE_SIZE;
1959
1960			memcpy(page_address(tbio->bi_io_vec[j].bv_page),
1961			       page_address(fbio->bi_io_vec[j].bv_page),
1962			       PAGE_SIZE);
1963		}
1964		tbio->bi_end_io = end_sync_write;
1965
1966		d = r10_bio->devs[i].devnum;
 
1967		atomic_inc(&conf->mirrors[d].rdev->nr_pending);
1968		atomic_inc(&r10_bio->remaining);
1969		md_sync_acct(conf->mirrors[d].rdev->bdev, tbio->bi_size >> 9);
1970
1971		tbio->bi_sector += conf->mirrors[d].rdev->data_offset;
1972		tbio->bi_bdev = conf->mirrors[d].rdev->bdev;
1973		generic_make_request(tbio);
 
1974	}
1975
1976	/* Now write out to any replacement devices
1977	 * that are active
1978	 */
1979	for (i = 0; i < conf->copies; i++) {
1980		int j, d;
1981
1982		tbio = r10_bio->devs[i].repl_bio;
1983		if (!tbio || !tbio->bi_end_io)
1984			continue;
1985		if (r10_bio->devs[i].bio->bi_end_io != end_sync_write
1986		    && r10_bio->devs[i].bio != fbio)
1987			for (j = 0; j < vcnt; j++)
1988				memcpy(page_address(tbio->bi_io_vec[j].bv_page),
1989				       page_address(fbio->bi_io_vec[j].bv_page),
1990				       PAGE_SIZE);
1991		d = r10_bio->devs[i].devnum;
1992		atomic_inc(&r10_bio->remaining);
1993		md_sync_acct(conf->mirrors[d].replacement->bdev,
1994			     tbio->bi_size >> 9);
1995		generic_make_request(tbio);
1996	}
1997
1998done:
1999	if (atomic_dec_and_test(&r10_bio->remaining)) {
2000		md_done_sync(mddev, r10_bio->sectors, 1);
2001		put_buf(r10_bio);
2002	}
2003}
2004
2005/*
2006 * Now for the recovery code.
2007 * Recovery happens across physical sectors.
2008 * We recover all non-is_sync drives by finding the virtual address of
2009 * each, and then choose a working drive that also has that virt address.
2010 * There is a separate r10_bio for each non-in_sync drive.
2011 * Only the first two slots are in use. The first for reading,
2012 * The second for writing.
2013 *
2014 */
2015static void fix_recovery_read_error(struct r10bio *r10_bio)
2016{
2017	/* We got a read error during recovery.
2018	 * We repeat the read in smaller page-sized sections.
2019	 * If a read succeeds, write it to the new device or record
2020	 * a bad block if we cannot.
2021	 * If a read fails, record a bad block on both old and
2022	 * new devices.
2023	 */
2024	struct mddev *mddev = r10_bio->mddev;
2025	struct r10conf *conf = mddev->private;
2026	struct bio *bio = r10_bio->devs[0].bio;
2027	sector_t sect = 0;
2028	int sectors = r10_bio->sectors;
2029	int idx = 0;
2030	int dr = r10_bio->devs[0].devnum;
2031	int dw = r10_bio->devs[1].devnum;
 
2032
2033	while (sectors) {
2034		int s = sectors;
2035		struct md_rdev *rdev;
2036		sector_t addr;
2037		int ok;
2038
2039		if (s > (PAGE_SIZE>>9))
2040			s = PAGE_SIZE >> 9;
2041
2042		rdev = conf->mirrors[dr].rdev;
2043		addr = r10_bio->devs[0].addr + sect,
2044		ok = sync_page_io(rdev,
2045				  addr,
2046				  s << 9,
2047				  bio->bi_io_vec[idx].bv_page,
2048				  READ, false);
2049		if (ok) {
2050			rdev = conf->mirrors[dw].rdev;
2051			addr = r10_bio->devs[1].addr + sect;
2052			ok = sync_page_io(rdev,
2053					  addr,
2054					  s << 9,
2055					  bio->bi_io_vec[idx].bv_page,
2056					  WRITE, false);
2057			if (!ok) {
2058				set_bit(WriteErrorSeen, &rdev->flags);
2059				if (!test_and_set_bit(WantReplacement,
2060						      &rdev->flags))
2061					set_bit(MD_RECOVERY_NEEDED,
2062						&rdev->mddev->recovery);
2063			}
2064		}
2065		if (!ok) {
2066			/* We don't worry if we cannot set a bad block -
2067			 * it really is bad so there is no loss in not
2068			 * recording it yet
2069			 */
2070			rdev_set_badblocks(rdev, addr, s, 0);
2071
2072			if (rdev != conf->mirrors[dw].rdev) {
2073				/* need bad block on destination too */
2074				struct md_rdev *rdev2 = conf->mirrors[dw].rdev;
2075				addr = r10_bio->devs[1].addr + sect;
2076				ok = rdev_set_badblocks(rdev2, addr, s, 0);
2077				if (!ok) {
2078					/* just abort the recovery */
2079					printk(KERN_NOTICE
2080					       "md/raid10:%s: recovery aborted"
2081					       " due to read error\n",
2082					       mdname(mddev));
2083
2084					conf->mirrors[dw].recovery_disabled
2085						= mddev->recovery_disabled;
2086					set_bit(MD_RECOVERY_INTR,
2087						&mddev->recovery);
2088					break;
2089				}
2090			}
2091		}
2092
2093		sectors -= s;
2094		sect += s;
2095		idx++;
2096	}
2097}
2098
2099static void recovery_request_write(struct mddev *mddev, struct r10bio *r10_bio)
2100{
2101	struct r10conf *conf = mddev->private;
2102	int d;
2103	struct bio *wbio, *wbio2;
 
 
 
 
 
 
 
 
2104
2105	if (!test_bit(R10BIO_Uptodate, &r10_bio->state)) {
2106		fix_recovery_read_error(r10_bio);
2107		end_sync_request(r10_bio);
 
 
 
2108		return;
2109	}
2110
2111	/*
2112	 * share the pages with the first bio
2113	 * and submit the write request
2114	 */
2115	d = r10_bio->devs[1].devnum;
2116	wbio = r10_bio->devs[1].bio;
2117	wbio2 = r10_bio->devs[1].repl_bio;
2118	if (wbio->bi_end_io) {
2119		atomic_inc(&conf->mirrors[d].rdev->nr_pending);
2120		md_sync_acct(conf->mirrors[d].rdev->bdev, wbio->bi_size >> 9);
2121		generic_make_request(wbio);
2122	}
2123	if (wbio2 && wbio2->bi_end_io) {
2124		atomic_inc(&conf->mirrors[d].replacement->nr_pending);
2125		md_sync_acct(conf->mirrors[d].replacement->bdev,
2126			     wbio2->bi_size >> 9);
2127		generic_make_request(wbio2);
2128	}
2129}
2130
2131
2132/*
2133 * Used by fix_read_error() to decay the per rdev read_errors.
2134 * We halve the read error count for every hour that has elapsed
2135 * since the last recorded read error.
2136 *
2137 */
2138static void check_decay_read_errors(struct mddev *mddev, struct md_rdev *rdev)
2139{
2140	struct timespec cur_time_mon;
2141	unsigned long hours_since_last;
2142	unsigned int read_errors = atomic_read(&rdev->read_errors);
2143
2144	ktime_get_ts(&cur_time_mon);
2145
2146	if (rdev->last_read_error.tv_sec == 0 &&
2147	    rdev->last_read_error.tv_nsec == 0) {
2148		/* first time we've seen a read error */
2149		rdev->last_read_error = cur_time_mon;
2150		return;
2151	}
2152
2153	hours_since_last = (cur_time_mon.tv_sec -
2154			    rdev->last_read_error.tv_sec) / 3600;
2155
2156	rdev->last_read_error = cur_time_mon;
2157
2158	/*
2159	 * if hours_since_last is > the number of bits in read_errors
2160	 * just set read errors to 0. We do this to avoid
2161	 * overflowing the shift of read_errors by hours_since_last.
2162	 */
2163	if (hours_since_last >= 8 * sizeof(read_errors))
2164		atomic_set(&rdev->read_errors, 0);
2165	else
2166		atomic_set(&rdev->read_errors, read_errors >> hours_since_last);
2167}
2168
2169static int r10_sync_page_io(struct md_rdev *rdev, sector_t sector,
2170			    int sectors, struct page *page, int rw)
2171{
2172	sector_t first_bad;
2173	int bad_sectors;
2174
2175	if (is_badblock(rdev, sector, sectors, &first_bad, &bad_sectors)
2176	    && (rw == READ || test_bit(WriteErrorSeen, &rdev->flags)))
2177		return -1;
2178	if (sync_page_io(rdev, sector, sectors << 9, page, rw, false))
2179		/* success */
2180		return 1;
2181	if (rw == WRITE) {
2182		set_bit(WriteErrorSeen, &rdev->flags);
2183		if (!test_and_set_bit(WantReplacement, &rdev->flags))
2184			set_bit(MD_RECOVERY_NEEDED,
2185				&rdev->mddev->recovery);
2186	}
2187	/* need to record an error - either for the block or the device */
2188	if (!rdev_set_badblocks(rdev, sector, sectors, 0))
2189		md_error(rdev->mddev, rdev);
2190	return 0;
2191}
2192
2193/*
2194 * This is a kernel thread which:
2195 *
2196 *	1.	Retries failed read operations on working mirrors.
2197 *	2.	Updates the raid superblock when problems encounter.
2198 *	3.	Performs writes following reads for array synchronising.
2199 */
2200
2201static void fix_read_error(struct r10conf *conf, struct mddev *mddev, struct r10bio *r10_bio)
2202{
2203	int sect = 0; /* Offset from r10_bio->sector */
2204	int sectors = r10_bio->sectors;
2205	struct md_rdev*rdev;
2206	int max_read_errors = atomic_read(&mddev->max_corr_read_errors);
2207	int d = r10_bio->devs[r10_bio->read_slot].devnum;
2208
2209	/* still own a reference to this rdev, so it cannot
2210	 * have been cleared recently.
2211	 */
2212	rdev = conf->mirrors[d].rdev;
2213
2214	if (test_bit(Faulty, &rdev->flags))
2215		/* drive has already been failed, just ignore any
2216		   more fix_read_error() attempts */
2217		return;
2218
2219	check_decay_read_errors(mddev, rdev);
2220	atomic_inc(&rdev->read_errors);
2221	if (atomic_read(&rdev->read_errors) > max_read_errors) {
2222		char b[BDEVNAME_SIZE];
2223		bdevname(rdev->bdev, b);
2224
2225		printk(KERN_NOTICE
2226		       "md/raid10:%s: %s: Raid device exceeded "
2227		       "read_error threshold [cur %d:max %d]\n",
2228		       mdname(mddev), b,
2229		       atomic_read(&rdev->read_errors), max_read_errors);
2230		printk(KERN_NOTICE
2231		       "md/raid10:%s: %s: Failing raid device\n",
2232		       mdname(mddev), b);
2233		md_error(mddev, conf->mirrors[d].rdev);
2234		r10_bio->devs[r10_bio->read_slot].bio = IO_BLOCKED;
2235		return;
2236	}
2237
2238	while(sectors) {
2239		int s = sectors;
2240		int sl = r10_bio->read_slot;
2241		int success = 0;
2242		int start;
2243
2244		if (s > (PAGE_SIZE>>9))
2245			s = PAGE_SIZE >> 9;
2246
2247		rcu_read_lock();
2248		do {
2249			sector_t first_bad;
2250			int bad_sectors;
2251
2252			d = r10_bio->devs[sl].devnum;
2253			rdev = rcu_dereference(conf->mirrors[d].rdev);
2254			if (rdev &&
2255			    !test_bit(Unmerged, &rdev->flags) &&
2256			    test_bit(In_sync, &rdev->flags) &&
 
2257			    is_badblock(rdev, r10_bio->devs[sl].addr + sect, s,
2258					&first_bad, &bad_sectors) == 0) {
2259				atomic_inc(&rdev->nr_pending);
2260				rcu_read_unlock();
2261				success = sync_page_io(rdev,
2262						       r10_bio->devs[sl].addr +
2263						       sect,
2264						       s<<9,
2265						       conf->tmppage, READ, false);
 
2266				rdev_dec_pending(rdev, mddev);
2267				rcu_read_lock();
2268				if (success)
2269					break;
2270			}
2271			sl++;
2272			if (sl == conf->copies)
2273				sl = 0;
2274		} while (!success && sl != r10_bio->read_slot);
2275		rcu_read_unlock();
2276
2277		if (!success) {
2278			/* Cannot read from anywhere, just mark the block
2279			 * as bad on the first device to discourage future
2280			 * reads.
2281			 */
2282			int dn = r10_bio->devs[r10_bio->read_slot].devnum;
2283			rdev = conf->mirrors[dn].rdev;
2284
2285			if (!rdev_set_badblocks(
2286				    rdev,
2287				    r10_bio->devs[r10_bio->read_slot].addr
2288				    + sect,
2289				    s, 0)) {
2290				md_error(mddev, rdev);
2291				r10_bio->devs[r10_bio->read_slot].bio
2292					= IO_BLOCKED;
2293			}
2294			break;
2295		}
2296
2297		start = sl;
2298		/* write it back and re-read */
2299		rcu_read_lock();
2300		while (sl != r10_bio->read_slot) {
2301			char b[BDEVNAME_SIZE];
2302
2303			if (sl==0)
2304				sl = conf->copies;
2305			sl--;
2306			d = r10_bio->devs[sl].devnum;
2307			rdev = rcu_dereference(conf->mirrors[d].rdev);
2308			if (!rdev ||
2309			    test_bit(Unmerged, &rdev->flags) ||
2310			    !test_bit(In_sync, &rdev->flags))
2311				continue;
2312
2313			atomic_inc(&rdev->nr_pending);
2314			rcu_read_unlock();
2315			if (r10_sync_page_io(rdev,
2316					     r10_bio->devs[sl].addr +
2317					     sect,
2318					     s, conf->tmppage, WRITE)
2319			    == 0) {
2320				/* Well, this device is dead */
2321				printk(KERN_NOTICE
2322				       "md/raid10:%s: read correction "
2323				       "write failed"
2324				       " (%d sectors at %llu on %s)\n",
2325				       mdname(mddev), s,
2326				       (unsigned long long)(
2327					       sect +
2328					       choose_data_offset(r10_bio,
2329								  rdev)),
2330				       bdevname(rdev->bdev, b));
2331				printk(KERN_NOTICE "md/raid10:%s: %s: failing "
2332				       "drive\n",
2333				       mdname(mddev),
2334				       bdevname(rdev->bdev, b));
2335			}
2336			rdev_dec_pending(rdev, mddev);
2337			rcu_read_lock();
2338		}
2339		sl = start;
2340		while (sl != r10_bio->read_slot) {
2341			char b[BDEVNAME_SIZE];
2342
2343			if (sl==0)
2344				sl = conf->copies;
2345			sl--;
2346			d = r10_bio->devs[sl].devnum;
2347			rdev = rcu_dereference(conf->mirrors[d].rdev);
2348			if (!rdev ||
 
2349			    !test_bit(In_sync, &rdev->flags))
2350				continue;
2351
2352			atomic_inc(&rdev->nr_pending);
2353			rcu_read_unlock();
2354			switch (r10_sync_page_io(rdev,
2355					     r10_bio->devs[sl].addr +
2356					     sect,
2357					     s, conf->tmppage,
2358						 READ)) {
2359			case 0:
2360				/* Well, this device is dead */
2361				printk(KERN_NOTICE
2362				       "md/raid10:%s: unable to read back "
2363				       "corrected sectors"
2364				       " (%d sectors at %llu on %s)\n",
2365				       mdname(mddev), s,
2366				       (unsigned long long)(
2367					       sect +
2368					       choose_data_offset(r10_bio, rdev)),
2369				       bdevname(rdev->bdev, b));
2370				printk(KERN_NOTICE "md/raid10:%s: %s: failing "
2371				       "drive\n",
2372				       mdname(mddev),
2373				       bdevname(rdev->bdev, b));
2374				break;
2375			case 1:
2376				printk(KERN_INFO
2377				       "md/raid10:%s: read error corrected"
2378				       " (%d sectors at %llu on %s)\n",
2379				       mdname(mddev), s,
2380				       (unsigned long long)(
2381					       sect +
2382					       choose_data_offset(r10_bio, rdev)),
2383				       bdevname(rdev->bdev, b));
2384				atomic_add(s, &rdev->corrected_errors);
2385			}
2386
2387			rdev_dec_pending(rdev, mddev);
2388			rcu_read_lock();
2389		}
2390		rcu_read_unlock();
2391
2392		sectors -= s;
2393		sect += s;
2394	}
2395}
2396
2397static void bi_complete(struct bio *bio, int error)
2398{
2399	complete((struct completion *)bio->bi_private);
2400}
2401
2402static int submit_bio_wait(int rw, struct bio *bio)
2403{
2404	struct completion event;
2405	rw |= REQ_SYNC;
2406
2407	init_completion(&event);
2408	bio->bi_private = &event;
2409	bio->bi_end_io = bi_complete;
2410	submit_bio(rw, bio);
2411	wait_for_completion(&event);
2412
2413	return test_bit(BIO_UPTODATE, &bio->bi_flags);
2414}
2415
2416static int narrow_write_error(struct r10bio *r10_bio, int i)
2417{
2418	struct bio *bio = r10_bio->master_bio;
2419	struct mddev *mddev = r10_bio->mddev;
2420	struct r10conf *conf = mddev->private;
2421	struct md_rdev *rdev = conf->mirrors[r10_bio->devs[i].devnum].rdev;
2422	/* bio has the data to be written to slot 'i' where
2423	 * we just recently had a write error.
2424	 * We repeatedly clone the bio and trim down to one block,
2425	 * then try the write.  Where the write fails we record
2426	 * a bad block.
2427	 * It is conceivable that the bio doesn't exactly align with
2428	 * blocks.  We must handle this.
2429	 *
2430	 * We currently own a reference to the rdev.
2431	 */
2432
2433	int block_sectors;
2434	sector_t sector;
2435	int sectors;
2436	int sect_to_write = r10_bio->sectors;
2437	int ok = 1;
2438
2439	if (rdev->badblocks.shift < 0)
2440		return 0;
2441
2442	block_sectors = 1 << rdev->badblocks.shift;
 
2443	sector = r10_bio->sector;
2444	sectors = ((r10_bio->sector + block_sectors)
2445		   & ~(sector_t)(block_sectors - 1))
2446		- sector;
2447
2448	while (sect_to_write) {
2449		struct bio *wbio;
 
2450		if (sectors > sect_to_write)
2451			sectors = sect_to_write;
2452		/* Write at 'sector' for 'sectors' */
2453		wbio = bio_clone_mddev(bio, GFP_NOIO, mddev);
2454		md_trim_bio(wbio, sector - bio->bi_sector, sectors);
2455		wbio->bi_sector = (r10_bio->devs[i].addr+
2456				   choose_data_offset(r10_bio, rdev) +
2457				   (sector - r10_bio->sector));
2458		wbio->bi_bdev = rdev->bdev;
2459		if (submit_bio_wait(WRITE, wbio) == 0)
 
 
2460			/* Failure! */
2461			ok = rdev_set_badblocks(rdev, sector,
2462						sectors, 0)
2463				&& ok;
2464
2465		bio_put(wbio);
2466		sect_to_write -= sectors;
2467		sector += sectors;
2468		sectors = block_sectors;
2469	}
2470	return ok;
2471}
2472
2473static void handle_read_error(struct mddev *mddev, struct r10bio *r10_bio)
2474{
2475	int slot = r10_bio->read_slot;
2476	struct bio *bio;
2477	struct r10conf *conf = mddev->private;
2478	struct md_rdev *rdev = r10_bio->devs[slot].rdev;
2479	char b[BDEVNAME_SIZE];
2480	unsigned long do_sync;
2481	int max_sectors;
2482
2483	/* we got a read error. Maybe the drive is bad.  Maybe just
2484	 * the block and we can fix it.
2485	 * We freeze all other IO, and try reading the block from
2486	 * other devices.  When we find one, we re-write
2487	 * and check it that fixes the read error.
2488	 * This is all done synchronously while the array is
2489	 * frozen.
2490	 */
2491	bio = r10_bio->devs[slot].bio;
2492	bdevname(bio->bi_bdev, b);
2493	bio_put(bio);
2494	r10_bio->devs[slot].bio = NULL;
2495
2496	if (mddev->ro == 0) {
2497		freeze_array(conf);
 
 
2498		fix_read_error(conf, mddev, r10_bio);
2499		unfreeze_array(conf);
2500	} else
2501		r10_bio->devs[slot].bio = IO_BLOCKED;
2502
2503	rdev_dec_pending(rdev, mddev);
2504
2505read_more:
2506	rdev = read_balance(conf, r10_bio, &max_sectors);
2507	if (rdev == NULL) {
2508		printk(KERN_ALERT "md/raid10:%s: %s: unrecoverable I/O"
2509		       " read error for block %llu\n",
2510		       mdname(mddev), b,
2511		       (unsigned long long)r10_bio->sector);
2512		raid_end_bio_io(r10_bio);
2513		return;
2514	}
2515
2516	do_sync = (r10_bio->master_bio->bi_rw & REQ_SYNC);
2517	slot = r10_bio->read_slot;
2518	printk_ratelimited(
2519		KERN_ERR
2520		"md/raid10:%s: %s: redirecting "
2521		"sector %llu to another mirror\n",
2522		mdname(mddev),
2523		bdevname(rdev->bdev, b),
2524		(unsigned long long)r10_bio->sector);
2525	bio = bio_clone_mddev(r10_bio->master_bio,
2526			      GFP_NOIO, mddev);
2527	md_trim_bio(bio,
2528		    r10_bio->sector - bio->bi_sector,
2529		    max_sectors);
2530	r10_bio->devs[slot].bio = bio;
2531	r10_bio->devs[slot].rdev = rdev;
2532	bio->bi_sector = r10_bio->devs[slot].addr
2533		+ choose_data_offset(r10_bio, rdev);
2534	bio->bi_bdev = rdev->bdev;
2535	bio->bi_rw = READ | do_sync;
2536	bio->bi_private = r10_bio;
2537	bio->bi_end_io = raid10_end_read_request;
2538	if (max_sectors < r10_bio->sectors) {
2539		/* Drat - have to split this up more */
2540		struct bio *mbio = r10_bio->master_bio;
2541		int sectors_handled =
2542			r10_bio->sector + max_sectors
2543			- mbio->bi_sector;
2544		r10_bio->sectors = max_sectors;
2545		spin_lock_irq(&conf->device_lock);
2546		if (mbio->bi_phys_segments == 0)
2547			mbio->bi_phys_segments = 2;
2548		else
2549			mbio->bi_phys_segments++;
2550		spin_unlock_irq(&conf->device_lock);
2551		generic_make_request(bio);
2552
2553		r10_bio = mempool_alloc(conf->r10bio_pool,
2554					GFP_NOIO);
2555		r10_bio->master_bio = mbio;
2556		r10_bio->sectors = (mbio->bi_size >> 9)
2557			- sectors_handled;
2558		r10_bio->state = 0;
2559		set_bit(R10BIO_ReadError,
2560			&r10_bio->state);
2561		r10_bio->mddev = mddev;
2562		r10_bio->sector = mbio->bi_sector
2563			+ sectors_handled;
2564
2565		goto read_more;
2566	} else
2567		generic_make_request(bio);
2568}
2569
2570static void handle_write_completed(struct r10conf *conf, struct r10bio *r10_bio)
2571{
2572	/* Some sort of write request has finished and it
2573	 * succeeded in writing where we thought there was a
2574	 * bad block.  So forget the bad block.
2575	 * Or possibly if failed and we need to record
2576	 * a bad block.
2577	 */
2578	int m;
2579	struct md_rdev *rdev;
2580
2581	if (test_bit(R10BIO_IsSync, &r10_bio->state) ||
2582	    test_bit(R10BIO_IsRecover, &r10_bio->state)) {
2583		for (m = 0; m < conf->copies; m++) {
2584			int dev = r10_bio->devs[m].devnum;
2585			rdev = conf->mirrors[dev].rdev;
2586			if (r10_bio->devs[m].bio == NULL)
 
2587				continue;
2588			if (test_bit(BIO_UPTODATE,
2589				     &r10_bio->devs[m].bio->bi_flags)) {
2590				rdev_clear_badblocks(
2591					rdev,
2592					r10_bio->devs[m].addr,
2593					r10_bio->sectors, 0);
2594			} else {
2595				if (!rdev_set_badblocks(
2596					    rdev,
2597					    r10_bio->devs[m].addr,
2598					    r10_bio->sectors, 0))
2599					md_error(conf->mddev, rdev);
2600			}
2601			rdev = conf->mirrors[dev].replacement;
2602			if (r10_bio->devs[m].repl_bio == NULL)
 
2603				continue;
2604			if (test_bit(BIO_UPTODATE,
2605				     &r10_bio->devs[m].repl_bio->bi_flags)) {
2606				rdev_clear_badblocks(
2607					rdev,
2608					r10_bio->devs[m].addr,
2609					r10_bio->sectors, 0);
2610			} else {
2611				if (!rdev_set_badblocks(
2612					    rdev,
2613					    r10_bio->devs[m].addr,
2614					    r10_bio->sectors, 0))
2615					md_error(conf->mddev, rdev);
2616			}
2617		}
2618		put_buf(r10_bio);
2619	} else {
 
2620		for (m = 0; m < conf->copies; m++) {
2621			int dev = r10_bio->devs[m].devnum;
2622			struct bio *bio = r10_bio->devs[m].bio;
2623			rdev = conf->mirrors[dev].rdev;
2624			if (bio == IO_MADE_GOOD) {
2625				rdev_clear_badblocks(
2626					rdev,
2627					r10_bio->devs[m].addr,
2628					r10_bio->sectors, 0);
2629				rdev_dec_pending(rdev, conf->mddev);
2630			} else if (bio != NULL &&
2631				   !test_bit(BIO_UPTODATE, &bio->bi_flags)) {
2632				if (!narrow_write_error(r10_bio, m)) {
2633					md_error(conf->mddev, rdev);
2634					set_bit(R10BIO_Degraded,
2635						&r10_bio->state);
2636				}
2637				rdev_dec_pending(rdev, conf->mddev);
2638			}
2639			bio = r10_bio->devs[m].repl_bio;
2640			rdev = conf->mirrors[dev].replacement;
2641			if (rdev && bio == IO_MADE_GOOD) {
2642				rdev_clear_badblocks(
2643					rdev,
2644					r10_bio->devs[m].addr,
2645					r10_bio->sectors, 0);
2646				rdev_dec_pending(rdev, conf->mddev);
2647			}
2648		}
2649		if (test_bit(R10BIO_WriteError,
2650			     &r10_bio->state))
2651			close_write(r10_bio);
2652		raid_end_bio_io(r10_bio);
 
 
 
 
 
 
 
 
 
 
 
 
 
2653	}
2654}
2655
2656static void raid10d(struct mddev *mddev)
2657{
 
2658	struct r10bio *r10_bio;
2659	unsigned long flags;
2660	struct r10conf *conf = mddev->private;
2661	struct list_head *head = &conf->retry_list;
2662	struct blk_plug plug;
2663
2664	md_check_recovery(mddev);
2665
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2666	blk_start_plug(&plug);
2667	for (;;) {
2668
2669		if (atomic_read(&mddev->plug_cnt) == 0)
2670			flush_pending_writes(conf);
2671
2672		spin_lock_irqsave(&conf->device_lock, flags);
2673		if (list_empty(head)) {
2674			spin_unlock_irqrestore(&conf->device_lock, flags);
2675			break;
2676		}
2677		r10_bio = list_entry(head->prev, struct r10bio, retry_list);
2678		list_del(head->prev);
2679		conf->nr_queued--;
2680		spin_unlock_irqrestore(&conf->device_lock, flags);
2681
2682		mddev = r10_bio->mddev;
2683		conf = mddev->private;
2684		if (test_bit(R10BIO_MadeGood, &r10_bio->state) ||
2685		    test_bit(R10BIO_WriteError, &r10_bio->state))
2686			handle_write_completed(conf, r10_bio);
2687		else if (test_bit(R10BIO_IsReshape, &r10_bio->state))
2688			reshape_request_write(mddev, r10_bio);
2689		else if (test_bit(R10BIO_IsSync, &r10_bio->state))
2690			sync_request_write(mddev, r10_bio);
2691		else if (test_bit(R10BIO_IsRecover, &r10_bio->state))
2692			recovery_request_write(mddev, r10_bio);
2693		else if (test_bit(R10BIO_ReadError, &r10_bio->state))
2694			handle_read_error(mddev, r10_bio);
2695		else {
2696			/* just a partial read to be scheduled from a
2697			 * separate context
2698			 */
2699			int slot = r10_bio->read_slot;
2700			generic_make_request(r10_bio->devs[slot].bio);
2701		}
2702
2703		cond_resched();
2704		if (mddev->flags & ~(1<<MD_CHANGE_PENDING))
2705			md_check_recovery(mddev);
2706	}
2707	blk_finish_plug(&plug);
2708}
2709
2710
2711static int init_resync(struct r10conf *conf)
2712{
2713	int buffs;
2714	int i;
2715
2716	buffs = RESYNC_WINDOW / RESYNC_BLOCK_SIZE;
2717	BUG_ON(conf->r10buf_pool);
2718	conf->have_replacement = 0;
2719	for (i = 0; i < conf->geo.raid_disks; i++)
2720		if (conf->mirrors[i].replacement)
2721			conf->have_replacement = 1;
2722	conf->r10buf_pool = mempool_create(buffs, r10buf_pool_alloc, r10buf_pool_free, conf);
2723	if (!conf->r10buf_pool)
2724		return -ENOMEM;
 
2725	conf->next_resync = 0;
2726	return 0;
2727}
2728
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2729/*
2730 * perform a "sync" on one "block"
2731 *
2732 * We need to make sure that no normal I/O request - particularly write
2733 * requests - conflict with active sync requests.
2734 *
2735 * This is achieved by tracking pending requests and a 'barrier' concept
2736 * that can be installed to exclude normal IO requests.
2737 *
2738 * Resync and recovery are handled very differently.
2739 * We differentiate by looking at MD_RECOVERY_SYNC in mddev->recovery.
2740 *
2741 * For resync, we iterate over virtual addresses, read all copies,
2742 * and update if there are differences.  If only one copy is live,
2743 * skip it.
2744 * For recovery, we iterate over physical addresses, read a good
2745 * value for each non-in_sync drive, and over-write.
2746 *
2747 * So, for recovery we may have several outstanding complex requests for a
2748 * given address, one for each out-of-sync device.  We model this by allocating
2749 * a number of r10_bio structures, one for each out-of-sync device.
2750 * As we setup these structures, we collect all bio's together into a list
2751 * which we then process collectively to add pages, and then process again
2752 * to pass to generic_make_request.
2753 *
2754 * The r10_bio structures are linked using a borrowed master_bio pointer.
2755 * This link is counted in ->remaining.  When the r10_bio that points to NULL
2756 * has its remaining count decremented to 0, the whole complex operation
2757 * is complete.
2758 *
2759 */
2760
2761static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
2762			     int *skipped, int go_faster)
2763{
2764	struct r10conf *conf = mddev->private;
2765	struct r10bio *r10_bio;
2766	struct bio *biolist = NULL, *bio;
2767	sector_t max_sector, nr_sectors;
2768	int i;
2769	int max_sync;
2770	sector_t sync_blocks;
2771	sector_t sectors_skipped = 0;
2772	int chunks_skipped = 0;
2773	sector_t chunk_mask = conf->geo.chunk_mask;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2774
2775	if (!conf->r10buf_pool)
2776		if (init_resync(conf))
2777			return 0;
2778
2779 skipped:
2780	max_sector = mddev->dev_sectors;
2781	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
2782	    test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
2783		max_sector = mddev->resync_max_sectors;
2784	if (sector_nr >= max_sector) {
 
 
 
2785		/* If we aborted, we need to abort the
2786		 * sync on the 'current' bitmap chucks (there can
2787		 * be several when recovering multiple devices).
2788		 * as we may have started syncing it but not finished.
2789		 * We can find the current address in
2790		 * mddev->curr_resync, but for recovery,
2791		 * we need to convert that to several
2792		 * virtual addresses.
2793		 */
2794		if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
2795			end_reshape(conf);
 
2796			return 0;
2797		}
2798
2799		if (mddev->curr_resync < max_sector) { /* aborted */
2800			if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
2801				bitmap_end_sync(mddev->bitmap, mddev->curr_resync,
2802						&sync_blocks, 1);
2803			else for (i = 0; i < conf->geo.raid_disks; i++) {
2804				sector_t sect =
2805					raid10_find_virt(conf, mddev->curr_resync, i);
2806				bitmap_end_sync(mddev->bitmap, sect,
2807						&sync_blocks, 1);
2808			}
2809		} else {
2810			/* completed sync */
2811			if ((!mddev->bitmap || conf->fullsync)
2812			    && conf->have_replacement
2813			    && test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
2814				/* Completed a full sync so the replacements
2815				 * are now fully recovered.
2816				 */
2817				for (i = 0; i < conf->geo.raid_disks; i++)
2818					if (conf->mirrors[i].replacement)
2819						conf->mirrors[i].replacement
2820							->recovery_offset
2821							= MaxSector;
 
 
2822			}
2823			conf->fullsync = 0;
2824		}
2825		bitmap_close_sync(mddev->bitmap);
2826		close_sync(conf);
2827		*skipped = 1;
2828		return sectors_skipped;
2829	}
2830
2831	if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
2832		return reshape_request(mddev, sector_nr, skipped);
2833
2834	if (chunks_skipped >= conf->geo.raid_disks) {
2835		/* if there has been nothing to do on any drive,
2836		 * then there is nothing to do at all..
 
 
 
 
 
 
 
 
 
 
 
 
 
2837		 */
2838		*skipped = 1;
2839		return (max_sector - sector_nr) + sectors_skipped;
2840	}
2841
2842	if (max_sector > mddev->resync_max)
2843		max_sector = mddev->resync_max; /* Don't do IO beyond here */
2844
2845	/* make sure whole request will fit in a chunk - if chunks
2846	 * are meaningful
2847	 */
2848	if (conf->geo.near_copies < conf->geo.raid_disks &&
2849	    max_sector > (sector_nr | chunk_mask))
2850		max_sector = (sector_nr | chunk_mask) + 1;
 
2851	/*
2852	 * If there is non-resync activity waiting for us then
2853	 * put in a delay to throttle resync.
2854	 */
2855	if (!go_faster && conf->nr_waiting)
2856		msleep_interruptible(1000);
2857
2858	/* Again, very different code for resync and recovery.
2859	 * Both must result in an r10bio with a list of bios that
2860	 * have bi_end_io, bi_sector, bi_bdev set,
2861	 * and bi_private set to the r10bio.
2862	 * For recovery, we may actually create several r10bios
2863	 * with 2 bios in each, that correspond to the bios in the main one.
2864	 * In this case, the subordinate r10bios link back through a
2865	 * borrowed master_bio pointer, and the counter in the master
2866	 * includes a ref from each subordinate.
2867	 */
2868	/* First, we decide what to do and set ->bi_end_io
2869	 * To end_sync_read if we want to read, and
2870	 * end_sync_write if we will want to write.
2871	 */
2872
2873	max_sync = RESYNC_PAGES << (PAGE_SHIFT-9);
2874	if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
2875		/* recovery... the complicated one */
2876		int j;
2877		r10_bio = NULL;
2878
2879		for (i = 0 ; i < conf->geo.raid_disks; i++) {
2880			int still_degraded;
2881			struct r10bio *rb2;
2882			sector_t sect;
2883			int must_sync;
2884			int any_working;
2885			struct mirror_info *mirror = &conf->mirrors[i];
 
 
 
 
2886
2887			if ((mirror->rdev == NULL ||
2888			     test_bit(In_sync, &mirror->rdev->flags))
2889			    &&
2890			    (mirror->replacement == NULL ||
2891			     test_bit(Faulty,
2892				      &mirror->replacement->flags)))
 
2893				continue;
2894
2895			still_degraded = 0;
2896			/* want to reconstruct this device */
2897			rb2 = r10_bio;
2898			sect = raid10_find_virt(conf, sector_nr, i);
2899			if (sect >= mddev->resync_max_sectors) {
2900				/* last stripe is not complete - don't
2901				 * try to recover this sector.
2902				 */
2903				continue;
2904			}
2905			/* Unless we are doing a full sync, or a replacement
2906			 * we only need to recover the block if it is set in
2907			 * the bitmap
2908			 */
2909			must_sync = bitmap_start_sync(mddev->bitmap, sect,
2910						      &sync_blocks, 1);
2911			if (sync_blocks < max_sync)
2912				max_sync = sync_blocks;
2913			if (!must_sync &&
2914			    mirror->replacement == NULL &&
2915			    !conf->fullsync) {
2916				/* yep, skip the sync_blocks here, but don't assume
2917				 * that there will never be anything to do here
2918				 */
2919				chunks_skipped = -1;
2920				continue;
2921			}
 
 
 
 
2922
2923			r10_bio = mempool_alloc(conf->r10buf_pool, GFP_NOIO);
 
2924			raise_barrier(conf, rb2 != NULL);
2925			atomic_set(&r10_bio->remaining, 0);
2926
2927			r10_bio->master_bio = (struct bio*)rb2;
2928			if (rb2)
2929				atomic_inc(&rb2->remaining);
2930			r10_bio->mddev = mddev;
2931			set_bit(R10BIO_IsRecover, &r10_bio->state);
2932			r10_bio->sector = sect;
2933
2934			raid10_find_phys(conf, r10_bio);
2935
2936			/* Need to check if the array will still be
2937			 * degraded
2938			 */
2939			for (j = 0; j < conf->geo.raid_disks; j++)
2940				if (conf->mirrors[j].rdev == NULL ||
2941				    test_bit(Faulty, &conf->mirrors[j].rdev->flags)) {
 
2942					still_degraded = 1;
2943					break;
2944				}
 
2945
2946			must_sync = bitmap_start_sync(mddev->bitmap, sect,
2947						      &sync_blocks, still_degraded);
2948
2949			any_working = 0;
2950			for (j=0; j<conf->copies;j++) {
2951				int k;
2952				int d = r10_bio->devs[j].devnum;
2953				sector_t from_addr, to_addr;
2954				struct md_rdev *rdev;
2955				sector_t sector, first_bad;
2956				int bad_sectors;
2957				if (!conf->mirrors[d].rdev ||
2958				    !test_bit(In_sync, &conf->mirrors[d].rdev->flags))
2959					continue;
2960				/* This is where we read from */
2961				any_working = 1;
2962				rdev = conf->mirrors[d].rdev;
2963				sector = r10_bio->devs[j].addr;
2964
2965				if (is_badblock(rdev, sector, max_sync,
2966						&first_bad, &bad_sectors)) {
2967					if (first_bad > sector)
2968						max_sync = first_bad - sector;
2969					else {
2970						bad_sectors -= (sector
2971								- first_bad);
2972						if (max_sync > bad_sectors)
2973							max_sync = bad_sectors;
2974						continue;
2975					}
2976				}
2977				bio = r10_bio->devs[0].bio;
2978				bio->bi_next = biolist;
2979				biolist = bio;
2980				bio->bi_private = r10_bio;
2981				bio->bi_end_io = end_sync_read;
2982				bio->bi_rw = READ;
 
 
2983				from_addr = r10_bio->devs[j].addr;
2984				bio->bi_sector = from_addr + rdev->data_offset;
2985				bio->bi_bdev = rdev->bdev;
 
2986				atomic_inc(&rdev->nr_pending);
2987				/* and we write to 'i' (if not in_sync) */
2988
2989				for (k=0; k<conf->copies; k++)
2990					if (r10_bio->devs[k].devnum == i)
2991						break;
2992				BUG_ON(k == conf->copies);
2993				to_addr = r10_bio->devs[k].addr;
2994				r10_bio->devs[0].devnum = d;
2995				r10_bio->devs[0].addr = from_addr;
2996				r10_bio->devs[1].devnum = i;
2997				r10_bio->devs[1].addr = to_addr;
2998
2999				rdev = mirror->rdev;
3000				if (!test_bit(In_sync, &rdev->flags)) {
3001					bio = r10_bio->devs[1].bio;
3002					bio->bi_next = biolist;
3003					biolist = bio;
3004					bio->bi_private = r10_bio;
3005					bio->bi_end_io = end_sync_write;
3006					bio->bi_rw = WRITE;
3007					bio->bi_sector = to_addr
3008						+ rdev->data_offset;
3009					bio->bi_bdev = rdev->bdev;
3010					atomic_inc(&r10_bio->remaining);
3011				} else
3012					r10_bio->devs[1].bio->bi_end_io = NULL;
3013
3014				/* and maybe write to replacement */
3015				bio = r10_bio->devs[1].repl_bio;
3016				if (bio)
3017					bio->bi_end_io = NULL;
3018				rdev = mirror->replacement;
3019				/* Note: if rdev != NULL, then bio
3020				 * cannot be NULL as r10buf_pool_alloc will
3021				 * have allocated it.
3022				 * So the second test here is pointless.
3023				 * But it keeps semantic-checkers happy, and
3024				 * this comment keeps human reviewers
3025				 * happy.
3026				 */
3027				if (rdev == NULL || bio == NULL ||
3028				    test_bit(Faulty, &rdev->flags))
3029					break;
3030				bio->bi_next = biolist;
3031				biolist = bio;
3032				bio->bi_private = r10_bio;
3033				bio->bi_end_io = end_sync_write;
3034				bio->bi_rw = WRITE;
3035				bio->bi_sector = to_addr + rdev->data_offset;
3036				bio->bi_bdev = rdev->bdev;
 
3037				atomic_inc(&r10_bio->remaining);
3038				break;
3039			}
3040			if (j == conf->copies) {
3041				/* Cannot recover, so abort the recovery or
3042				 * record a bad block */
3043				put_buf(r10_bio);
3044				if (rb2)
3045					atomic_dec(&rb2->remaining);
3046				r10_bio = rb2;
3047				if (any_working) {
3048					/* problem is that there are bad blocks
3049					 * on other device(s)
3050					 */
3051					int k;
3052					for (k = 0; k < conf->copies; k++)
3053						if (r10_bio->devs[k].devnum == i)
3054							break;
3055					if (!test_bit(In_sync,
3056						      &mirror->rdev->flags)
3057					    && !rdev_set_badblocks(
3058						    mirror->rdev,
3059						    r10_bio->devs[k].addr,
3060						    max_sync, 0))
3061						any_working = 0;
3062					if (mirror->replacement &&
3063					    !rdev_set_badblocks(
3064						    mirror->replacement,
3065						    r10_bio->devs[k].addr,
3066						    max_sync, 0))
3067						any_working = 0;
3068				}
3069				if (!any_working)  {
3070					if (!test_and_set_bit(MD_RECOVERY_INTR,
3071							      &mddev->recovery))
3072						printk(KERN_INFO "md/raid10:%s: insufficient "
3073						       "working devices for recovery.\n",
3074						       mdname(mddev));
3075					mirror->recovery_disabled
3076						= mddev->recovery_disabled;
 
 
3077				}
 
 
 
 
 
 
 
 
3078				break;
3079			}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3080		}
3081		if (biolist == NULL) {
3082			while (r10_bio) {
3083				struct r10bio *rb2 = r10_bio;
3084				r10_bio = (struct r10bio*) rb2->master_bio;
3085				rb2->master_bio = NULL;
3086				put_buf(rb2);
3087			}
3088			goto giveup;
3089		}
3090	} else {
3091		/* resync. Schedule a read for every block at this virt offset */
3092		int count = 0;
3093
3094		bitmap_cond_end_sync(mddev->bitmap, sector_nr);
 
 
 
 
 
 
 
 
 
3095
3096		if (!bitmap_start_sync(mddev->bitmap, sector_nr,
3097				       &sync_blocks, mddev->degraded) &&
3098		    !conf->fullsync && !test_bit(MD_RECOVERY_REQUESTED,
3099						 &mddev->recovery)) {
3100			/* We can skip this block */
3101			*skipped = 1;
3102			return sync_blocks + sectors_skipped;
3103		}
3104		if (sync_blocks < max_sync)
3105			max_sync = sync_blocks;
3106		r10_bio = mempool_alloc(conf->r10buf_pool, GFP_NOIO);
 
3107
3108		r10_bio->mddev = mddev;
3109		atomic_set(&r10_bio->remaining, 0);
3110		raise_barrier(conf, 0);
3111		conf->next_resync = sector_nr;
3112
3113		r10_bio->master_bio = NULL;
3114		r10_bio->sector = sector_nr;
3115		set_bit(R10BIO_IsSync, &r10_bio->state);
3116		raid10_find_phys(conf, r10_bio);
3117		r10_bio->sectors = (sector_nr | chunk_mask) - sector_nr + 1;
3118
3119		for (i = 0; i < conf->copies; i++) {
3120			int d = r10_bio->devs[i].devnum;
3121			sector_t first_bad, sector;
3122			int bad_sectors;
 
3123
3124			if (r10_bio->devs[i].repl_bio)
3125				r10_bio->devs[i].repl_bio->bi_end_io = NULL;
3126
3127			bio = r10_bio->devs[i].bio;
3128			bio->bi_end_io = NULL;
3129			clear_bit(BIO_UPTODATE, &bio->bi_flags);
3130			if (conf->mirrors[d].rdev == NULL ||
3131			    test_bit(Faulty, &conf->mirrors[d].rdev->flags))
3132				continue;
 
3133			sector = r10_bio->devs[i].addr;
3134			if (is_badblock(conf->mirrors[d].rdev,
3135					sector, max_sync,
3136					&first_bad, &bad_sectors)) {
3137				if (first_bad > sector)
3138					max_sync = first_bad - sector;
3139				else {
3140					bad_sectors -= (sector - first_bad);
3141					if (max_sync > bad_sectors)
3142						max_sync = max_sync;
3143					continue;
3144				}
3145			}
3146			atomic_inc(&conf->mirrors[d].rdev->nr_pending);
3147			atomic_inc(&r10_bio->remaining);
3148			bio->bi_next = biolist;
3149			biolist = bio;
3150			bio->bi_private = r10_bio;
3151			bio->bi_end_io = end_sync_read;
3152			bio->bi_rw = READ;
3153			bio->bi_sector = sector +
3154				conf->mirrors[d].rdev->data_offset;
3155			bio->bi_bdev = conf->mirrors[d].rdev->bdev;
 
3156			count++;
3157
3158			if (conf->mirrors[d].replacement == NULL ||
3159			    test_bit(Faulty,
3160				     &conf->mirrors[d].replacement->flags))
3161				continue;
3162
 
 
3163			/* Need to set up for writing to the replacement */
3164			bio = r10_bio->devs[i].repl_bio;
3165			clear_bit(BIO_UPTODATE, &bio->bi_flags);
3166
3167			sector = r10_bio->devs[i].addr;
3168			atomic_inc(&conf->mirrors[d].rdev->nr_pending);
3169			bio->bi_next = biolist;
3170			biolist = bio;
3171			bio->bi_private = r10_bio;
3172			bio->bi_end_io = end_sync_write;
3173			bio->bi_rw = WRITE;
3174			bio->bi_sector = sector +
3175				conf->mirrors[d].replacement->data_offset;
3176			bio->bi_bdev = conf->mirrors[d].replacement->bdev;
 
3177			count++;
3178		}
3179
3180		if (count < 2) {
3181			for (i=0; i<conf->copies; i++) {
3182				int d = r10_bio->devs[i].devnum;
3183				if (r10_bio->devs[i].bio->bi_end_io)
3184					rdev_dec_pending(conf->mirrors[d].rdev,
3185							 mddev);
3186				if (r10_bio->devs[i].repl_bio &&
3187				    r10_bio->devs[i].repl_bio->bi_end_io)
3188					rdev_dec_pending(
3189						conf->mirrors[d].replacement,
3190						mddev);
3191			}
3192			put_buf(r10_bio);
3193			biolist = NULL;
3194			goto giveup;
3195		}
3196	}
3197
3198	for (bio = biolist; bio ; bio=bio->bi_next) {
3199
3200		bio->bi_flags &= ~(BIO_POOL_MASK - 1);
3201		if (bio->bi_end_io)
3202			bio->bi_flags |= 1 << BIO_UPTODATE;
3203		bio->bi_vcnt = 0;
3204		bio->bi_idx = 0;
3205		bio->bi_phys_segments = 0;
3206		bio->bi_size = 0;
3207	}
3208
3209	nr_sectors = 0;
3210	if (sector_nr + max_sync < max_sector)
3211		max_sector = sector_nr + max_sync;
3212	do {
3213		struct page *page;
3214		int len = PAGE_SIZE;
3215		if (sector_nr + (len>>9) > max_sector)
3216			len = (max_sector - sector_nr) << 9;
3217		if (len == 0)
3218			break;
3219		for (bio= biolist ; bio ; bio=bio->bi_next) {
3220			struct bio *bio2;
3221			page = bio->bi_io_vec[bio->bi_vcnt].bv_page;
3222			if (bio_add_page(bio, page, len, 0))
3223				continue;
3224
3225			/* stop here */
3226			bio->bi_io_vec[bio->bi_vcnt].bv_page = page;
3227			for (bio2 = biolist;
3228			     bio2 && bio2 != bio;
3229			     bio2 = bio2->bi_next) {
3230				/* remove last page from this bio */
3231				bio2->bi_vcnt--;
3232				bio2->bi_size -= len;
3233				bio2->bi_flags &= ~(1<< BIO_SEG_VALID);
3234			}
3235			goto bio_full;
3236		}
3237		nr_sectors += len>>9;
3238		sector_nr += len>>9;
3239	} while (biolist->bi_vcnt < RESYNC_PAGES);
3240 bio_full:
3241	r10_bio->sectors = nr_sectors;
3242
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3243	while (biolist) {
3244		bio = biolist;
3245		biolist = biolist->bi_next;
3246
3247		bio->bi_next = NULL;
3248		r10_bio = bio->bi_private;
3249		r10_bio->sectors = nr_sectors;
3250
3251		if (bio->bi_end_io == end_sync_read) {
3252			md_sync_acct(bio->bi_bdev, nr_sectors);
3253			generic_make_request(bio);
 
3254		}
3255	}
3256
3257	if (sectors_skipped)
3258		/* pretend they weren't skipped, it makes
3259		 * no important difference in this case
3260		 */
3261		md_done_sync(mddev, sectors_skipped, 1);
3262
3263	return sectors_skipped + nr_sectors;
3264 giveup:
3265	/* There is nowhere to write, so all non-sync
3266	 * drives must be failed or in resync, all drives
3267	 * have a bad block, so try the next chunk...
3268	 */
3269	if (sector_nr + max_sync < max_sector)
3270		max_sector = sector_nr + max_sync;
3271
3272	sectors_skipped += (max_sector - sector_nr);
3273	chunks_skipped ++;
3274	sector_nr = max_sector;
3275	goto skipped;
3276}
3277
3278static sector_t
3279raid10_size(struct mddev *mddev, sector_t sectors, int raid_disks)
3280{
3281	sector_t size;
3282	struct r10conf *conf = mddev->private;
3283
3284	if (!raid_disks)
3285		raid_disks = min(conf->geo.raid_disks,
3286				 conf->prev.raid_disks);
3287	if (!sectors)
3288		sectors = conf->dev_sectors;
3289
3290	size = sectors >> conf->geo.chunk_shift;
3291	sector_div(size, conf->geo.far_copies);
3292	size = size * raid_disks;
3293	sector_div(size, conf->geo.near_copies);
3294
3295	return size << conf->geo.chunk_shift;
3296}
3297
3298static void calc_sectors(struct r10conf *conf, sector_t size)
3299{
3300	/* Calculate the number of sectors-per-device that will
3301	 * actually be used, and set conf->dev_sectors and
3302	 * conf->stride
3303	 */
3304
3305	size = size >> conf->geo.chunk_shift;
3306	sector_div(size, conf->geo.far_copies);
3307	size = size * conf->geo.raid_disks;
3308	sector_div(size, conf->geo.near_copies);
3309	/* 'size' is now the number of chunks in the array */
3310	/* calculate "used chunks per device" */
3311	size = size * conf->copies;
3312
3313	/* We need to round up when dividing by raid_disks to
3314	 * get the stride size.
3315	 */
3316	size = DIV_ROUND_UP_SECTOR_T(size, conf->geo.raid_disks);
3317
3318	conf->dev_sectors = size << conf->geo.chunk_shift;
3319
3320	if (conf->geo.far_offset)
3321		conf->geo.stride = 1 << conf->geo.chunk_shift;
3322	else {
3323		sector_div(size, conf->geo.far_copies);
3324		conf->geo.stride = size << conf->geo.chunk_shift;
3325	}
3326}
3327
3328enum geo_type {geo_new, geo_old, geo_start};
3329static int setup_geo(struct geom *geo, struct mddev *mddev, enum geo_type new)
3330{
3331	int nc, fc, fo;
3332	int layout, chunk, disks;
3333	switch (new) {
3334	case geo_old:
3335		layout = mddev->layout;
3336		chunk = mddev->chunk_sectors;
3337		disks = mddev->raid_disks - mddev->delta_disks;
3338		break;
3339	case geo_new:
3340		layout = mddev->new_layout;
3341		chunk = mddev->new_chunk_sectors;
3342		disks = mddev->raid_disks;
3343		break;
3344	default: /* avoid 'may be unused' warnings */
3345	case geo_start: /* new when starting reshape - raid_disks not
3346			 * updated yet. */
3347		layout = mddev->new_layout;
3348		chunk = mddev->new_chunk_sectors;
3349		disks = mddev->raid_disks + mddev->delta_disks;
3350		break;
3351	}
3352	if (layout >> 17)
3353		return -1;
3354	if (chunk < (PAGE_SIZE >> 9) ||
3355	    !is_power_of_2(chunk))
3356		return -2;
3357	nc = layout & 255;
3358	fc = (layout >> 8) & 255;
3359	fo = layout & (1<<16);
3360	geo->raid_disks = disks;
3361	geo->near_copies = nc;
3362	geo->far_copies = fc;
3363	geo->far_offset = fo;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3364	geo->chunk_mask = chunk - 1;
3365	geo->chunk_shift = ffz(~chunk);
3366	return nc*fc;
3367}
3368
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3369static struct r10conf *setup_conf(struct mddev *mddev)
3370{
3371	struct r10conf *conf = NULL;
3372	int err = -EINVAL;
3373	struct geom geo;
3374	int copies;
3375
3376	copies = setup_geo(&geo, mddev, geo_new);
3377
3378	if (copies == -2) {
3379		printk(KERN_ERR "md/raid10:%s: chunk size must be "
3380		       "at least PAGE_SIZE(%ld) and be a power of 2.\n",
3381		       mdname(mddev), PAGE_SIZE);
3382		goto out;
3383	}
3384
3385	if (copies < 2 || copies > mddev->raid_disks) {
3386		printk(KERN_ERR "md/raid10:%s: unsupported raid10 layout: 0x%8x\n",
3387		       mdname(mddev), mddev->new_layout);
3388		goto out;
3389	}
3390
3391	err = -ENOMEM;
3392	conf = kzalloc(sizeof(struct r10conf), GFP_KERNEL);
3393	if (!conf)
3394		goto out;
3395
3396	/* FIXME calc properly */
3397	conf->mirrors = kzalloc(sizeof(struct mirror_info)*(mddev->raid_disks +
3398							    max(0,mddev->delta_disks)),
3399				GFP_KERNEL);
3400	if (!conf->mirrors)
3401		goto out;
3402
3403	conf->tmppage = alloc_page(GFP_KERNEL);
3404	if (!conf->tmppage)
3405		goto out;
3406
3407	conf->geo = geo;
3408	conf->copies = copies;
3409	conf->r10bio_pool = mempool_create(NR_RAID10_BIOS, r10bio_pool_alloc,
3410					   r10bio_pool_free, conf);
3411	if (!conf->r10bio_pool)
 
 
 
 
3412		goto out;
3413
3414	calc_sectors(conf, mddev->dev_sectors);
3415	if (mddev->reshape_position == MaxSector) {
3416		conf->prev = conf->geo;
3417		conf->reshape_progress = MaxSector;
3418	} else {
3419		if (setup_geo(&conf->prev, mddev, geo_old) != conf->copies) {
3420			err = -EINVAL;
3421			goto out;
3422		}
3423		conf->reshape_progress = mddev->reshape_position;
3424		if (conf->prev.far_offset)
3425			conf->prev.stride = 1 << conf->prev.chunk_shift;
3426		else
3427			/* far_copies must be 1 */
3428			conf->prev.stride = conf->dev_sectors;
3429	}
 
3430	spin_lock_init(&conf->device_lock);
3431	INIT_LIST_HEAD(&conf->retry_list);
 
3432
3433	spin_lock_init(&conf->resync_lock);
3434	init_waitqueue_head(&conf->wait_barrier);
 
3435
3436	conf->thread = md_register_thread(raid10d, mddev, "raid10");
 
 
3437	if (!conf->thread)
3438		goto out;
3439
3440	conf->mddev = mddev;
3441	return conf;
3442
3443 out:
3444	if (err == -ENOMEM)
3445		printk(KERN_ERR "md/raid10:%s: couldn't allocate memory.\n",
3446		       mdname(mddev));
3447	if (conf) {
3448		if (conf->r10bio_pool)
3449			mempool_destroy(conf->r10bio_pool);
3450		kfree(conf->mirrors);
3451		safe_put_page(conf->tmppage);
3452		kfree(conf);
3453	}
3454	return ERR_PTR(err);
3455}
3456
3457static int run(struct mddev *mddev)
 
 
 
 
 
 
 
 
 
 
3458{
3459	struct r10conf *conf;
3460	int i, disk_idx, chunk_size;
3461	struct mirror_info *disk;
3462	struct md_rdev *rdev;
3463	sector_t size;
3464	sector_t min_offset_diff = 0;
3465	int first = 1;
3466
3467	if (mddev->private == NULL) {
3468		conf = setup_conf(mddev);
3469		if (IS_ERR(conf))
3470			return PTR_ERR(conf);
3471		mddev->private = conf;
3472	}
3473	conf = mddev->private;
3474	if (!conf)
3475		goto out;
3476
3477	mddev->thread = conf->thread;
3478	conf->thread = NULL;
3479
3480	chunk_size = mddev->chunk_sectors << 9;
3481	blk_queue_io_min(mddev->queue, chunk_size);
3482	if (conf->geo.raid_disks % conf->geo.near_copies)
3483		blk_queue_io_opt(mddev->queue, chunk_size * conf->geo.raid_disks);
3484	else
3485		blk_queue_io_opt(mddev->queue, chunk_size *
3486				 (conf->geo.raid_disks / conf->geo.near_copies));
 
 
 
 
 
 
 
 
 
 
3487
3488	rdev_for_each(rdev, mddev) {
3489		long long diff;
3490		struct request_queue *q;
3491
3492		disk_idx = rdev->raid_disk;
3493		if (disk_idx < 0)
3494			continue;
3495		if (disk_idx >= conf->geo.raid_disks &&
3496		    disk_idx >= conf->prev.raid_disks)
3497			continue;
3498		disk = conf->mirrors + disk_idx;
3499
3500		if (test_bit(Replacement, &rdev->flags)) {
3501			if (disk->replacement)
3502				goto out_free_conf;
3503			disk->replacement = rdev;
3504		} else {
3505			if (disk->rdev)
3506				goto out_free_conf;
3507			disk->rdev = rdev;
3508		}
3509		q = bdev_get_queue(rdev->bdev);
3510		if (q->merge_bvec_fn)
3511			mddev->merge_check_needed = 1;
3512		diff = (rdev->new_data_offset - rdev->data_offset);
3513		if (!mddev->reshape_backwards)
3514			diff = -diff;
3515		if (diff < 0)
3516			diff = 0;
3517		if (first || diff < min_offset_diff)
3518			min_offset_diff = diff;
3519
3520		disk_stack_limits(mddev->gendisk, rdev->bdev,
3521				  rdev->data_offset << 9);
 
3522
3523		disk->head_position = 0;
 
3524	}
3525
3526	/* need to check that every block has at least one working mirror */
3527	if (!enough(conf, -1)) {
3528		printk(KERN_ERR "md/raid10:%s: not enough operational mirrors.\n",
3529		       mdname(mddev));
3530		goto out_free_conf;
3531	}
3532
3533	if (conf->reshape_progress != MaxSector) {
3534		/* must ensure that shape change is supported */
3535		if (conf->geo.far_copies != 1 &&
3536		    conf->geo.far_offset == 0)
3537			goto out_free_conf;
3538		if (conf->prev.far_copies != 1 &&
3539		    conf->geo.far_offset == 0)
3540			goto out_free_conf;
3541	}
3542
3543	mddev->degraded = 0;
3544	for (i = 0;
3545	     i < conf->geo.raid_disks
3546		     || i < conf->prev.raid_disks;
3547	     i++) {
3548
3549		disk = conf->mirrors + i;
3550
3551		if (!disk->rdev && disk->replacement) {
3552			/* The replacement is all we have - use it */
3553			disk->rdev = disk->replacement;
3554			disk->replacement = NULL;
3555			clear_bit(Replacement, &disk->rdev->flags);
3556		}
3557
3558		if (!disk->rdev ||
3559		    !test_bit(In_sync, &disk->rdev->flags)) {
3560			disk->head_position = 0;
3561			mddev->degraded++;
3562			if (disk->rdev)
 
3563				conf->fullsync = 1;
3564		}
 
 
 
 
 
 
 
3565		disk->recovery_disabled = mddev->recovery_disabled - 1;
3566	}
3567
3568	if (mddev->recovery_cp != MaxSector)
3569		printk(KERN_NOTICE "md/raid10:%s: not clean"
3570		       " -- starting background reconstruction\n",
3571		       mdname(mddev));
3572	printk(KERN_INFO
3573		"md/raid10:%s: active with %d out of %d devices\n",
3574		mdname(mddev), conf->geo.raid_disks - mddev->degraded,
3575		conf->geo.raid_disks);
3576	/*
3577	 * Ok, everything is just fine now
3578	 */
3579	mddev->dev_sectors = conf->dev_sectors;
3580	size = raid10_size(mddev, 0, 0);
3581	md_set_array_sectors(mddev, size);
3582	mddev->resync_max_sectors = size;
3583
3584	mddev->queue->backing_dev_info.congested_fn = raid10_congested;
3585	mddev->queue->backing_dev_info.congested_data = mddev;
3586
3587	/* Calculate max read-ahead size.
3588	 * We need to readahead at least twice a whole stripe....
3589	 * maybe...
3590	 */
3591	{
3592		int stripe = conf->geo.raid_disks *
3593			((mddev->chunk_sectors << 9) / PAGE_SIZE);
3594		stripe /= conf->geo.near_copies;
3595		if (mddev->queue->backing_dev_info.ra_pages < 2 * stripe)
3596			mddev->queue->backing_dev_info.ra_pages = 2 * stripe;
3597	}
3598
3599	blk_queue_merge_bvec(mddev->queue, raid10_mergeable_bvec);
3600
3601	if (md_integrity_register(mddev))
3602		goto out_free_conf;
3603
3604	if (conf->reshape_progress != MaxSector) {
3605		unsigned long before_length, after_length;
3606
3607		before_length = ((1 << conf->prev.chunk_shift) *
3608				 conf->prev.far_copies);
3609		after_length = ((1 << conf->geo.chunk_shift) *
3610				conf->geo.far_copies);
3611
3612		if (max(before_length, after_length) > min_offset_diff) {
3613			/* This cannot work */
3614			printk("md/raid10: offset difference not enough to continue reshape\n");
3615			goto out_free_conf;
3616		}
3617		conf->offset_diff = min_offset_diff;
3618
3619		conf->reshape_safe = conf->reshape_progress;
3620		clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
3621		clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
3622		set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
3623		set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
3624		mddev->sync_thread = md_register_thread(md_do_sync, mddev,
3625							"reshape");
3626	}
3627
3628	return 0;
3629
3630out_free_conf:
3631	md_unregister_thread(&mddev->thread);
3632	if (conf->r10bio_pool)
3633		mempool_destroy(conf->r10bio_pool);
3634	safe_put_page(conf->tmppage);
3635	kfree(conf->mirrors);
3636	kfree(conf);
3637	mddev->private = NULL;
3638out:
3639	return -EIO;
3640}
3641
3642static int stop(struct mddev *mddev)
3643{
3644	struct r10conf *conf = mddev->private;
3645
3646	raise_barrier(conf, 0);
3647	lower_barrier(conf);
3648
3649	md_unregister_thread(&mddev->thread);
3650	blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
3651	if (conf->r10bio_pool)
3652		mempool_destroy(conf->r10bio_pool);
3653	kfree(conf->mirrors);
3654	kfree(conf);
3655	mddev->private = NULL;
3656	return 0;
3657}
3658
3659static void raid10_quiesce(struct mddev *mddev, int state)
3660{
3661	struct r10conf *conf = mddev->private;
3662
3663	switch(state) {
3664	case 1:
3665		raise_barrier(conf, 0);
3666		break;
3667	case 0:
3668		lower_barrier(conf);
3669		break;
3670	}
3671}
3672
3673static int raid10_resize(struct mddev *mddev, sector_t sectors)
3674{
3675	/* Resize of 'far' arrays is not supported.
3676	 * For 'near' and 'offset' arrays we can set the
3677	 * number of sectors used to be an appropriate multiple
3678	 * of the chunk size.
3679	 * For 'offset', this is far_copies*chunksize.
3680	 * For 'near' the multiplier is the LCM of
3681	 * near_copies and raid_disks.
3682	 * So if far_copies > 1 && !far_offset, fail.
3683	 * Else find LCM(raid_disks, near_copy)*far_copies and
3684	 * multiply by chunk_size.  Then round to this number.
3685	 * This is mostly done by raid10_size()
3686	 */
3687	struct r10conf *conf = mddev->private;
3688	sector_t oldsize, size;
3689
3690	if (mddev->reshape_position != MaxSector)
3691		return -EBUSY;
3692
3693	if (conf->geo.far_copies > 1 && !conf->geo.far_offset)
3694		return -EINVAL;
3695
3696	oldsize = raid10_size(mddev, 0, 0);
3697	size = raid10_size(mddev, sectors, 0);
3698	if (mddev->external_size &&
3699	    mddev->array_sectors > size)
3700		return -EINVAL;
3701	if (mddev->bitmap) {
3702		int ret = bitmap_resize(mddev->bitmap, size, 0, 0);
3703		if (ret)
3704			return ret;
3705	}
3706	md_set_array_sectors(mddev, size);
3707	set_capacity(mddev->gendisk, mddev->array_sectors);
3708	revalidate_disk(mddev->gendisk);
3709	if (sectors > mddev->dev_sectors &&
3710	    mddev->recovery_cp > oldsize) {
3711		mddev->recovery_cp = oldsize;
3712		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3713	}
3714	calc_sectors(conf, sectors);
3715	mddev->dev_sectors = conf->dev_sectors;
3716	mddev->resync_max_sectors = size;
3717	return 0;
3718}
3719
3720static void *raid10_takeover_raid0(struct mddev *mddev)
3721{
3722	struct md_rdev *rdev;
3723	struct r10conf *conf;
3724
3725	if (mddev->degraded > 0) {
3726		printk(KERN_ERR "md/raid10:%s: Error: degraded raid0!\n",
3727		       mdname(mddev));
3728		return ERR_PTR(-EINVAL);
3729	}
 
3730
3731	/* Set new parameters */
3732	mddev->new_level = 10;
3733	/* new layout: far_copies = 1, near_copies = 2 */
3734	mddev->new_layout = (1<<8) + 2;
3735	mddev->new_chunk_sectors = mddev->chunk_sectors;
3736	mddev->delta_disks = mddev->raid_disks;
3737	mddev->raid_disks *= 2;
3738	/* make sure it will be not marked as dirty */
3739	mddev->recovery_cp = MaxSector;
 
3740
3741	conf = setup_conf(mddev);
3742	if (!IS_ERR(conf)) {
3743		rdev_for_each(rdev, mddev)
3744			if (rdev->raid_disk >= 0)
3745				rdev->new_raid_disk = rdev->raid_disk * 2;
3746		conf->barrier = 1;
 
3747	}
3748
3749	return conf;
3750}
3751
3752static void *raid10_takeover(struct mddev *mddev)
3753{
3754	struct r0conf *raid0_conf;
3755
3756	/* raid10 can take over:
3757	 *  raid0 - providing it has only two drives
3758	 */
3759	if (mddev->level == 0) {
3760		/* for raid0 takeover only one zone is supported */
3761		raid0_conf = mddev->private;
3762		if (raid0_conf->nr_strip_zones > 1) {
3763			printk(KERN_ERR "md/raid10:%s: cannot takeover raid 0"
3764			       " with more than one zone.\n",
3765			       mdname(mddev));
3766			return ERR_PTR(-EINVAL);
3767		}
3768		return raid10_takeover_raid0(mddev);
 
 
3769	}
3770	return ERR_PTR(-EINVAL);
3771}
3772
3773static int raid10_check_reshape(struct mddev *mddev)
3774{
3775	/* Called when there is a request to change
3776	 * - layout (to ->new_layout)
3777	 * - chunk size (to ->new_chunk_sectors)
3778	 * - raid_disks (by delta_disks)
3779	 * or when trying to restart a reshape that was ongoing.
3780	 *
3781	 * We need to validate the request and possibly allocate
3782	 * space if that might be an issue later.
3783	 *
3784	 * Currently we reject any reshape of a 'far' mode array,
3785	 * allow chunk size to change if new is generally acceptable,
3786	 * allow raid_disks to increase, and allow
3787	 * a switch between 'near' mode and 'offset' mode.
3788	 */
3789	struct r10conf *conf = mddev->private;
3790	struct geom geo;
3791
3792	if (conf->geo.far_copies != 1 && !conf->geo.far_offset)
3793		return -EINVAL;
3794
3795	if (setup_geo(&geo, mddev, geo_start) != conf->copies)
3796		/* mustn't change number of copies */
3797		return -EINVAL;
3798	if (geo.far_copies > 1 && !geo.far_offset)
3799		/* Cannot switch to 'far' mode */
3800		return -EINVAL;
3801
3802	if (mddev->array_sectors & geo.chunk_mask)
3803			/* not factor of array size */
3804			return -EINVAL;
3805
3806	if (!enough(conf, -1))
3807		return -EINVAL;
3808
3809	kfree(conf->mirrors_new);
3810	conf->mirrors_new = NULL;
3811	if (mddev->delta_disks > 0) {
3812		/* allocate new 'mirrors' list */
3813		conf->mirrors_new = kzalloc(
3814			sizeof(struct mirror_info)
3815			*(mddev->raid_disks +
3816			  mddev->delta_disks),
3817			GFP_KERNEL);
3818		if (!conf->mirrors_new)
3819			return -ENOMEM;
3820	}
3821	return 0;
3822}
3823
3824/*
3825 * Need to check if array has failed when deciding whether to:
3826 *  - start an array
3827 *  - remove non-faulty devices
3828 *  - add a spare
3829 *  - allow a reshape
3830 * This determination is simple when no reshape is happening.
3831 * However if there is a reshape, we need to carefully check
3832 * both the before and after sections.
3833 * This is because some failed devices may only affect one
3834 * of the two sections, and some non-in_sync devices may
3835 * be insync in the section most affected by failed devices.
3836 */
3837static int calc_degraded(struct r10conf *conf)
3838{
3839	int degraded, degraded2;
3840	int i;
3841
3842	rcu_read_lock();
3843	degraded = 0;
3844	/* 'prev' section first */
3845	for (i = 0; i < conf->prev.raid_disks; i++) {
3846		struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
 
3847		if (!rdev || test_bit(Faulty, &rdev->flags))
3848			degraded++;
3849		else if (!test_bit(In_sync, &rdev->flags))
3850			/* When we can reduce the number of devices in
3851			 * an array, this might not contribute to
3852			 * 'degraded'.  It does now.
3853			 */
3854			degraded++;
3855	}
3856	rcu_read_unlock();
3857	if (conf->geo.raid_disks == conf->prev.raid_disks)
3858		return degraded;
3859	rcu_read_lock();
3860	degraded2 = 0;
3861	for (i = 0; i < conf->geo.raid_disks; i++) {
3862		struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
 
3863		if (!rdev || test_bit(Faulty, &rdev->flags))
3864			degraded2++;
3865		else if (!test_bit(In_sync, &rdev->flags)) {
3866			/* If reshape is increasing the number of devices,
3867			 * this section has already been recovered, so
3868			 * it doesn't contribute to degraded.
3869			 * else it does.
3870			 */
3871			if (conf->geo.raid_disks <= conf->prev.raid_disks)
3872				degraded2++;
3873		}
3874	}
3875	rcu_read_unlock();
3876	if (degraded2 > degraded)
3877		return degraded2;
3878	return degraded;
3879}
3880
3881static int raid10_start_reshape(struct mddev *mddev)
3882{
3883	/* A 'reshape' has been requested. This commits
3884	 * the various 'new' fields and sets MD_RECOVER_RESHAPE
3885	 * This also checks if there are enough spares and adds them
3886	 * to the array.
3887	 * We currently require enough spares to make the final
3888	 * array non-degraded.  We also require that the difference
3889	 * between old and new data_offset - on each device - is
3890	 * enough that we never risk over-writing.
3891	 */
3892
3893	unsigned long before_length, after_length;
3894	sector_t min_offset_diff = 0;
3895	int first = 1;
3896	struct geom new;
3897	struct r10conf *conf = mddev->private;
3898	struct md_rdev *rdev;
3899	int spares = 0;
3900	int ret;
3901
3902	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
3903		return -EBUSY;
3904
3905	if (setup_geo(&new, mddev, geo_start) != conf->copies)
3906		return -EINVAL;
3907
3908	before_length = ((1 << conf->prev.chunk_shift) *
3909			 conf->prev.far_copies);
3910	after_length = ((1 << conf->geo.chunk_shift) *
3911			conf->geo.far_copies);
3912
3913	rdev_for_each(rdev, mddev) {
3914		if (!test_bit(In_sync, &rdev->flags)
3915		    && !test_bit(Faulty, &rdev->flags))
3916			spares++;
3917		if (rdev->raid_disk >= 0) {
3918			long long diff = (rdev->new_data_offset
3919					  - rdev->data_offset);
3920			if (!mddev->reshape_backwards)
3921				diff = -diff;
3922			if (diff < 0)
3923				diff = 0;
3924			if (first || diff < min_offset_diff)
3925				min_offset_diff = diff;
 
3926		}
3927	}
3928
3929	if (max(before_length, after_length) > min_offset_diff)
3930		return -EINVAL;
3931
3932	if (spares < mddev->delta_disks)
3933		return -EINVAL;
3934
3935	conf->offset_diff = min_offset_diff;
3936	spin_lock_irq(&conf->device_lock);
3937	if (conf->mirrors_new) {
3938		memcpy(conf->mirrors_new, conf->mirrors,
3939		       sizeof(struct mirror_info)*conf->prev.raid_disks);
3940		smp_mb();
3941		kfree(conf->mirrors_old); /* FIXME and elsewhere */
3942		conf->mirrors_old = conf->mirrors;
3943		conf->mirrors = conf->mirrors_new;
3944		conf->mirrors_new = NULL;
3945	}
3946	setup_geo(&conf->geo, mddev, geo_start);
3947	smp_mb();
3948	if (mddev->reshape_backwards) {
3949		sector_t size = raid10_size(mddev, 0, 0);
3950		if (size < mddev->array_sectors) {
3951			spin_unlock_irq(&conf->device_lock);
3952			printk(KERN_ERR "md/raid10:%s: array size must be reduce before number of disks\n",
3953			       mdname(mddev));
3954			return -EINVAL;
3955		}
3956		mddev->resync_max_sectors = size;
3957		conf->reshape_progress = size;
3958	} else
3959		conf->reshape_progress = 0;
 
3960	spin_unlock_irq(&conf->device_lock);
3961
3962	if (mddev->delta_disks && mddev->bitmap) {
3963		ret = bitmap_resize(mddev->bitmap,
3964				    raid10_size(mddev, 0,
3965						conf->geo.raid_disks),
3966				    0, 0);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3967		if (ret)
3968			goto abort;
 
 
 
 
 
 
3969	}
 
3970	if (mddev->delta_disks > 0) {
3971		rdev_for_each(rdev, mddev)
3972			if (rdev->raid_disk < 0 &&
3973			    !test_bit(Faulty, &rdev->flags)) {
3974				if (raid10_add_disk(mddev, rdev) == 0) {
3975					if (rdev->raid_disk >=
3976					    conf->prev.raid_disks)
3977						set_bit(In_sync, &rdev->flags);
3978					else
3979						rdev->recovery_offset = 0;
3980
3981					if (sysfs_link_rdev(mddev, rdev))
3982						/* Failure here  is OK */;
3983				}
3984			} else if (rdev->raid_disk >= conf->prev.raid_disks
3985				   && !test_bit(Faulty, &rdev->flags)) {
3986				/* This is a spare that was manually added */
3987				set_bit(In_sync, &rdev->flags);
3988			}
3989	}
3990	/* When a reshape changes the number of devices,
3991	 * ->degraded is measured against the larger of the
3992	 * pre and  post numbers.
3993	 */
3994	spin_lock_irq(&conf->device_lock);
3995	mddev->degraded = calc_degraded(conf);
3996	spin_unlock_irq(&conf->device_lock);
3997	mddev->raid_disks = conf->geo.raid_disks;
3998	mddev->reshape_position = conf->reshape_progress;
3999	set_bit(MD_CHANGE_DEVS, &mddev->flags);
4000
4001	clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
4002	clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
 
4003	set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
4004	set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
4005
4006	mddev->sync_thread = md_register_thread(md_do_sync, mddev,
4007						"reshape");
4008	if (!mddev->sync_thread) {
4009		ret = -EAGAIN;
4010		goto abort;
4011	}
4012	conf->reshape_checkpoint = jiffies;
4013	md_wakeup_thread(mddev->sync_thread);
4014	md_new_event(mddev);
4015	return 0;
4016
4017abort:
4018	mddev->recovery = 0;
4019	spin_lock_irq(&conf->device_lock);
4020	conf->geo = conf->prev;
4021	mddev->raid_disks = conf->geo.raid_disks;
4022	rdev_for_each(rdev, mddev)
4023		rdev->new_data_offset = rdev->data_offset;
4024	smp_wmb();
4025	conf->reshape_progress = MaxSector;
 
4026	mddev->reshape_position = MaxSector;
4027	spin_unlock_irq(&conf->device_lock);
4028	return ret;
4029}
4030
4031/* Calculate the last device-address that could contain
4032 * any block from the chunk that includes the array-address 's'
4033 * and report the next address.
4034 * i.e. the address returned will be chunk-aligned and after
4035 * any data that is in the chunk containing 's'.
4036 */
4037static sector_t last_dev_address(sector_t s, struct geom *geo)
4038{
4039	s = (s | geo->chunk_mask) + 1;
4040	s >>= geo->chunk_shift;
4041	s *= geo->near_copies;
4042	s = DIV_ROUND_UP_SECTOR_T(s, geo->raid_disks);
4043	s *= geo->far_copies;
4044	s <<= geo->chunk_shift;
4045	return s;
4046}
4047
4048/* Calculate the first device-address that could contain
4049 * any block from the chunk that includes the array-address 's'.
4050 * This too will be the start of a chunk
4051 */
4052static sector_t first_dev_address(sector_t s, struct geom *geo)
4053{
4054	s >>= geo->chunk_shift;
4055	s *= geo->near_copies;
4056	sector_div(s, geo->raid_disks);
4057	s *= geo->far_copies;
4058	s <<= geo->chunk_shift;
4059	return s;
4060}
4061
4062static sector_t reshape_request(struct mddev *mddev, sector_t sector_nr,
4063				int *skipped)
4064{
4065	/* We simply copy at most one chunk (smallest of old and new)
4066	 * at a time, possibly less if that exceeds RESYNC_PAGES,
4067	 * or we hit a bad block or something.
4068	 * This might mean we pause for normal IO in the middle of
4069	 * a chunk, but that is not a problem was mddev->reshape_position
4070	 * can record any location.
4071	 *
4072	 * If we will want to write to a location that isn't
4073	 * yet recorded as 'safe' (i.e. in metadata on disk) then
4074	 * we need to flush all reshape requests and update the metadata.
4075	 *
4076	 * When reshaping forwards (e.g. to more devices), we interpret
4077	 * 'safe' as the earliest block which might not have been copied
4078	 * down yet.  We divide this by previous stripe size and multiply
4079	 * by previous stripe length to get lowest device offset that we
4080	 * cannot write to yet.
4081	 * We interpret 'sector_nr' as an address that we want to write to.
4082	 * From this we use last_device_address() to find where we might
4083	 * write to, and first_device_address on the  'safe' position.
4084	 * If this 'next' write position is after the 'safe' position,
4085	 * we must update the metadata to increase the 'safe' position.
4086	 *
4087	 * When reshaping backwards, we round in the opposite direction
4088	 * and perform the reverse test:  next write position must not be
4089	 * less than current safe position.
4090	 *
4091	 * In all this the minimum difference in data offsets
4092	 * (conf->offset_diff - always positive) allows a bit of slack,
4093	 * so next can be after 'safe', but not by more than offset_disk
4094	 *
4095	 * We need to prepare all the bios here before we start any IO
4096	 * to ensure the size we choose is acceptable to all devices.
4097	 * The means one for each copy for write-out and an extra one for
4098	 * read-in.
4099	 * We store the read-in bio in ->master_bio and the others in
4100	 * ->devs[x].bio and ->devs[x].repl_bio.
4101	 */
4102	struct r10conf *conf = mddev->private;
4103	struct r10bio *r10_bio;
4104	sector_t next, safe, last;
4105	int max_sectors;
4106	int nr_sectors;
4107	int s;
4108	struct md_rdev *rdev;
4109	int need_flush = 0;
4110	struct bio *blist;
4111	struct bio *bio, *read_bio;
4112	int sectors_done = 0;
 
4113
4114	if (sector_nr == 0) {
4115		/* If restarting in the middle, skip the initial sectors */
4116		if (mddev->reshape_backwards &&
4117		    conf->reshape_progress < raid10_size(mddev, 0, 0)) {
4118			sector_nr = (raid10_size(mddev, 0, 0)
4119				     - conf->reshape_progress);
4120		} else if (!mddev->reshape_backwards &&
4121			   conf->reshape_progress > 0)
4122			sector_nr = conf->reshape_progress;
4123		if (sector_nr) {
4124			mddev->curr_resync_completed = sector_nr;
4125			sysfs_notify(&mddev->kobj, NULL, "sync_completed");
4126			*skipped = 1;
4127			return sector_nr;
4128		}
4129	}
4130
4131	/* We don't use sector_nr to track where we are up to
4132	 * as that doesn't work well for ->reshape_backwards.
4133	 * So just use ->reshape_progress.
4134	 */
4135	if (mddev->reshape_backwards) {
4136		/* 'next' is the earliest device address that we might
4137		 * write to for this chunk in the new layout
4138		 */
4139		next = first_dev_address(conf->reshape_progress - 1,
4140					 &conf->geo);
4141
4142		/* 'safe' is the last device address that we might read from
4143		 * in the old layout after a restart
4144		 */
4145		safe = last_dev_address(conf->reshape_safe - 1,
4146					&conf->prev);
4147
4148		if (next + conf->offset_diff < safe)
4149			need_flush = 1;
4150
4151		last = conf->reshape_progress - 1;
4152		sector_nr = last & ~(sector_t)(conf->geo.chunk_mask
4153					       & conf->prev.chunk_mask);
4154		if (sector_nr + RESYNC_BLOCK_SIZE/512 < last)
4155			sector_nr = last + 1 - RESYNC_BLOCK_SIZE/512;
4156	} else {
4157		/* 'next' is after the last device address that we
4158		 * might write to for this chunk in the new layout
4159		 */
4160		next = last_dev_address(conf->reshape_progress, &conf->geo);
4161
4162		/* 'safe' is the earliest device address that we might
4163		 * read from in the old layout after a restart
4164		 */
4165		safe = first_dev_address(conf->reshape_safe, &conf->prev);
4166
4167		/* Need to update metadata if 'next' might be beyond 'safe'
4168		 * as that would possibly corrupt data
4169		 */
4170		if (next > safe + conf->offset_diff)
4171			need_flush = 1;
4172
4173		sector_nr = conf->reshape_progress;
4174		last  = sector_nr | (conf->geo.chunk_mask
4175				     & conf->prev.chunk_mask);
4176
4177		if (sector_nr + RESYNC_BLOCK_SIZE/512 <= last)
4178			last = sector_nr + RESYNC_BLOCK_SIZE/512 - 1;
4179	}
4180
4181	if (need_flush ||
4182	    time_after(jiffies, conf->reshape_checkpoint + 10*HZ)) {
4183		/* Need to update reshape_position in metadata */
4184		wait_barrier(conf);
4185		mddev->reshape_position = conf->reshape_progress;
4186		if (mddev->reshape_backwards)
4187			mddev->curr_resync_completed = raid10_size(mddev, 0, 0)
4188				- conf->reshape_progress;
4189		else
4190			mddev->curr_resync_completed = conf->reshape_progress;
4191		conf->reshape_checkpoint = jiffies;
4192		set_bit(MD_CHANGE_DEVS, &mddev->flags);
4193		md_wakeup_thread(mddev->thread);
4194		wait_event(mddev->sb_wait, mddev->flags == 0 ||
4195			   kthread_should_stop());
 
 
 
 
4196		conf->reshape_safe = mddev->reshape_position;
4197		allow_barrier(conf);
4198	}
4199
 
4200read_more:
4201	/* Now schedule reads for blocks from sector_nr to last */
4202	r10_bio = mempool_alloc(conf->r10buf_pool, GFP_NOIO);
4203	raise_barrier(conf, sectors_done != 0);
 
4204	atomic_set(&r10_bio->remaining, 0);
4205	r10_bio->mddev = mddev;
4206	r10_bio->sector = sector_nr;
4207	set_bit(R10BIO_IsReshape, &r10_bio->state);
4208	r10_bio->sectors = last - sector_nr + 1;
4209	rdev = read_balance(conf, r10_bio, &max_sectors);
4210	BUG_ON(!test_bit(R10BIO_Previous, &r10_bio->state));
4211
4212	if (!rdev) {
4213		/* Cannot read from here, so need to record bad blocks
4214		 * on all the target devices.
4215		 */
4216		// FIXME
 
4217		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4218		return sectors_done;
4219	}
4220
4221	read_bio = bio_alloc_mddev(GFP_KERNEL, RESYNC_PAGES, mddev);
4222
4223	read_bio->bi_bdev = rdev->bdev;
4224	read_bio->bi_sector = (r10_bio->devs[r10_bio->read_slot].addr
4225			       + rdev->data_offset);
4226	read_bio->bi_private = r10_bio;
4227	read_bio->bi_end_io = end_sync_read;
4228	read_bio->bi_rw = READ;
4229	read_bio->bi_flags &= ~(BIO_POOL_MASK - 1);
4230	read_bio->bi_flags |= 1 << BIO_UPTODATE;
4231	read_bio->bi_vcnt = 0;
4232	read_bio->bi_idx = 0;
4233	read_bio->bi_size = 0;
4234	r10_bio->master_bio = read_bio;
4235	r10_bio->read_slot = r10_bio->devs[r10_bio->read_slot].devnum;
4236
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4237	/* Now find the locations in the new layout */
4238	__raid10_find_phys(&conf->geo, r10_bio);
4239
4240	blist = read_bio;
4241	read_bio->bi_next = NULL;
4242
4243	for (s = 0; s < conf->copies*2; s++) {
4244		struct bio *b;
4245		int d = r10_bio->devs[s/2].devnum;
4246		struct md_rdev *rdev2;
4247		if (s&1) {
4248			rdev2 = conf->mirrors[d].replacement;
4249			b = r10_bio->devs[s/2].repl_bio;
4250		} else {
4251			rdev2 = conf->mirrors[d].rdev;
4252			b = r10_bio->devs[s/2].bio;
4253		}
4254		if (!rdev2 || test_bit(Faulty, &rdev2->flags))
4255			continue;
4256		b->bi_bdev = rdev2->bdev;
4257		b->bi_sector = r10_bio->devs[s/2].addr + rdev2->new_data_offset;
4258		b->bi_private = r10_bio;
 
4259		b->bi_end_io = end_reshape_write;
4260		b->bi_rw = WRITE;
4261		b->bi_flags &= ~(BIO_POOL_MASK - 1);
4262		b->bi_flags |= 1 << BIO_UPTODATE;
4263		b->bi_next = blist;
4264		b->bi_vcnt = 0;
4265		b->bi_idx = 0;
4266		b->bi_size = 0;
4267		blist = b;
4268	}
4269
4270	/* Now add as many pages as possible to all of these bios. */
4271
4272	nr_sectors = 0;
 
4273	for (s = 0 ; s < max_sectors; s += PAGE_SIZE >> 9) {
4274		struct page *page = r10_bio->devs[0].bio->bi_io_vec[s/(PAGE_SIZE>>9)].bv_page;
4275		int len = (max_sectors - s) << 9;
4276		if (len > PAGE_SIZE)
4277			len = PAGE_SIZE;
4278		for (bio = blist; bio ; bio = bio->bi_next) {
4279			struct bio *bio2;
4280			if (bio_add_page(bio, page, len, 0))
4281				continue;
4282
4283			/* Didn't fit, must stop */
4284			for (bio2 = blist;
4285			     bio2 && bio2 != bio;
4286			     bio2 = bio2->bi_next) {
4287				/* Remove last page from this bio */
4288				bio2->bi_vcnt--;
4289				bio2->bi_size -= len;
4290				bio2->bi_flags &= ~(1<<BIO_SEG_VALID);
4291			}
4292			goto bio_full;
4293		}
4294		sector_nr += len >> 9;
4295		nr_sectors += len >> 9;
4296	}
4297bio_full:
4298	r10_bio->sectors = nr_sectors;
4299
4300	/* Now submit the read */
4301	md_sync_acct(read_bio->bi_bdev, r10_bio->sectors);
4302	atomic_inc(&r10_bio->remaining);
4303	read_bio->bi_next = NULL;
4304	generic_make_request(read_bio);
4305	sector_nr += nr_sectors;
4306	sectors_done += nr_sectors;
4307	if (sector_nr <= last)
4308		goto read_more;
4309
 
 
4310	/* Now that we have done the whole section we can
4311	 * update reshape_progress
4312	 */
4313	if (mddev->reshape_backwards)
4314		conf->reshape_progress -= sectors_done;
4315	else
4316		conf->reshape_progress += sectors_done;
4317
4318	return sectors_done;
4319}
4320
4321static void end_reshape_request(struct r10bio *r10_bio);
4322static int handle_reshape_read_error(struct mddev *mddev,
4323				     struct r10bio *r10_bio);
4324static void reshape_request_write(struct mddev *mddev, struct r10bio *r10_bio)
4325{
4326	/* Reshape read completed.  Hopefully we have a block
4327	 * to write out.
4328	 * If we got a read error then we do sync 1-page reads from
4329	 * elsewhere until we find the data - or give up.
4330	 */
4331	struct r10conf *conf = mddev->private;
4332	int s;
4333
4334	if (!test_bit(R10BIO_Uptodate, &r10_bio->state))
4335		if (handle_reshape_read_error(mddev, r10_bio) < 0) {
4336			/* Reshape has been aborted */
4337			md_done_sync(mddev, r10_bio->sectors, 0);
4338			return;
4339		}
4340
4341	/* We definitely have the data in the pages, schedule the
4342	 * writes.
4343	 */
4344	atomic_set(&r10_bio->remaining, 1);
4345	for (s = 0; s < conf->copies*2; s++) {
4346		struct bio *b;
4347		int d = r10_bio->devs[s/2].devnum;
4348		struct md_rdev *rdev;
4349		if (s&1) {
4350			rdev = conf->mirrors[d].replacement;
4351			b = r10_bio->devs[s/2].repl_bio;
4352		} else {
4353			rdev = conf->mirrors[d].rdev;
4354			b = r10_bio->devs[s/2].bio;
4355		}
4356		if (!rdev || test_bit(Faulty, &rdev->flags))
4357			continue;
 
4358		atomic_inc(&rdev->nr_pending);
4359		md_sync_acct(b->bi_bdev, r10_bio->sectors);
4360		atomic_inc(&r10_bio->remaining);
4361		b->bi_next = NULL;
4362		generic_make_request(b);
4363	}
4364	end_reshape_request(r10_bio);
4365}
4366
4367static void end_reshape(struct r10conf *conf)
4368{
4369	if (test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery))
4370		return;
4371
4372	spin_lock_irq(&conf->device_lock);
4373	conf->prev = conf->geo;
4374	md_finish_reshape(conf->mddev);
4375	smp_wmb();
4376	conf->reshape_progress = MaxSector;
 
4377	spin_unlock_irq(&conf->device_lock);
4378
4379	/* read-ahead size must cover two whole stripes, which is
4380	 * 2 * (datadisks) * chunksize where 'n' is the number of raid devices
4381	 */
4382	if (conf->mddev->queue) {
4383		int stripe = conf->geo.raid_disks *
4384			((conf->mddev->chunk_sectors << 9) / PAGE_SIZE);
4385		stripe /= conf->geo.near_copies;
4386		if (conf->mddev->queue->backing_dev_info.ra_pages < 2 * stripe)
4387			conf->mddev->queue->backing_dev_info.ra_pages = 2 * stripe;
4388	}
4389	conf->fullsync = 0;
4390}
4391
 
 
 
 
 
 
 
 
 
 
 
 
4392
4393static int handle_reshape_read_error(struct mddev *mddev,
4394				     struct r10bio *r10_bio)
4395{
4396	/* Use sync reads to get the blocks from somewhere else */
4397	int sectors = r10_bio->sectors;
4398	struct r10conf *conf = mddev->private;
4399	struct {
4400		struct r10bio r10_bio;
4401		struct r10dev devs[conf->copies];
4402	} on_stack;
4403	struct r10bio *r10b = &on_stack.r10_bio;
4404	int slot = 0;
4405	int idx = 0;
4406	struct bio_vec *bvec = r10_bio->master_bio->bi_io_vec;
 
 
 
 
 
 
 
 
 
4407
4408	r10b->sector = r10_bio->sector;
4409	__raid10_find_phys(&conf->prev, r10b);
4410
4411	while (sectors) {
4412		int s = sectors;
4413		int success = 0;
4414		int first_slot = slot;
4415
4416		if (s > (PAGE_SIZE >> 9))
4417			s = PAGE_SIZE >> 9;
4418
4419		while (!success) {
4420			int d = r10b->devs[slot].devnum;
4421			struct md_rdev *rdev = conf->mirrors[d].rdev;
4422			sector_t addr;
4423			if (rdev == NULL ||
4424			    test_bit(Faulty, &rdev->flags) ||
4425			    !test_bit(In_sync, &rdev->flags))
4426				goto failed;
4427
4428			addr = r10b->devs[slot].addr + idx * PAGE_SIZE;
 
4429			success = sync_page_io(rdev,
4430					       addr,
4431					       s << 9,
4432					       bvec[idx].bv_page,
4433					       READ, false);
 
4434			if (success)
4435				break;
4436		failed:
4437			slot++;
4438			if (slot >= conf->copies)
4439				slot = 0;
4440			if (slot == first_slot)
4441				break;
4442		}
4443		if (!success) {
4444			/* couldn't read this block, must give up */
4445			set_bit(MD_RECOVERY_INTR,
4446				&mddev->recovery);
 
4447			return -EIO;
4448		}
4449		sectors -= s;
4450		idx++;
4451	}
 
4452	return 0;
4453}
4454
4455static void end_reshape_write(struct bio *bio, int error)
4456{
4457	int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
4458	struct r10bio *r10_bio = bio->bi_private;
4459	struct mddev *mddev = r10_bio->mddev;
4460	struct r10conf *conf = mddev->private;
4461	int d;
4462	int slot;
4463	int repl;
4464	struct md_rdev *rdev = NULL;
4465
4466	d = find_bio_disk(conf, r10_bio, bio, &slot, &repl);
4467	if (repl)
4468		rdev = conf->mirrors[d].replacement;
4469	if (!rdev) {
4470		smp_mb();
4471		rdev = conf->mirrors[d].rdev;
4472	}
4473
4474	if (!uptodate) {
4475		/* FIXME should record badblock */
4476		md_error(mddev, rdev);
4477	}
4478
4479	rdev_dec_pending(rdev, mddev);
4480	end_reshape_request(r10_bio);
4481}
4482
4483static void end_reshape_request(struct r10bio *r10_bio)
4484{
4485	if (!atomic_dec_and_test(&r10_bio->remaining))
4486		return;
4487	md_done_sync(r10_bio->mddev, r10_bio->sectors, 1);
4488	bio_put(r10_bio->master_bio);
4489	put_buf(r10_bio);
4490}
4491
4492static void raid10_finish_reshape(struct mddev *mddev)
4493{
4494	struct r10conf *conf = mddev->private;
4495
4496	if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
4497		return;
4498
4499	if (mddev->delta_disks > 0) {
4500		sector_t size = raid10_size(mddev, 0, 0);
4501		md_set_array_sectors(mddev, size);
4502		if (mddev->recovery_cp > mddev->resync_max_sectors) {
4503			mddev->recovery_cp = mddev->resync_max_sectors;
4504			set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4505		}
4506		mddev->resync_max_sectors = size;
4507		set_capacity(mddev->gendisk, mddev->array_sectors);
4508		revalidate_disk(mddev->gendisk);
4509	} else {
4510		int d;
4511		for (d = conf->geo.raid_disks ;
4512		     d < conf->geo.raid_disks - mddev->delta_disks;
4513		     d++) {
4514			struct md_rdev *rdev = conf->mirrors[d].rdev;
4515			if (rdev)
4516				clear_bit(In_sync, &rdev->flags);
4517			rdev = conf->mirrors[d].replacement;
4518			if (rdev)
4519				clear_bit(In_sync, &rdev->flags);
4520		}
4521	}
4522	mddev->layout = mddev->new_layout;
4523	mddev->chunk_sectors = 1 << conf->geo.chunk_shift;
4524	mddev->reshape_position = MaxSector;
4525	mddev->delta_disks = 0;
4526	mddev->reshape_backwards = 0;
4527}
4528
4529static struct md_personality raid10_personality =
4530{
4531	.name		= "raid10",
4532	.level		= 10,
4533	.owner		= THIS_MODULE,
4534	.make_request	= make_request,
4535	.run		= run,
4536	.stop		= stop,
4537	.status		= status,
4538	.error_handler	= error,
4539	.hot_add_disk	= raid10_add_disk,
4540	.hot_remove_disk= raid10_remove_disk,
4541	.spare_active	= raid10_spare_active,
4542	.sync_request	= sync_request,
4543	.quiesce	= raid10_quiesce,
4544	.size		= raid10_size,
4545	.resize		= raid10_resize,
4546	.takeover	= raid10_takeover,
4547	.check_reshape	= raid10_check_reshape,
4548	.start_reshape	= raid10_start_reshape,
4549	.finish_reshape	= raid10_finish_reshape,
 
4550};
4551
4552static int __init raid_init(void)
4553{
4554	return register_md_personality(&raid10_personality);
4555}
4556
4557static void raid_exit(void)
4558{
4559	unregister_md_personality(&raid10_personality);
4560}
4561
4562module_init(raid_init);
4563module_exit(raid_exit);
4564MODULE_LICENSE("GPL");
4565MODULE_DESCRIPTION("RAID10 (striped mirror) personality for MD");
4566MODULE_ALIAS("md-personality-9"); /* RAID10 */
4567MODULE_ALIAS("md-raid10");
4568MODULE_ALIAS("md-level-10");
4569
4570module_param(max_queued_requests, int, S_IRUGO|S_IWUSR);