raid1.c (11e4afb49b7fa1fc8e1ffd850c1806dd86a08204) raid1.c (7b6d91daee5cac6402186ff224c3af39d79f4a0e)
1/*
2 * raid1.c : Multiple Devices driver for Linux
3 *
4 * Copyright (C) 1999, 2000, 2001 Ingo Molnar, Red Hat
5 *
6 * Copyright (C) 1996, 1997, 1998 Ingo Molnar, Miguel de Icaza, Gadi Oxman
7 *
8 * RAID-1 management functions.

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

782 r1bio_t *r1_bio;
783 struct bio *read_bio;
784 int i, targets = 0, disks;
785 struct bitmap *bitmap;
786 unsigned long flags;
787 struct bio_list bl;
788 struct page **behind_pages = NULL;
789 const int rw = bio_data_dir(bio);
1/*
2 * raid1.c : Multiple Devices driver for Linux
3 *
4 * Copyright (C) 1999, 2000, 2001 Ingo Molnar, Red Hat
5 *
6 * Copyright (C) 1996, 1997, 1998 Ingo Molnar, Miguel de Icaza, Gadi Oxman
7 *
8 * RAID-1 management functions.

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

782 r1bio_t *r1_bio;
783 struct bio *read_bio;
784 int i, targets = 0, disks;
785 struct bitmap *bitmap;
786 unsigned long flags;
787 struct bio_list bl;
788 struct page **behind_pages = NULL;
789 const int rw = bio_data_dir(bio);
790 const bool do_sync = bio_rw_flagged(bio, BIO_RW_SYNCIO);
790 const bool do_sync = (bio->bi_rw & REQ_SYNC);
791 bool do_barriers;
792 mdk_rdev_t *blocked_rdev;
793
794 /*
795 * Register the new request and wait if the reconstruction
796 * thread has put up a bar for new requests.
797 * Continue immediately if no resync is active currently.
798 * We test barriers_work *after* md_write_start as md_write_start

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

817 if (bio->bi_sector + bio->bi_size/512 <= mddev->suspend_lo ||
818 bio->bi_sector >= mddev->suspend_hi)
819 break;
820 schedule();
821 }
822 finish_wait(&conf->wait_barrier, &w);
823 }
824 if (unlikely(!mddev->barriers_work &&
791 bool do_barriers;
792 mdk_rdev_t *blocked_rdev;
793
794 /*
795 * Register the new request and wait if the reconstruction
796 * thread has put up a bar for new requests.
797 * Continue immediately if no resync is active currently.
798 * We test barriers_work *after* md_write_start as md_write_start

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

817 if (bio->bi_sector + bio->bi_size/512 <= mddev->suspend_lo ||
818 bio->bi_sector >= mddev->suspend_hi)
819 break;
820 schedule();
821 }
822 finish_wait(&conf->wait_barrier, &w);
823 }
824 if (unlikely(!mddev->barriers_work &&
825 bio_rw_flagged(bio, BIO_RW_BARRIER))) {
825 (bio->bi_rw & REQ_HARDBARRIER))) {
826 if (rw == WRITE)
827 md_write_end(mddev);
828 bio_endio(bio, -EOPNOTSUPP);
829 return 0;
830 }
831
832 wait_barrier(conf);
833

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

872
873 read_bio = bio_clone(bio, GFP_NOIO);
874
875 r1_bio->bios[rdisk] = read_bio;
876
877 read_bio->bi_sector = r1_bio->sector + mirror->rdev->data_offset;
878 read_bio->bi_bdev = mirror->rdev->bdev;
879 read_bio->bi_end_io = raid1_end_read_request;
826 if (rw == WRITE)
827 md_write_end(mddev);
828 bio_endio(bio, -EOPNOTSUPP);
829 return 0;
830 }
831
832 wait_barrier(conf);
833

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

872
873 read_bio = bio_clone(bio, GFP_NOIO);
874
875 r1_bio->bios[rdisk] = read_bio;
876
877 read_bio->bi_sector = r1_bio->sector + mirror->rdev->data_offset;
878 read_bio->bi_bdev = mirror->rdev->bdev;
879 read_bio->bi_end_io = raid1_end_read_request;
880 read_bio->bi_rw = READ | (do_sync << BIO_RW_SYNCIO);
880 read_bio->bi_rw = READ | do_sync;
881 read_bio->bi_private = r1_bio;
882
883 generic_make_request(read_bio);
884 return 0;
885 }
886
887 /*
888 * WRITE:

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

954 < mddev->bitmap_info.max_write_behind) &&
955 !waitqueue_active(&bitmap->behind_wait) &&
956 (behind_pages = alloc_behind_pages(bio)) != NULL)
957 set_bit(R1BIO_BehindIO, &r1_bio->state);
958
959 atomic_set(&r1_bio->remaining, 0);
960 atomic_set(&r1_bio->behind_remaining, 0);
961
881 read_bio->bi_private = r1_bio;
882
883 generic_make_request(read_bio);
884 return 0;
885 }
886
887 /*
888 * WRITE:

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

954 < mddev->bitmap_info.max_write_behind) &&
955 !waitqueue_active(&bitmap->behind_wait) &&
956 (behind_pages = alloc_behind_pages(bio)) != NULL)
957 set_bit(R1BIO_BehindIO, &r1_bio->state);
958
959 atomic_set(&r1_bio->remaining, 0);
960 atomic_set(&r1_bio->behind_remaining, 0);
961
962 do_barriers = bio_rw_flagged(bio, BIO_RW_BARRIER);
962 do_barriers = bio->bi_rw & REQ_HARDBARRIER;
963 if (do_barriers)
964 set_bit(R1BIO_Barrier, &r1_bio->state);
965
966 bio_list_init(&bl);
967 for (i = 0; i < disks; i++) {
968 struct bio *mbio;
969 if (!r1_bio->bios[i])
970 continue;
971
972 mbio = bio_clone(bio, GFP_NOIO);
973 r1_bio->bios[i] = mbio;
974
975 mbio->bi_sector = r1_bio->sector + conf->mirrors[i].rdev->data_offset;
976 mbio->bi_bdev = conf->mirrors[i].rdev->bdev;
977 mbio->bi_end_io = raid1_end_write_request;
963 if (do_barriers)
964 set_bit(R1BIO_Barrier, &r1_bio->state);
965
966 bio_list_init(&bl);
967 for (i = 0; i < disks; i++) {
968 struct bio *mbio;
969 if (!r1_bio->bios[i])
970 continue;
971
972 mbio = bio_clone(bio, GFP_NOIO);
973 r1_bio->bios[i] = mbio;
974
975 mbio->bi_sector = r1_bio->sector + conf->mirrors[i].rdev->data_offset;
976 mbio->bi_bdev = conf->mirrors[i].rdev->bdev;
977 mbio->bi_end_io = raid1_end_write_request;
978 mbio->bi_rw = WRITE | (do_barriers << BIO_RW_BARRIER) |
979 (do_sync << BIO_RW_SYNCIO);
978 mbio->bi_rw = WRITE | do_barriers | do_sync;
980 mbio->bi_private = r1_bio;
981
982 if (behind_pages) {
983 struct bio_vec *bvec;
984 int j;
985
986 /* Yes, I really want the '__' version so that
987 * we clear any unused pointer in the io_vec, rather

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

1628 spin_unlock_irqrestore(&conf->device_lock, flags);
1629
1630 mddev = r1_bio->mddev;
1631 conf = mddev->private;
1632 if (test_bit(R1BIO_IsSync, &r1_bio->state)) {
1633 sync_request_write(mddev, r1_bio);
1634 unplug = 1;
1635 } else if (test_bit(R1BIO_BarrierRetry, &r1_bio->state)) {
979 mbio->bi_private = r1_bio;
980
981 if (behind_pages) {
982 struct bio_vec *bvec;
983 int j;
984
985 /* Yes, I really want the '__' version so that
986 * we clear any unused pointer in the io_vec, rather

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

1627 spin_unlock_irqrestore(&conf->device_lock, flags);
1628
1629 mddev = r1_bio->mddev;
1630 conf = mddev->private;
1631 if (test_bit(R1BIO_IsSync, &r1_bio->state)) {
1632 sync_request_write(mddev, r1_bio);
1633 unplug = 1;
1634 } else if (test_bit(R1BIO_BarrierRetry, &r1_bio->state)) {
1636 /* some requests in the r1bio were BIO_RW_BARRIER
1635 /* some requests in the r1bio were REQ_HARDBARRIER
1637 * requests which failed with -EOPNOTSUPP. Hohumm..
1638 * Better resubmit without the barrier.
1639 * We know which devices to resubmit for, because
1640 * all others have had their bios[] entry cleared.
1641 * We already have a nr_pending reference on these rdevs.
1642 */
1643 int i;
1636 * requests which failed with -EOPNOTSUPP. Hohumm..
1637 * Better resubmit without the barrier.
1638 * We know which devices to resubmit for, because
1639 * all others have had their bios[] entry cleared.
1640 * We already have a nr_pending reference on these rdevs.
1641 */
1642 int i;
1644 const bool do_sync = bio_rw_flagged(r1_bio->master_bio, BIO_RW_SYNCIO);
1643 const bool do_sync = (r1_bio->master_bio->bi_rw & REQ_SYNC);
1645 clear_bit(R1BIO_BarrierRetry, &r1_bio->state);
1646 clear_bit(R1BIO_Barrier, &r1_bio->state);
1647 for (i=0; i < conf->raid_disks; i++)
1648 if (r1_bio->bios[i])
1649 atomic_inc(&r1_bio->remaining);
1650 for (i=0; i < conf->raid_disks; i++)
1651 if (r1_bio->bios[i]) {
1652 struct bio_vec *bvec;

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

1657 * this might be a write-behind device */
1658 __bio_for_each_segment(bvec, bio, j, 0)
1659 bvec->bv_page = bio_iovec_idx(r1_bio->bios[i], j)->bv_page;
1660 bio_put(r1_bio->bios[i]);
1661 bio->bi_sector = r1_bio->sector +
1662 conf->mirrors[i].rdev->data_offset;
1663 bio->bi_bdev = conf->mirrors[i].rdev->bdev;
1664 bio->bi_end_io = raid1_end_write_request;
1644 clear_bit(R1BIO_BarrierRetry, &r1_bio->state);
1645 clear_bit(R1BIO_Barrier, &r1_bio->state);
1646 for (i=0; i < conf->raid_disks; i++)
1647 if (r1_bio->bios[i])
1648 atomic_inc(&r1_bio->remaining);
1649 for (i=0; i < conf->raid_disks; i++)
1650 if (r1_bio->bios[i]) {
1651 struct bio_vec *bvec;

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

1656 * this might be a write-behind device */
1657 __bio_for_each_segment(bvec, bio, j, 0)
1658 bvec->bv_page = bio_iovec_idx(r1_bio->bios[i], j)->bv_page;
1659 bio_put(r1_bio->bios[i]);
1660 bio->bi_sector = r1_bio->sector +
1661 conf->mirrors[i].rdev->data_offset;
1662 bio->bi_bdev = conf->mirrors[i].rdev->bdev;
1663 bio->bi_end_io = raid1_end_write_request;
1665 bio->bi_rw = WRITE |
1666 (do_sync << BIO_RW_SYNCIO);
1664 bio->bi_rw = WRITE | do_sync;
1667 bio->bi_private = r1_bio;
1668 r1_bio->bios[i] = bio;
1669 generic_make_request(bio);
1670 }
1671 } else {
1672 int disk;
1673
1674 /* we got a read error. Maybe the drive is bad. Maybe just

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

1693 if ((disk=read_balance(conf, r1_bio)) == -1) {
1694 printk(KERN_ALERT "md/raid1:%s: %s: unrecoverable I/O"
1695 " read error for block %llu\n",
1696 mdname(mddev),
1697 bdevname(bio->bi_bdev,b),
1698 (unsigned long long)r1_bio->sector);
1699 raid_end_bio_io(r1_bio);
1700 } else {
1665 bio->bi_private = r1_bio;
1666 r1_bio->bios[i] = bio;
1667 generic_make_request(bio);
1668 }
1669 } else {
1670 int disk;
1671
1672 /* we got a read error. Maybe the drive is bad. Maybe just

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

1691 if ((disk=read_balance(conf, r1_bio)) == -1) {
1692 printk(KERN_ALERT "md/raid1:%s: %s: unrecoverable I/O"
1693 " read error for block %llu\n",
1694 mdname(mddev),
1695 bdevname(bio->bi_bdev,b),
1696 (unsigned long long)r1_bio->sector);
1697 raid_end_bio_io(r1_bio);
1698 } else {
1701 const bool do_sync = bio_rw_flagged(r1_bio->master_bio, BIO_RW_SYNCIO);
1699 const bool do_sync = r1_bio->master_bio->bi_rw & REQ_SYNC;
1702 r1_bio->bios[r1_bio->read_disk] =
1703 mddev->ro ? IO_BLOCKED : NULL;
1704 r1_bio->read_disk = disk;
1705 bio_put(bio);
1706 bio = bio_clone(r1_bio->master_bio, GFP_NOIO);
1707 r1_bio->bios[r1_bio->read_disk] = bio;
1708 rdev = conf->mirrors[disk].rdev;
1709 if (printk_ratelimit())
1710 printk(KERN_ERR "md/raid1:%s: redirecting sector %llu to"
1711 " other mirror: %s\n",
1712 mdname(mddev),
1713 (unsigned long long)r1_bio->sector,
1714 bdevname(rdev->bdev,b));
1715 bio->bi_sector = r1_bio->sector + rdev->data_offset;
1716 bio->bi_bdev = rdev->bdev;
1717 bio->bi_end_io = raid1_end_read_request;
1700 r1_bio->bios[r1_bio->read_disk] =
1701 mddev->ro ? IO_BLOCKED : NULL;
1702 r1_bio->read_disk = disk;
1703 bio_put(bio);
1704 bio = bio_clone(r1_bio->master_bio, GFP_NOIO);
1705 r1_bio->bios[r1_bio->read_disk] = bio;
1706 rdev = conf->mirrors[disk].rdev;
1707 if (printk_ratelimit())
1708 printk(KERN_ERR "md/raid1:%s: redirecting sector %llu to"
1709 " other mirror: %s\n",
1710 mdname(mddev),
1711 (unsigned long long)r1_bio->sector,
1712 bdevname(rdev->bdev,b));
1713 bio->bi_sector = r1_bio->sector + rdev->data_offset;
1714 bio->bi_bdev = rdev->bdev;
1715 bio->bi_end_io = raid1_end_read_request;
1718 bio->bi_rw = READ | (do_sync << BIO_RW_SYNCIO);
1716 bio->bi_rw = READ | do_sync;
1719 bio->bi_private = r1_bio;
1720 unplug = 1;
1721 generic_make_request(bio);
1722 }
1723 }
1724 cond_resched();
1725 }
1726 if (unplug)

--- 667 unchanged lines hidden --- 		1717 bio->bi_private = r1_bio;
1718 unplug = 1;
1719 generic_make_request(bio);
1720 }
1721 }
1722 cond_resched();
1723 }
1724 if (unplug)

--- 667 unchanged lines hidden ---