« back to all changes in this revision
Viewing changes to drbd/drbd_actlog.c
- browse files at revision 25
- compare with another revision
- download diff
- download tarball
- view history from revision 25
- Committer: Bazaar Package Importer
- Author(s): Andres Rodriguez
- Date: 2011-07-05 15:40:13 UTC
- mfrom: (1.4.6 upstream)
- Revision ID: james.westby@ubuntu.com-20110705154013-f9l32owj6mi9e1p0
Tags: 2:8.3.11-0ubuntu1
* New upstream release
* debian/patches/01_ubuntu_cn_idx.dpatch: Refreshed.
* debian/patches/01_ubuntu_cn_idx.dpatch: Refreshed.
- files added:
- drbd-kernel.spec.in
- drbd/compat
- drbd/compat/linux
- rpm-macro-fixes
- files removed:
- drbd/linux/autoconf.h
- files modified:
- .filelist
added
removed
drbd/drbd_actlog.c
30
30
#include "drbd_tracing.h"
31
31
#include "drbd_wrappers.h"
32
32
33
/* We maintain a trivial check sum in our on disk activity log.
33
/* We maintain a trivial checksum in our on disk activity log.
34
34
* With that we can ensure correct operation even when the storage
35
* device might do a partial (last) sector write while loosing power.
35
* device might do a partial (last) sector write while losing power.
36
36
*/
37
37
struct __packed al_transaction {
38
38
u32 magic;
85
85
md_io.error = 0;
86
86
87
87
if ((rw & WRITE) && !test_bit(MD_NO_BARRIER, &mdev->flags))
88
rw |= REQ_HARDBARRIER;
89
rw |= REQ_UNPLUG | REQ_SYNC;
88
rw |= DRBD_REQ_FUA | DRBD_REQ_FLUSH;
89
rw |= DRBD_REQ_UNPLUG | DRBD_REQ_SYNC;
90
90
91
#ifndef REQ_FLUSH
92
/* < 2.6.36, "barrier" semantic may fail with EOPNOTSUPP */
91
93
retry:
94
#endif
92
95
bio = bio_alloc(GFP_NOIO, 1);
93
96
bio->bi_bdev = bdev->md_bdev;
94
97
bio->bi_sector = sector;
101
104
102
105
trace_drbd_bio(mdev, "Md", bio, 0, NULL);
103
106
104
if (FAULT_ACTIVE(mdev, (rw & WRITE) ? DRBD_FAULT_MD_WR : DRBD_FAULT_MD_RD))
107
if (drbd_insert_fault(mdev, (rw & WRITE) ? DRBD_FAULT_MD_WR : DRBD_FAULT_MD_RD))
105
108
bio_endio(bio, -EIO);
106
109
else
107
110
submit_bio(rw, bio);
108
111
wait_for_completion(&md_io.event);
109
112
ok = bio_flagged(bio, BIO_UPTODATE) && md_io.error == 0;
110
113
114
#ifndef REQ_FLUSH
111
115
/* check for unsupported barrier op.
112
116
* would rather check on EOPNOTSUPP, but that is not reliable.
113
117
* don't try again for ANY return value != 0 */
114
if (unlikely((bio->bi_rw & REQ_HARDBARRIER) && !ok)) {
118
if (unlikely((bio->bi_rw & DRBD_REQ_HARDBARRIER) && !ok)) {
115
119
/* Try again with no barrier */
116
120
dev_warn(DEV, "Barriers not supported on meta data device - disabling\n");
117
121
set_bit(MD_NO_BARRIER, &mdev->flags);
118
rw &= ~REQ_HARDBARRIER;
122
rw &= ~DRBD_REQ_HARDBARRIER;
119
123
bio_put(bio);
120
124
goto retry;
121
125
}
126
#endif
122
127
out:
123
128
bio_put(bio);
124
129
return ok;
209
214
struct lc_element *al_ext;
210
215
struct lc_element *tmp;
211
216
unsigned long al_flags = 0;
217
int wake;
212
218
213
219
spin_lock_irq(&mdev->al_lock);
214
220
tmp = lc_find(mdev->resync, enr/AL_EXT_PER_BM_SECT);
215
221
if (unlikely(tmp != NULL)) {
216
222
struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce);
217
223
if (test_bit(BME_NO_WRITES, &bm_ext->flags)) {
224
wake = !test_and_set_bit(BME_PRIORITY, &bm_ext->flags);
218
225
spin_unlock_irq(&mdev->al_lock);
226
if (wake)
227
wake_up(&mdev->al_wait);
219
228
return NULL;
220
229
}
221
230
}
299
308
spin_unlock_irqrestore(&mdev->al_lock, flags);
300
309
}
301
310
311
#if (PAGE_SHIFT + 3) < (AL_EXTENT_SHIFT - BM_BLOCK_SHIFT)
312
/* Currently BM_BLOCK_SHIFT, BM_EXT_SHIFT and AL_EXTENT_SHIFT
313
* are still coupled, or assume too much about their relation.
314
* Code below will not work if this is violated.
315
* Will be cleaned up with some followup patch.
316
*/
317
# error FIXME
318
#endif
319
320
static unsigned int al_extent_to_bm_page(unsigned int al_enr)
321
{
322
return al_enr >>
323
/* bit to page */
324
((PAGE_SHIFT + 3) -
325
/* al extent number to bit */
326
(AL_EXTENT_SHIFT - BM_BLOCK_SHIFT));
327
}
328
329
static unsigned int rs_extent_to_bm_page(unsigned int rs_enr)
330
{
331
return rs_enr >>
332
/* bit to page */
333
((PAGE_SHIFT + 3) -
334
/* al extent number to bit */
335
(BM_EXT_SHIFT - BM_BLOCK_SHIFT));
336
}
337
302
338
int
303
339
w_al_write_transaction(struct drbd_conf *mdev, struct drbd_work *w, int unused)
304
340
{
326
362
* For now, we must not write the transaction,
327
363
* if we cannot write out the bitmap of the evicted extent. */
328
364
if (mdev->state.conn < C_CONNECTED && evicted != LC_FREE)
329
drbd_bm_write_sect(mdev, evicted/AL_EXT_PER_BM_SECT);
365
drbd_bm_write_page(mdev, al_extent_to_bm_page(evicted));
330
366
331
367
/* The bitmap write may have failed, causing a state change. */
332
368
if (mdev->state.disk < D_INCONSISTENT) {
375
411
+ mdev->ldev->md.al_offset + mdev->al_tr_pos;
376
412
377
413
if (!drbd_md_sync_page_io(mdev, mdev->ldev, sector, WRITE))
378
drbd_chk_io_error(mdev, 1, TRUE);
414
drbd_chk_io_error(mdev, 1, true);
379
415
380
416
if (++mdev->al_tr_pos >
381
417
div_ceil(mdev->act_log->nr_elements, AL_EXTENTS_PT))
552
588
return 1;
553
589
}
554
590
555
struct drbd_atodb_wait {
556
atomic_t count;
557
struct completion io_done;
558
struct drbd_conf *mdev;
559
int error;
560
};
561
562
STATIC BIO_ENDIO_TYPE atodb_endio BIO_ENDIO_ARGS(struct bio *bio, int error)
563
{
564
struct drbd_atodb_wait *wc = bio->bi_private;
565
struct drbd_conf *mdev = wc->mdev;
566
struct page *page;
567
int uptodate = bio_flagged(bio, BIO_UPTODATE);
568
569
BIO_ENDIO_FN_START;
570
/* strange behavior of some lower level drivers...
571
* fail the request by clearing the uptodate flag,
572
* but do not return any error?! */
573
if (!error && !uptodate)
574
error = -EIO;
575
576
drbd_chk_io_error(mdev, error, TRUE);
577
if (error && wc->error == 0)
578
wc->error = error;
579
580
if (atomic_dec_and_test(&wc->count))
581
complete(&wc->io_done);
582
583
page = bio->bi_io_vec[0].bv_page;
584
put_page(page);
585
bio_put(bio);
586
mdev->bm_writ_cnt++;
587
put_ldev(mdev);
588
589
BIO_ENDIO_FN_RETURN;
590
}
591
592
/* sector to word */
593
#define S2W(s) ((s)<<(BM_EXT_SHIFT-BM_BLOCK_SHIFT-LN2_BPL))
594
595
/* activity log to on disk bitmap -- prepare bio unless that sector
596
* is already covered by previously prepared bios */
597
STATIC int atodb_prepare_unless_covered(struct drbd_conf *mdev,
598
struct bio **bios,
599
unsigned int enr,
600
struct drbd_atodb_wait *wc) __must_hold(local)
601
{
602
struct bio *bio;
603
struct page *page;
604
sector_t on_disk_sector;
605
unsigned int page_offset = PAGE_SIZE;
606
int offset;
607
int i = 0;
608
int err = -ENOMEM;
609
610
/* We always write aligned, full 4k blocks,
611
* so we can ignore the logical_block_size (for now) */
612
enr &= ~7U;
613
on_disk_sector = enr + mdev->ldev->md.md_offset
614
+ mdev->ldev->md.bm_offset;
615
616
D_ASSERT(!(on_disk_sector & 7U));
617
618
/* Check if that enr is already covered by an already created bio.
619
* Caution, bios[] is not NULL terminated,
620
* but only initialized to all NULL.
621
* For completely scattered activity log,
622
* the last invocation iterates over all bios,
623
* and finds the last NULL entry.
624
*/
625
while ((bio = bios[i])) {
626
if (bio->bi_sector == on_disk_sector)
627
return 0;
628
i++;
629
}
630
/* bios[i] == NULL, the next not yet used slot */
631
632
/* GFP_KERNEL, we are not in the write-out path */
633
bio = bio_alloc(GFP_KERNEL, 1);
634
if (bio == NULL)
635
return -ENOMEM;
636
637
if (i > 0) {
638
const struct bio_vec *prev_bv = bios[i-1]->bi_io_vec;
639
page_offset = prev_bv->bv_offset + prev_bv->bv_len;
640
page = prev_bv->bv_page;
641
}
642
if (page_offset == PAGE_SIZE) {
643
page = alloc_page(__GFP_HIGHMEM);
644
if (page == NULL)
645
goto out_bio_put;
646
page_offset = 0;
647
} else {
648
get_page(page);
649
}
650
651
offset = S2W(enr);
652
drbd_bm_get_lel(mdev, offset,
653
min_t(size_t, S2W(8), drbd_bm_words(mdev) - offset),
654
kmap(page) + page_offset);
655
kunmap(page);
656
657
bio->bi_private = wc;
658
bio->bi_end_io = atodb_endio;
659
bio->bi_bdev = mdev->ldev->md_bdev;
660
bio->bi_sector = on_disk_sector;
661
662
if (bio_add_page(bio, page, 4096, page_offset) != 4096)
663
goto out_put_page;
664
665
atomic_inc(&wc->count);
666
/* we already know that we may do this...
667
* get_ldev_if_state(mdev,D_ATTACHING);
668
* just get the extra reference, so that the local_cnt reflects
669
* the number of pending IO requests DRBD at its backing device.
670
*/
671
atomic_inc(&mdev->local_cnt);
672
673
bios[i] = bio;
674
675
return 0;
676
677
out_put_page:
678
err = -EINVAL;
679
put_page(page);
680
out_bio_put:
681
bio_put(bio);
682
return err;
683
}
684
685
/**
686
* drbd_al_to_on_disk_bm() - * Writes bitmap parts covered by active AL extents
687
* @mdev: DRBD device.
688
*
689
* Called when we detach (unconfigure) local storage,
690
* or when we go from R_PRIMARY to R_SECONDARY role.
691
*/
692
void drbd_al_to_on_disk_bm(struct drbd_conf *mdev)
693
{
694
int i, nr_elements;
695
unsigned int enr;
696
struct bio **bios;
697
struct drbd_atodb_wait wc;
698
699
ERR_IF (!get_ldev_if_state(mdev, D_ATTACHING))
700
return; /* sorry, I don't have any act_log etc... */
701
702
wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
703
704
nr_elements = mdev->act_log->nr_elements;
705
706
/* GFP_KERNEL, we are not in anyone's write-out path */
707
bios = kzalloc(sizeof(struct bio *) * nr_elements, GFP_KERNEL);
708
if (!bios)
709
goto submit_one_by_one;
710
711
atomic_set(&wc.count, 0);
712
init_completion(&wc.io_done);
713
wc.mdev = mdev;
714
wc.error = 0;
715
716
for (i = 0; i < nr_elements; i++) {
717
enr = lc_element_by_index(mdev->act_log, i)->lc_number;
718
if (enr == LC_FREE)
719
continue;
720
/* next statement also does atomic_inc wc.count and local_cnt */
721
if (atodb_prepare_unless_covered(mdev, bios,
722
enr/AL_EXT_PER_BM_SECT,
723
&wc))
724
goto free_bios_submit_one_by_one;
725
}
726
727
/* unnecessary optimization? */
728
lc_unlock(mdev->act_log);
729
wake_up(&mdev->al_wait);
730
731
/* all prepared, submit them */
732
for (i = 0; i < nr_elements; i++) {
733
if (bios[i] == NULL)
734
break;
735
if (FAULT_ACTIVE(mdev, DRBD_FAULT_MD_WR)) {
736
bios[i]->bi_rw = WRITE;
737
bio_endio(bios[i], -EIO);
738
} else {
739
submit_bio(WRITE, bios[i]);
740
}
741
}
742
743
drbd_blk_run_queue(bdev_get_queue(mdev->ldev->md_bdev));
744
745
/* always (try to) flush bitmap to stable storage */
746
drbd_md_flush(mdev);
747
748
/* In case we did not submit a single IO do not wait for
749
* them to complete. ( Because we would wait forever here. )
750
*
751
* In case we had IOs and they are already complete, there
752
* is not point in waiting anyways.
753
* Therefore this if () ... */
754
if (atomic_read(&wc.count))
755
wait_for_completion(&wc.io_done);
756
757
put_ldev(mdev);
758
759
kfree(bios);
760
return;
761
762
free_bios_submit_one_by_one:
763
/* free everything by calling the endio callback directly. */
764
for (i = 0; i < nr_elements && bios[i]; i++)
765
bio_endio(bios[i], 0);
766
767
kfree(bios);
768
769
submit_one_by_one:
770
dev_warn(DEV, "Using the slow drbd_al_to_on_disk_bm()\n");
771
772
for (i = 0; i < mdev->act_log->nr_elements; i++) {
773
enr = lc_element_by_index(mdev->act_log, i)->lc_number;
774
if (enr == LC_FREE)
775
continue;
776
/* Really slow: if we have al-extents 16..19 active,
777
* sector 4 will be written four times! Synchronous! */
778
drbd_bm_write_sect(mdev, enr/AL_EXT_PER_BM_SECT);
779
}
780
781
lc_unlock(mdev->act_log);
782
wake_up(&mdev->al_wait);
783
put_ldev(mdev);
784
}
785
786
591
/**
787
592
* drbd_al_apply_to_bm() - Sets the bitmap to diry(1) where covered ba active AL extents
788
593
* @mdev: DRBD device.
862
667
return 1;
863
668
}
864
669
865
drbd_bm_write_sect(mdev, udw->enr);
670
drbd_bm_write_page(mdev, rs_extent_to_bm_page(udw->enr));
866
671
put_ldev(mdev);
867
672
868
673
kfree(udw);
942
747
dev_warn(DEV, "Kicking resync_lru element enr=%u "
943
748
"out with rs_failed=%d\n",
944
749
ext->lce.lc_number, ext->rs_failed);
945
set_bit(WRITE_BM_AFTER_RESYNC, &mdev->flags);
946
750
}
947
751
ext->rs_left = rs_left;
948
752
ext->rs_failed = success ? 0 : count;
961
765
drbd_queue_work_front(&mdev->data.work, &udw->w);
962
766
} else {
963
767
dev_warn(DEV, "Could not kmalloc an udw\n");
964
set_bit(WRITE_BM_AFTER_RESYNC, &mdev->flags);
965
768
}
966
769
}
967
770
} else {
972
775
}
973
776
}
974
777
778
void drbd_advance_rs_marks(struct drbd_conf *mdev, unsigned long still_to_go)
779
{
780
unsigned long now = jiffies;
781
unsigned long last = mdev->rs_mark_time[mdev->rs_last_mark];
782
int next = (mdev->rs_last_mark + 1) % DRBD_SYNC_MARKS;
783
if (time_after_eq(now, last + DRBD_SYNC_MARK_STEP)) {
784
if (mdev->rs_mark_left[mdev->rs_last_mark] != still_to_go &&
785
mdev->state.conn != C_PAUSED_SYNC_T &&
786
mdev->state.conn != C_PAUSED_SYNC_S) {
787
mdev->rs_mark_time[next] = now;
788
mdev->rs_mark_left[next] = still_to_go;
789
mdev->rs_last_mark = next;
790
}
791
}
792
}
793
975
794
/* clear the bit corresponding to the piece of storage in question:
976
795
* size byte of data starting from sector. Only clear a bits of the affected
977
796
* one ore more _aligned_ BM_BLOCK_SIZE blocks.
989
808
int wake_up = 0;
990
809
unsigned long flags;
991
810
992
if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_SEGMENT_SIZE) {
811
if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_BIO_SIZE) {
993
812
dev_err(DEV, "drbd_set_in_sync: sector=%llus size=%d nonsense!\n",
994
813
(unsigned long long)sector, size);
995
814
return;
1026
845
*/
1027
846
count = drbd_bm_clear_bits(mdev, sbnr, ebnr);
1028
847
if (count && get_ldev(mdev)) {
1029
unsigned long now = jiffies;
1030
unsigned long last = mdev->rs_mark_time[mdev->rs_last_mark];
1031
int next = (mdev->rs_last_mark + 1) % DRBD_SYNC_MARKS;
1032
if (time_after_eq(now, last + DRBD_SYNC_MARK_STEP)) {
1033
unsigned long tw = drbd_bm_total_weight(mdev);
1034
if (mdev->rs_mark_left[mdev->rs_last_mark] != tw &&
1035
mdev->state.conn != C_PAUSED_SYNC_T &&
1036
mdev->state.conn != C_PAUSED_SYNC_S) {
1037
mdev->rs_mark_time[next] = now;
1038
mdev->rs_mark_left[next] = tw;
1039
mdev->rs_last_mark = next;
1040
}
1041
}
848
drbd_advance_rs_marks(mdev, drbd_bm_total_weight(mdev));
1042
849
spin_lock_irqsave(&mdev->al_lock, flags);
1043
drbd_try_clear_on_disk_bm(mdev, sector, count, TRUE);
850
drbd_try_clear_on_disk_bm(mdev, sector, count, true);
1044
851
spin_unlock_irqrestore(&mdev->al_lock, flags);
1045
852
1046
853
/* just wake_up unconditional now, various lc_chaged(),
1055
862
/*
1056
863
* this is intended to set one request worth of data out of sync.
1057
864
* affects at least 1 bit,
1058
* and at most 1+DRBD_MAX_SEGMENT_SIZE/BM_BLOCK_SIZE bits.
865
* and at most 1+DRBD_MAX_BIO_SIZE/BM_BLOCK_SIZE bits.
1059
866
*
1060
867
* called by tl_clear and drbd_send_dblock (==drbd_make_request).
1061
868
* so this can be _any_ process.
1062
869
*/
1063
void __drbd_set_out_of_sync(struct drbd_conf *mdev, sector_t sector, int size,
870
int __drbd_set_out_of_sync(struct drbd_conf *mdev, sector_t sector, int size,
1064
871
const char *file, const unsigned int line)
1065
872
{
1066
873
unsigned long sbnr, ebnr, lbnr, flags;
1067
874
sector_t esector, nr_sectors;
1068
unsigned int enr, count;
875
unsigned int enr, count = 0;
1069
876
struct lc_element *e;
1070
877
1071
if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_SEGMENT_SIZE) {
878
if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_BIO_SIZE) {
1072
879
dev_err(DEV, "sector: %llus, size: %d\n",
1073
880
(unsigned long long)sector, size);
1074
return;
881
return 0;
1075
882
}
1076
883
1077
884
if (!get_ldev(mdev))
1078
return; /* no disk, no metadata, no bitmap to set bits in */
885
return 0; /* no disk, no metadata, no bitmap to set bits in */
1079
886
1080
887
nr_sectors = drbd_get_capacity(mdev->this_bdev);
1081
888
esector = sector + (size >> 9) - 1;
1109
916
1110
917
out:
1111
918
put_ldev(mdev);
919
920
return count;
1112
921
}
1113
922
1114
923
static
1189
998
unsigned int enr = BM_SECT_TO_EXT(sector);
1190
999
struct bm_extent *bm_ext;
1191
1000
int i, sig;
1001
int sa = 200; /* Step aside 200 times, then grab the extent and let app-IO wait.
1002
200 times -> 20 seconds. */
1192
1003
1193
1004
trace_drbd_resync(mdev, TRACE_LVL_ALL,
1194
1005
"drbd_rs_begin_io: sector=%llus (rs_end=%d)\n",
1195
1006
(unsigned long long)sector, enr);
1196
1007
retry:
1197
1008
sig = wait_event_interruptible(mdev->al_wait,
1198
1009
(bm_ext = _bme_get(mdev, enr)));
1199
1010
if (sig)
1204
1015
1205
1016
for (i = 0; i < AL_EXT_PER_BM_SECT; i++) {
1206
1017
sig = wait_event_interruptible(mdev->al_wait,
1207
!_is_in_al(mdev, enr * AL_EXT_PER_BM_SECT + i));
1208
if (sig) {
1018
!_is_in_al(mdev, enr * AL_EXT_PER_BM_SECT + i) ||
1019
test_bit(BME_PRIORITY, &bm_ext->flags));
1020
1021
if (sig || (test_bit(BME_PRIORITY, &bm_ext->flags) && sa)) {
1209
1022
spin_lock_irq(&mdev->al_lock);
1210
1023
if (lc_put(mdev->resync, &bm_ext->lce) == 0) {
1211
clear_bit(BME_NO_WRITES, &bm_ext->flags);
1024
bm_ext->flags = 0; /* clears BME_NO_WRITES and eventually BME_PRIORITY */
1212
1025
mdev->resync_locked--;
1213
1026
wake_up(&mdev->al_wait);
1214
1027
}
1215
1028
spin_unlock_irq(&mdev->al_lock);
1216
return -EINTR;
1029
if (sig)
1030
return -EINTR;
1031
if (schedule_timeout_interruptible(HZ/10))
1032
return -EINTR;
1033
if (sa && --sa == 0)
1034
dev_warn(DEV,"drbd_rs_begin_io() stepped aside for 20sec."
1035
"Resync stalled?\n");
1036
goto retry;
1217
1037
}
1218
1038
}
1219
1039
set_bit(BME_LOCKED, &bm_ext->flags);
1378
1198
}
1379
1199
1380
1200
if (lc_put(mdev->resync, &bm_ext->lce) == 0) {
1381
clear_bit(BME_LOCKED, &bm_ext->flags);
1382
clear_bit(BME_NO_WRITES, &bm_ext->flags);
1201
bm_ext->flags = 0; /* clear BME_LOCKED, BME_NO_WRITES and BME_PRIORITY */
1383
1202
mdev->resync_locked--;
1384
1203
wake_up(&mdev->al_wait);
1385
1204
}
1478
1297
"drbd_rs_failed_io: sector=%llus, size=%u\n",
1479
1298
(unsigned long long)sector, size);
1480
1299
1481
if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_SEGMENT_SIZE) {
1300
if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_BIO_SIZE) {
1482
1301
dev_err(DEV, "drbd_rs_failed_io: sector=%llus size=%d nonsense!\n",
1483
1302
(unsigned long long)sector, size);
1484
1303
return;
1515
1334
mdev->rs_failed += count;
1516
1335
1517
1336
if (get_ldev(mdev)) {
1518
drbd_try_clear_on_disk_bm(mdev, sector, count, FALSE);
1337
drbd_try_clear_on_disk_bm(mdev, sector, count, false);
1519
1338
put_ldev(mdev);
1520
1339
}
1521
1340
Loggerhead is a web-based interface for Breezy
Version: 2.0.1