raid10.c (c6380ecd8e9bee7aba3d9a5a94b58168244c4a61) raid10.c (8b904b5b6b58b9a29dcf3f82d936d9e7fd69fda6)
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.

--- 127 unchanged lines hidden (view full) ---

136 kfree(r10_bio);
137}
138
139#define RESYNC_SECTORS (RESYNC_BLOCK_SIZE >> 9)
140/* amount of memory to reserve for resync requests */
141#define RESYNC_WINDOW (1024*1024)
142/* maximum number of concurrent requests, memory permitting */
143#define RESYNC_DEPTH (32*1024*1024/RESYNC_BLOCK_SIZE)
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.

--- 127 unchanged lines hidden (view full) ---

136 kfree(r10_bio);
137}
138
139#define RESYNC_SECTORS (RESYNC_BLOCK_SIZE >> 9)
140/* amount of memory to reserve for resync requests */
141#define RESYNC_WINDOW (1024*1024)
142/* maximum number of concurrent requests, memory permitting */
143#define RESYNC_DEPTH (32*1024*1024/RESYNC_BLOCK_SIZE)
144#define CLUSTER_RESYNC_WINDOW (32 * RESYNC_WINDOW)
144#define CLUSTER_RESYNC_WINDOW (16 * RESYNC_WINDOW)
145#define CLUSTER_RESYNC_WINDOW_SECTORS (CLUSTER_RESYNC_WINDOW >> 9)
146
147/*
148 * When performing a resync, we need to read and compare, so
149 * we need as many pages are there are copies.
150 * When performing a recovery, we need 2 bios, one for read,
151 * one for write (we recover only one drive per r10buf)
152 *

--- 1687 unchanged lines hidden (view full) ---

1840 rdev->raid_disk = mirror;
1841 err = 0;
1842 if (rdev->saved_raid_disk != mirror)
1843 conf->fullsync = 1;
1844 rcu_assign_pointer(p->rdev, rdev);
1845 break;
1846 }
1847 if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev)))
145#define CLUSTER_RESYNC_WINDOW_SECTORS (CLUSTER_RESYNC_WINDOW >> 9)
146
147/*
148 * When performing a resync, we need to read and compare, so
149 * we need as many pages are there are copies.
150 * When performing a recovery, we need 2 bios, one for read,
151 * one for write (we recover only one drive per r10buf)
152 *

--- 1687 unchanged lines hidden (view full) ---

1840 rdev->raid_disk = mirror;
1841 err = 0;
1842 if (rdev->saved_raid_disk != mirror)
1843 conf->fullsync = 1;
1844 rcu_assign_pointer(p->rdev, rdev);
1845 break;
1846 }
1847 if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev)))
1848 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mddev->queue);
1848 blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue);
1849
1850 print_conf(conf);
1851 return err;
1852}
1853
1854static int raid10_remove_disk(struct mddev *mddev, struct md_rdev *rdev)
1855{
1856 struct r10conf *conf = mddev->private;

--- 793 unchanged lines hidden (view full) ---

2650 int m;
2651 struct md_rdev *rdev;
2652
2653 if (test_bit(R10BIO_IsSync, &r10_bio->state) ||
2654 test_bit(R10BIO_IsRecover, &r10_bio->state)) {
2655 for (m = 0; m < conf->copies; m++) {
2656 int dev = r10_bio->devs[m].devnum;
2657 rdev = conf->mirrors[dev].rdev;
1849
1850 print_conf(conf);
1851 return err;
1852}
1853
1854static int raid10_remove_disk(struct mddev *mddev, struct md_rdev *rdev)
1855{
1856 struct r10conf *conf = mddev->private;

--- 793 unchanged lines hidden (view full) ---

2650 int m;
2651 struct md_rdev *rdev;
2652
2653 if (test_bit(R10BIO_IsSync, &r10_bio->state) ||
2654 test_bit(R10BIO_IsRecover, &r10_bio->state)) {
2655 for (m = 0; m < conf->copies; m++) {
2656 int dev = r10_bio->devs[m].devnum;
2657 rdev = conf->mirrors[dev].rdev;
2658 if (r10_bio->devs[m].bio == NULL ||
2659 r10_bio->devs[m].bio->bi_end_io == NULL)
2658 if (r10_bio->devs[m].bio == NULL)
2660 continue;
2661 if (!r10_bio->devs[m].bio->bi_status) {
2662 rdev_clear_badblocks(
2663 rdev,
2664 r10_bio->devs[m].addr,
2665 r10_bio->sectors, 0);
2666 } else {
2667 if (!rdev_set_badblocks(
2668 rdev,
2669 r10_bio->devs[m].addr,
2670 r10_bio->sectors, 0))
2671 md_error(conf->mddev, rdev);
2672 }
2673 rdev = conf->mirrors[dev].replacement;
2659 continue;
2660 if (!r10_bio->devs[m].bio->bi_status) {
2661 rdev_clear_badblocks(
2662 rdev,
2663 r10_bio->devs[m].addr,
2664 r10_bio->sectors, 0);
2665 } else {
2666 if (!rdev_set_badblocks(
2667 rdev,
2668 r10_bio->devs[m].addr,
2669 r10_bio->sectors, 0))
2670 md_error(conf->mddev, rdev);
2671 }
2672 rdev = conf->mirrors[dev].replacement;
2674 if (r10_bio->devs[m].repl_bio == NULL ||
2675 r10_bio->devs[m].repl_bio->bi_end_io == NULL)
2673 if (r10_bio->devs[m].repl_bio == NULL)
2676 continue;
2677
2678 if (!r10_bio->devs[m].repl_bio->bi_status) {
2679 rdev_clear_badblocks(
2680 rdev,
2681 r10_bio->devs[m].addr,
2682 r10_bio->sectors, 0);
2683 } else {

--- 1095 unchanged lines hidden (view full) ---

3779 if (mddev_is_clustered(conf->mddev)) {
3780 int fc, fo;
3781
3782 fc = (mddev->layout >> 8) & 255;
3783 fo = mddev->layout & (1<<16);
3784 if (fc > 1 || fo > 0) {
3785 pr_err("only near layout is supported by clustered"
3786 " raid10\n");
2674 continue;
2675
2676 if (!r10_bio->devs[m].repl_bio->bi_status) {
2677 rdev_clear_badblocks(
2678 rdev,
2679 r10_bio->devs[m].addr,
2680 r10_bio->sectors, 0);
2681 } else {

--- 1095 unchanged lines hidden (view full) ---

3777 if (mddev_is_clustered(conf->mddev)) {
3778 int fc, fo;
3779
3780 fc = (mddev->layout >> 8) & 255;
3781 fo = mddev->layout & (1<<16);
3782 if (fc > 1 || fo > 0) {
3783 pr_err("only near layout is supported by clustered"
3784 " raid10\n");
3787 goto out_free_conf;
3785 goto out;
3788 }
3789 }
3790
3791 mddev->thread = conf->thread;
3792 conf->thread = NULL;
3793
3794 chunk_size = mddev->chunk_sectors << 9;
3795 if (mddev->queue) {

--- 45 unchanged lines hidden (view full) ---

3841
3842 if (blk_queue_discard(bdev_get_queue(rdev->bdev)))
3843 discard_supported = true;
3844 first = 0;
3845 }
3846
3847 if (mddev->queue) {
3848 if (discard_supported)
3786 }
3787 }
3788
3789 mddev->thread = conf->thread;
3790 conf->thread = NULL;
3791
3792 chunk_size = mddev->chunk_sectors << 9;
3793 if (mddev->queue) {

--- 45 unchanged lines hidden (view full) ---

3839
3840 if (blk_queue_discard(bdev_get_queue(rdev->bdev)))
3841 discard_supported = true;
3842 first = 0;
3843 }
3844
3845 if (mddev->queue) {
3846 if (discard_supported)
3849 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD,
3847 blk_queue_flag_set(QUEUE_FLAG_DISCARD,
3850 mddev->queue);
3851 else
3848 mddev->queue);
3849 else
3852 queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD,
3850 blk_queue_flag_clear(QUEUE_FLAG_DISCARD,
3853 mddev->queue);
3854 }
3855 /* need to check that every block has at least one working mirror */
3856 if (!enough(conf, -1)) {
3857 pr_err("md/raid10:%s: not enough operational mirrors.\n",
3858 mdname(mddev));
3859 goto out_free_conf;
3860 }

--- 966 unchanged lines hidden (view full) ---

4827static void raid10_finish_reshape(struct mddev *mddev)
4828{
4829 struct r10conf *conf = mddev->private;
4830
4831 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
4832 return;
4833
4834 if (mddev->delta_disks > 0) {
3851 mddev->queue);
3852 }
3853 /* need to check that every block has at least one working mirror */
3854 if (!enough(conf, -1)) {
3855 pr_err("md/raid10:%s: not enough operational mirrors.\n",
3856 mdname(mddev));
3857 goto out_free_conf;
3858 }

--- 966 unchanged lines hidden (view full) ---

4825static void raid10_finish_reshape(struct mddev *mddev)
4826{
4827 struct r10conf *conf = mddev->private;
4828
4829 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
4830 return;
4831
4832 if (mddev->delta_disks > 0) {
4833 sector_t size = raid10_size(mddev, 0, 0);
4834 md_set_array_sectors(mddev, size);
4835 if (mddev->recovery_cp > mddev->resync_max_sectors) {
4836 mddev->recovery_cp = mddev->resync_max_sectors;
4837 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4838 }
4835 if (mddev->recovery_cp > mddev->resync_max_sectors) {
4836 mddev->recovery_cp = mddev->resync_max_sectors;
4837 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4838 }
4839 mddev->resync_max_sectors = mddev->array_sectors;
4839 mddev->resync_max_sectors = size;
4840 if (mddev->queue) {
4841 set_capacity(mddev->gendisk, mddev->array_sectors);
4842 revalidate_disk(mddev->gendisk);
4843 }
4840 } else {
4841 int d;
4842 rcu_read_lock();
4843 for (d = conf->geo.raid_disks ;
4844 d < conf->geo.raid_disks - mddev->delta_disks;
4845 d++) {
4846 struct md_rdev *rdev = rcu_dereference(conf->mirrors[d].rdev);
4847 if (rdev)

--- 57 unchanged lines hidden --- 		4844 } else {
4845 int d;
4846 rcu_read_lock();
4847 for (d = conf->geo.raid_disks ;
4848 d < conf->geo.raid_disks - mddev->delta_disks;
4849 d++) {
4850 struct md_rdev *rdev = rcu_dereference(conf->mirrors[d].rdev);
4851 if (rdev)

--- 57 unchanged lines hidden ---