1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include <linux/module.h>
27
28#include <linux/slab.h>
29#include <linux/drbd.h>
30#include "drbd_int.h"
31#include "drbd_req.h"
32
33
34
35static void _drbd_start_io_acct(struct drbd_conf *mdev, struct drbd_request *req, struct bio *bio)
36{
37 const int rw = bio_data_dir(bio);
38 int cpu;
39 cpu = part_stat_lock();
40 part_stat_inc(cpu, &mdev->vdisk->part0, ios[rw]);
41 part_stat_add(cpu, &mdev->vdisk->part0, sectors[rw], bio_sectors(bio));
42 part_inc_in_flight(&mdev->vdisk->part0, rw);
43 part_stat_unlock();
44}
45
46
47static void _drbd_end_io_acct(struct drbd_conf *mdev, struct drbd_request *req)
48{
49 int rw = bio_data_dir(req->master_bio);
50 unsigned long duration = jiffies - req->start_time;
51 int cpu;
52 cpu = part_stat_lock();
53 part_stat_add(cpu, &mdev->vdisk->part0, ticks[rw], duration);
54 part_round_stats(cpu, &mdev->vdisk->part0);
55 part_dec_in_flight(&mdev->vdisk->part0, rw);
56 part_stat_unlock();
57}
58
59static void _req_is_done(struct drbd_conf *mdev, struct drbd_request *req, const int rw)
60{
61 const unsigned long s = req->rq_state;
62
63
64
65
66
67
68
69 list_del(&req->tl_requests);
70
71
72
73
74 if (rw == WRITE) {
75
76
77
78
79 if (!(s & RQ_NET_OK) || !(s & RQ_LOCAL_OK))
80 drbd_set_out_of_sync(mdev, req->sector, req->size);
81
82 if ((s & RQ_NET_OK) && (s & RQ_LOCAL_OK) && (s & RQ_NET_SIS))
83 drbd_set_in_sync(mdev, req->sector, req->size);
84
85
86
87
88
89
90
91
92
93
94
95 if (s & RQ_LOCAL_MASK) {
96 if (get_ldev_if_state(mdev, D_FAILED)) {
97 if (s & RQ_IN_ACT_LOG)
98 drbd_al_complete_io(mdev, req->sector);
99 put_ldev(mdev);
100 } else if (__ratelimit(&drbd_ratelimit_state)) {
101 dev_warn(DEV, "Should have called drbd_al_complete_io(, %llu), "
102 "but my Disk seems to have failed :(\n",
103 (unsigned long long) req->sector);
104 }
105 }
106 }
107
108 drbd_req_free(req);
109}
110
111static void queue_barrier(struct drbd_conf *mdev)
112{
113 struct drbd_tl_epoch *b;
114
115
116
117
118
119
120 if (test_bit(CREATE_BARRIER, &mdev->flags))
121 return;
122
123 b = mdev->newest_tle;
124 b->w.cb = w_send_barrier;
125
126
127
128
129 inc_ap_pending(mdev);
130 drbd_queue_work(&mdev->data.work, &b->w);
131 set_bit(CREATE_BARRIER, &mdev->flags);
132}
133
134static void _about_to_complete_local_write(struct drbd_conf *mdev,
135 struct drbd_request *req)
136{
137 const unsigned long s = req->rq_state;
138 struct drbd_request *i;
139 struct drbd_epoch_entry *e;
140 struct hlist_node *n;
141 struct hlist_head *slot;
142
143
144
145 if (mdev->state.conn >= C_CONNECTED &&
146 req->epoch == mdev->newest_tle->br_number)
147 queue_barrier(mdev);
148
149
150
151
152 if ((s & RQ_NET_DONE) && mdev->ee_hash != NULL) {
153 const sector_t sector = req->sector;
154 const int size = req->size;
155
156
157
158
159#define OVERLAPS overlaps(sector, size, i->sector, i->size)
160 slot = tl_hash_slot(mdev, sector);
161 hlist_for_each_entry(i, n, slot, colision) {
162 if (OVERLAPS) {
163 dev_alert(DEV, "LOGIC BUG: completed: %p %llus +%u; "
164 "other: %p %llus +%u\n",
165 req, (unsigned long long)sector, size,
166 i, (unsigned long long)i->sector, i->size);
167 }
168 }
169
170
171
172
173
174
175
176
177
178
179
180
181
182#undef OVERLAPS
183#define OVERLAPS overlaps(sector, size, e->sector, e->size)
184 slot = ee_hash_slot(mdev, req->sector);
185 hlist_for_each_entry(e, n, slot, colision) {
186 if (OVERLAPS) {
187 wake_up(&mdev->misc_wait);
188 break;
189 }
190 }
191 }
192#undef OVERLAPS
193}
194
195void complete_master_bio(struct drbd_conf *mdev,
196 struct bio_and_error *m)
197{
198 bio_endio(m->bio, m->error);
199 dec_ap_bio(mdev);
200}
201
202
203
204
205
206
207
208void _req_may_be_done(struct drbd_request *req, struct bio_and_error *m)
209{
210 const unsigned long s = req->rq_state;
211 struct drbd_conf *mdev = req->mdev;
212
213 int rw = req->master_bio ? bio_data_dir(req->master_bio) : WRITE;
214
215
216
217
218
219
220
221
222
223
224 if (s & RQ_NET_QUEUED)
225 return;
226 if (s & RQ_NET_PENDING)
227 return;
228 if (s & RQ_LOCAL_PENDING)
229 return;
230
231 if (req->master_bio) {
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253 int ok = (s & RQ_LOCAL_OK) || (s & RQ_NET_OK);
254 int error = PTR_ERR(req->private_bio);
255
256
257
258 if (!hlist_unhashed(&req->colision))
259 hlist_del(&req->colision);
260 else
261 D_ASSERT((s & (RQ_NET_MASK & ~RQ_NET_DONE)) == 0);
262
263
264 if (rw == WRITE)
265 _about_to_complete_local_write(mdev, req);
266
267
268 _drbd_end_io_acct(mdev, req);
269
270 m->error = ok ? 0 : (error ?: -EIO);
271 m->bio = req->master_bio;
272 req->master_bio = NULL;
273 }
274
275 if ((s & RQ_NET_MASK) == 0 || (s & RQ_NET_DONE)) {
276
277
278
279
280 _req_is_done(mdev, req, rw);
281 }
282
283
284}
285
286static void _req_may_be_done_not_susp(struct drbd_request *req, struct bio_and_error *m)
287{
288 struct drbd_conf *mdev = req->mdev;
289
290 if (!is_susp(mdev->state))
291 _req_may_be_done(req, m);
292}
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317static int _req_conflicts(struct drbd_request *req)
318{
319 struct drbd_conf *mdev = req->mdev;
320 const sector_t sector = req->sector;
321 const int size = req->size;
322 struct drbd_request *i;
323 struct drbd_epoch_entry *e;
324 struct hlist_node *n;
325 struct hlist_head *slot;
326
327 D_ASSERT(hlist_unhashed(&req->colision));
328
329 if (!get_net_conf(mdev))
330 return 0;
331
332
333 ERR_IF (mdev->tl_hash_s == 0)
334 goto out_no_conflict;
335 BUG_ON(mdev->tl_hash == NULL);
336
337#define OVERLAPS overlaps(i->sector, i->size, sector, size)
338 slot = tl_hash_slot(mdev, sector);
339 hlist_for_each_entry(i, n, slot, colision) {
340 if (OVERLAPS) {
341 dev_alert(DEV, "%s[%u] Concurrent local write detected! "
342 "[DISCARD L] new: %llus +%u; "
343 "pending: %llus +%u\n",
344 current->comm, current->pid,
345 (unsigned long long)sector, size,
346 (unsigned long long)i->sector, i->size);
347 goto out_conflict;
348 }
349 }
350
351 if (mdev->ee_hash_s) {
352
353 BUG_ON(mdev->ee_hash == NULL);
354#undef OVERLAPS
355#define OVERLAPS overlaps(e->sector, e->size, sector, size)
356 slot = ee_hash_slot(mdev, sector);
357 hlist_for_each_entry(e, n, slot, colision) {
358 if (OVERLAPS) {
359 dev_alert(DEV, "%s[%u] Concurrent remote write detected!"
360 " [DISCARD L] new: %llus +%u; "
361 "pending: %llus +%u\n",
362 current->comm, current->pid,
363 (unsigned long long)sector, size,
364 (unsigned long long)e->sector, e->size);
365 goto out_conflict;
366 }
367 }
368 }
369#undef OVERLAPS
370
371out_no_conflict:
372
373
374 put_net_conf(mdev);
375 return 0;
376
377out_conflict:
378 put_net_conf(mdev);
379 return 1;
380}
381
382
383
384
385
386
387
388
389
390
391
392
393
394int __req_mod(struct drbd_request *req, enum drbd_req_event what,
395 struct bio_and_error *m)
396{
397 struct drbd_conf *mdev = req->mdev;
398 int rv = 0;
399 m->bio = NULL;
400
401 switch (what) {
402 default:
403 dev_err(DEV, "LOGIC BUG in %s:%u\n", __FILE__ , __LINE__);
404 break;
405
406
407
408
409
410
411
412 case to_be_send:
413
414
415 D_ASSERT(!(req->rq_state & RQ_NET_MASK));
416 req->rq_state |= RQ_NET_PENDING;
417 inc_ap_pending(mdev);
418 break;
419
420 case to_be_submitted:
421
422 D_ASSERT(!(req->rq_state & RQ_LOCAL_MASK));
423 req->rq_state |= RQ_LOCAL_PENDING;
424 break;
425
426 case completed_ok:
427 if (bio_data_dir(req->master_bio) == WRITE)
428 mdev->writ_cnt += req->size>>9;
429 else
430 mdev->read_cnt += req->size>>9;
431
432 req->rq_state |= (RQ_LOCAL_COMPLETED|RQ_LOCAL_OK);
433 req->rq_state &= ~RQ_LOCAL_PENDING;
434
435 _req_may_be_done_not_susp(req, m);
436 put_ldev(mdev);
437 break;
438
439 case write_completed_with_error:
440 req->rq_state |= RQ_LOCAL_COMPLETED;
441 req->rq_state &= ~RQ_LOCAL_PENDING;
442
443 __drbd_chk_io_error(mdev, FALSE);
444 _req_may_be_done_not_susp(req, m);
445 put_ldev(mdev);
446 break;
447
448 case read_ahead_completed_with_error:
449
450 req->rq_state |= RQ_LOCAL_COMPLETED;
451 req->rq_state &= ~RQ_LOCAL_PENDING;
452 _req_may_be_done_not_susp(req, m);
453 put_ldev(mdev);
454 break;
455
456 case read_completed_with_error:
457 drbd_set_out_of_sync(mdev, req->sector, req->size);
458
459 req->rq_state |= RQ_LOCAL_COMPLETED;
460 req->rq_state &= ~RQ_LOCAL_PENDING;
461
462 D_ASSERT(!(req->rq_state & RQ_NET_MASK));
463
464 __drbd_chk_io_error(mdev, FALSE);
465 put_ldev(mdev);
466
467
468
469 if (mdev->state.pdsk != D_UP_TO_DATE) {
470 _req_may_be_done_not_susp(req, m);
471 break;
472 }
473
474
475 req->rq_state |= RQ_NET_PENDING;
476 inc_ap_pending(mdev);
477
478
479 case queue_for_net_read:
480
481
482
483
484
485
486
487
488
489 hlist_add_head(&req->colision, ar_hash_slot(mdev, req->sector));
490
491 set_bit(UNPLUG_REMOTE, &mdev->flags);
492
493 D_ASSERT(req->rq_state & RQ_NET_PENDING);
494 req->rq_state |= RQ_NET_QUEUED;
495 req->w.cb = (req->rq_state & RQ_LOCAL_MASK)
496 ? w_read_retry_remote
497 : w_send_read_req;
498 drbd_queue_work(&mdev->data.work, &req->w);
499 break;
500
501 case queue_for_net_write:
502
503
504
505 hlist_add_head(&req->colision, tl_hash_slot(mdev, req->sector));
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525 set_bit(UNPLUG_REMOTE, &mdev->flags);
526
527
528
529 D_ASSERT(test_bit(CREATE_BARRIER, &mdev->flags) == 0);
530
531 req->epoch = mdev->newest_tle->br_number;
532
533
534 mdev->newest_tle->n_writes++;
535
536
537 D_ASSERT(req->rq_state & RQ_NET_PENDING);
538 req->rq_state |= RQ_NET_QUEUED;
539 req->w.cb = w_send_dblock;
540 drbd_queue_work(&mdev->data.work, &req->w);
541
542
543 if (mdev->newest_tle->n_writes >= mdev->net_conf->max_epoch_size)
544 queue_barrier(mdev);
545
546 break;
547
548 case send_canceled:
549
550 case send_failed:
551
552
553 req->rq_state &= ~RQ_NET_QUEUED;
554
555
556 _req_may_be_done_not_susp(req, m);
557 break;
558
559 case handed_over_to_network:
560
561 if (bio_data_dir(req->master_bio) == WRITE &&
562 mdev->net_conf->wire_protocol == DRBD_PROT_A) {
563
564
565 if (req->rq_state & RQ_NET_PENDING) {
566 dec_ap_pending(mdev);
567 req->rq_state &= ~RQ_NET_PENDING;
568 req->rq_state |= RQ_NET_OK;
569 }
570
571
572
573 }
574 req->rq_state &= ~RQ_NET_QUEUED;
575 req->rq_state |= RQ_NET_SENT;
576
577
578
579
580
581 _req_may_be_done_not_susp(req, m);
582 break;
583
584 case read_retry_remote_canceled:
585 req->rq_state &= ~RQ_NET_QUEUED;
586
587 case connection_lost_while_pending:
588
589
590 if (req->rq_state & RQ_NET_PENDING)
591 dec_ap_pending(mdev);
592 req->rq_state &= ~(RQ_NET_OK|RQ_NET_PENDING);
593 req->rq_state |= RQ_NET_DONE;
594
595
596 if (!(req->rq_state & RQ_NET_QUEUED))
597 _req_may_be_done(req, m);
598 break;
599
600 case write_acked_by_peer_and_sis:
601 req->rq_state |= RQ_NET_SIS;
602 case conflict_discarded_by_peer:
603
604
605
606 if (what == conflict_discarded_by_peer)
607 dev_alert(DEV, "Got DiscardAck packet %llus +%u!"
608 " DRBD is not a random data generator!\n",
609 (unsigned long long)req->sector, req->size);
610 req->rq_state |= RQ_NET_DONE;
611
612 case write_acked_by_peer:
613
614
615
616
617
618
619
620
621
622
623
624 case recv_acked_by_peer:
625
626
627
628 req->rq_state |= RQ_NET_OK;
629 D_ASSERT(req->rq_state & RQ_NET_PENDING);
630 dec_ap_pending(mdev);
631 req->rq_state &= ~RQ_NET_PENDING;
632 _req_may_be_done_not_susp(req, m);
633 break;
634
635 case neg_acked:
636
637 if (req->rq_state & RQ_NET_PENDING)
638 dec_ap_pending(mdev);
639 req->rq_state &= ~(RQ_NET_OK|RQ_NET_PENDING);
640
641 req->rq_state |= RQ_NET_DONE;
642 _req_may_be_done_not_susp(req, m);
643
644 break;
645
646 case fail_frozen_disk_io:
647 if (!(req->rq_state & RQ_LOCAL_COMPLETED))
648 break;
649
650 _req_may_be_done(req, m);
651 break;
652
653 case restart_frozen_disk_io:
654 if (!(req->rq_state & RQ_LOCAL_COMPLETED))
655 break;
656
657 req->rq_state &= ~RQ_LOCAL_COMPLETED;
658
659 rv = MR_READ;
660 if (bio_data_dir(req->master_bio) == WRITE)
661 rv = MR_WRITE;
662
663 get_ldev(mdev);
664 req->w.cb = w_restart_disk_io;
665 drbd_queue_work(&mdev->data.work, &req->w);
666 break;
667
668 case resend:
669
670
671
672
673 if (!(req->rq_state & RQ_NET_OK)) {
674 if (req->w.cb) {
675 drbd_queue_work(&mdev->data.work, &req->w);
676 rv = req->rq_state & RQ_WRITE ? MR_WRITE : MR_READ;
677 }
678 break;
679 }
680
681
682 case barrier_acked:
683 if (!(req->rq_state & RQ_WRITE))
684 break;
685
686 if (req->rq_state & RQ_NET_PENDING) {
687
688
689
690 dev_err(DEV, "FIXME (barrier_acked but pending)\n");
691 list_move(&req->tl_requests, &mdev->out_of_sequence_requests);
692 }
693 D_ASSERT(req->rq_state & RQ_NET_SENT);
694 req->rq_state |= RQ_NET_DONE;
695 _req_may_be_done(req, m);
696 break;
697
698 case data_received:
699 D_ASSERT(req->rq_state & RQ_NET_PENDING);
700 dec_ap_pending(mdev);
701 req->rq_state &= ~RQ_NET_PENDING;
702 req->rq_state |= (RQ_NET_OK|RQ_NET_DONE);
703 _req_may_be_done_not_susp(req, m);
704 break;
705 };
706
707 return rv;
708}
709
710
711
712
713
714
715
716
717static int drbd_may_do_local_read(struct drbd_conf *mdev, sector_t sector, int size)
718{
719 unsigned long sbnr, ebnr;
720 sector_t esector, nr_sectors;
721
722 if (mdev->state.disk == D_UP_TO_DATE)
723 return 1;
724 if (mdev->state.disk >= D_OUTDATED)
725 return 0;
726 if (mdev->state.disk < D_INCONSISTENT)
727 return 0;
728
729 nr_sectors = drbd_get_capacity(mdev->this_bdev);
730 esector = sector + (size >> 9) - 1;
731
732 D_ASSERT(sector < nr_sectors);
733 D_ASSERT(esector < nr_sectors);
734
735 sbnr = BM_SECT_TO_BIT(sector);
736 ebnr = BM_SECT_TO_BIT(esector);
737
738 return 0 == drbd_bm_count_bits(mdev, sbnr, ebnr);
739}
740
741static int drbd_make_request_common(struct drbd_conf *mdev, struct bio *bio)
742{
743 const int rw = bio_rw(bio);
744 const int size = bio->bi_size;
745 const sector_t sector = bio->bi_sector;
746 struct drbd_tl_epoch *b = NULL;
747 struct drbd_request *req;
748 int local, remote;
749 int err = -EIO;
750 int ret = 0;
751
752
753 req = drbd_req_new(mdev, bio);
754 if (!req) {
755 dec_ap_bio(mdev);
756
757
758 dev_err(DEV, "could not kmalloc() req\n");
759 bio_endio(bio, -ENOMEM);
760 return 0;
761 }
762
763 local = get_ldev(mdev);
764 if (!local) {
765 bio_put(req->private_bio);
766 req->private_bio = NULL;
767 }
768 if (rw == WRITE) {
769 remote = 1;
770 } else {
771
772 if (local) {
773 if (!drbd_may_do_local_read(mdev, sector, size)) {
774
775
776
777
778
779 local = 0;
780 bio_put(req->private_bio);
781 req->private_bio = NULL;
782 put_ldev(mdev);
783 }
784 }
785 remote = !local && mdev->state.pdsk >= D_UP_TO_DATE;
786 }
787
788
789
790
791
792
793
794
795
796 if (rw == READA && mdev->state.disk >= D_INCONSISTENT && !local) {
797 err = -EWOULDBLOCK;
798 goto fail_and_free_req;
799 }
800
801
802
803
804
805
806 if (rw == WRITE && local && !test_bit(AL_SUSPENDED, &mdev->flags)) {
807 req->rq_state |= RQ_IN_ACT_LOG;
808 drbd_al_begin_io(mdev, sector);
809 }
810
811 remote = remote && (mdev->state.pdsk == D_UP_TO_DATE ||
812 (mdev->state.pdsk == D_INCONSISTENT &&
813 mdev->state.conn >= C_CONNECTED));
814
815 if (!(local || remote) && !is_susp(mdev->state)) {
816 if (__ratelimit(&drbd_ratelimit_state))
817 dev_err(DEV, "IO ERROR: neither local nor remote disk\n");
818 goto fail_free_complete;
819 }
820
821
822
823
824
825
826
827 if (rw == WRITE && remote &&
828 mdev->unused_spare_tle == NULL &&
829 test_bit(CREATE_BARRIER, &mdev->flags)) {
830allocate_barrier:
831 b = kmalloc(sizeof(struct drbd_tl_epoch), GFP_NOIO);
832 if (!b) {
833 dev_err(DEV, "Failed to alloc barrier.\n");
834 err = -ENOMEM;
835 goto fail_free_complete;
836 }
837 }
838
839
840 spin_lock_irq(&mdev->req_lock);
841
842 if (is_susp(mdev->state)) {
843
844
845
846
847 ret = 1;
848 spin_unlock_irq(&mdev->req_lock);
849 goto fail_free_complete;
850 }
851
852 if (remote) {
853 remote = (mdev->state.pdsk == D_UP_TO_DATE ||
854 (mdev->state.pdsk == D_INCONSISTENT &&
855 mdev->state.conn >= C_CONNECTED));
856 if (!remote)
857 dev_warn(DEV, "lost connection while grabbing the req_lock!\n");
858 if (!(local || remote)) {
859 dev_err(DEV, "IO ERROR: neither local nor remote disk\n");
860 spin_unlock_irq(&mdev->req_lock);
861 goto fail_free_complete;
862 }
863 }
864
865 if (b && mdev->unused_spare_tle == NULL) {
866 mdev->unused_spare_tle = b;
867 b = NULL;
868 }
869 if (rw == WRITE && remote &&
870 mdev->unused_spare_tle == NULL &&
871 test_bit(CREATE_BARRIER, &mdev->flags)) {
872
873
874 spin_unlock_irq(&mdev->req_lock);
875 goto allocate_barrier;
876 }
877
878
879
880 _drbd_start_io_acct(mdev, req, bio);
881
882
883
884
885
886
887
888
889
890
891
892 if (remote && mdev->unused_spare_tle &&
893 test_and_clear_bit(CREATE_BARRIER, &mdev->flags)) {
894 _tl_add_barrier(mdev, mdev->unused_spare_tle);
895 mdev->unused_spare_tle = NULL;
896 } else {
897 D_ASSERT(!(remote && rw == WRITE &&
898 test_bit(CREATE_BARRIER, &mdev->flags)));
899 }
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916 if (remote)
917 _req_mod(req, to_be_send);
918 if (local)
919 _req_mod(req, to_be_submitted);
920
921
922
923
924 if (rw == WRITE && _req_conflicts(req))
925 goto fail_conflicting;
926
927 list_add_tail(&req->tl_requests, &mdev->newest_tle->requests);
928
929
930
931 if (remote) {
932
933
934
935
936 _req_mod(req, (rw == WRITE)
937 ? queue_for_net_write
938 : queue_for_net_read);
939 }
940 spin_unlock_irq(&mdev->req_lock);
941 kfree(b);
942
943 if (local) {
944 req->private_bio->bi_bdev = mdev->ldev->backing_bdev;
945
946
947
948
949
950
951 if (get_ldev(mdev)) {
952 if (FAULT_ACTIVE(mdev, rw == WRITE ? DRBD_FAULT_DT_WR
953 : rw == READ ? DRBD_FAULT_DT_RD
954 : DRBD_FAULT_DT_RA))
955 bio_endio(req->private_bio, -EIO);
956 else
957 generic_make_request(req->private_bio);
958 put_ldev(mdev);
959 } else
960 bio_endio(req->private_bio, -EIO);
961 }
962
963
964
965 drbd_plug_device(mdev);
966
967 return 0;
968
969fail_conflicting:
970
971
972
973
974
975
976 _drbd_end_io_acct(mdev, req);
977 spin_unlock_irq(&mdev->req_lock);
978 if (remote)
979 dec_ap_pending(mdev);
980
981
982 err = 0;
983
984fail_free_complete:
985 if (rw == WRITE && local)
986 drbd_al_complete_io(mdev, sector);
987fail_and_free_req:
988 if (local) {
989 bio_put(req->private_bio);
990 req->private_bio = NULL;
991 put_ldev(mdev);
992 }
993 if (!ret)
994 bio_endio(bio, err);
995
996 drbd_req_free(req);
997 dec_ap_bio(mdev);
998 kfree(b);
999
1000 return ret;
1001}
1002
1003
1004
1005
1006
1007
1008static int drbd_fail_request_early(struct drbd_conf *mdev, int is_write)
1009{
1010 if (mdev->state.role != R_PRIMARY &&
1011 (!allow_oos || is_write)) {
1012 if (__ratelimit(&drbd_ratelimit_state)) {
1013 dev_err(DEV, "Process %s[%u] tried to %s; "
1014 "since we are not in Primary state, "
1015 "we cannot allow this\n",
1016 current->comm, current->pid,
1017 is_write ? "WRITE" : "READ");
1018 }
1019 return 1;
1020 }
1021
1022 return 0;
1023}
1024
1025int drbd_make_request_26(struct request_queue *q, struct bio *bio)
1026{
1027 unsigned int s_enr, e_enr;
1028 struct drbd_conf *mdev = (struct drbd_conf *) q->queuedata;
1029
1030 if (drbd_fail_request_early(mdev, bio_data_dir(bio) & WRITE)) {
1031 bio_endio(bio, -EPERM);
1032 return 0;
1033 }
1034
1035
1036
1037
1038 D_ASSERT(bio->bi_size > 0);
1039 D_ASSERT((bio->bi_size & 0x1ff) == 0);
1040 D_ASSERT(bio->bi_idx == 0);
1041
1042
1043
1044 s_enr = bio->bi_sector >> HT_SHIFT;
1045 e_enr = (bio->bi_sector+(bio->bi_size>>9)-1) >> HT_SHIFT;
1046
1047 if (likely(s_enr == e_enr)) {
1048 inc_ap_bio(mdev, 1);
1049 return drbd_make_request_common(mdev, bio);
1050 }
1051
1052
1053
1054 if (bio->bi_vcnt != 1 || bio->bi_idx != 0 || bio->bi_size > DRBD_MAX_SEGMENT_SIZE) {
1055
1056 dev_err(DEV, "bio would need to, but cannot, be split: "
1057 "(vcnt=%u,idx=%u,size=%u,sector=%llu)\n",
1058 bio->bi_vcnt, bio->bi_idx, bio->bi_size,
1059 (unsigned long long)bio->bi_sector);
1060 bio_endio(bio, -EINVAL);
1061 } else {
1062
1063 struct bio_pair *bp;
1064
1065
1066
1067
1068
1069
1070
1071
1072 const sector_t sect = bio->bi_sector;
1073 const int sps = 1 << HT_SHIFT;
1074 const int mask = sps - 1;
1075 const sector_t first_sectors = sps - (sect & mask);
1076 bp = bio_split(bio,
1077#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
1078 bio_split_pool,
1079#endif
1080 first_sectors);
1081
1082
1083
1084
1085
1086
1087 inc_ap_bio(mdev, 3);
1088
1089 D_ASSERT(e_enr == s_enr + 1);
1090
1091 while (drbd_make_request_common(mdev, &bp->bio1))
1092 inc_ap_bio(mdev, 1);
1093
1094 while (drbd_make_request_common(mdev, &bp->bio2))
1095 inc_ap_bio(mdev, 1);
1096
1097 dec_ap_bio(mdev);
1098
1099 bio_pair_release(bp);
1100 }
1101 return 0;
1102}
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117int drbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bvm, struct bio_vec *bvec)
1118{
1119 struct drbd_conf *mdev = (struct drbd_conf *) q->queuedata;
1120 unsigned int bio_offset =
1121 (unsigned int)bvm->bi_sector << 9;
1122 unsigned int bio_size = bvm->bi_size;
1123 int limit, backing_limit;
1124
1125 limit = DRBD_MAX_SEGMENT_SIZE
1126 - ((bio_offset & (DRBD_MAX_SEGMENT_SIZE-1)) + bio_size);
1127 if (limit < 0)
1128 limit = 0;
1129 if (bio_size == 0) {
1130 if (limit <= bvec->bv_len)
1131 limit = bvec->bv_len;
1132 } else if (limit && get_ldev(mdev)) {
1133 struct request_queue * const b =
1134 mdev->ldev->backing_bdev->bd_disk->queue;
1135 if (b->merge_bvec_fn) {
1136 backing_limit = b->merge_bvec_fn(b, bvm, bvec);
1137 limit = min(limit, backing_limit);
1138 }
1139 put_ldev(mdev);
1140 }
1141 return limit;
1142}
1143