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#ifndef _DRBD_INT_H
27#define _DRBD_INT_H
28
29#include <linux/compiler.h>
30#include <linux/types.h>
31#include <linux/list.h>
32#include <linux/sched.h>
33#include <linux/bitops.h>
34#include <linux/slab.h>
35#include <linux/crypto.h>
36#include <linux/ratelimit.h>
37#include <linux/tcp.h>
38#include <linux/mutex.h>
39#include <linux/major.h>
40#include <linux/blkdev.h>
41#include <linux/genhd.h>
42#include <linux/idr.h>
43#include <net/tcp.h>
44#include <linux/lru_cache.h>
45#include <linux/prefetch.h>
46#include <linux/drbd_genl_api.h>
47#include <linux/drbd.h>
48#include "drbd_state.h"
49
50#ifdef __CHECKER__
51# define __protected_by(x) __attribute__((require_context(x,1,999,"rdwr")))
52# define __protected_read_by(x) __attribute__((require_context(x,1,999,"read")))
53# define __protected_write_by(x) __attribute__((require_context(x,1,999,"write")))
54# define __must_hold(x) __attribute__((context(x,1,1), require_context(x,1,999,"call")))
55#else
56# define __protected_by(x)
57# define __protected_read_by(x)
58# define __protected_write_by(x)
59# define __must_hold(x)
60#endif
61
62#define __no_warn(lock, stmt) do { __acquire(lock); stmt; __release(lock); } while (0)
63
64
65extern unsigned int minor_count;
66extern bool disable_sendpage;
67extern bool allow_oos;
68
69#ifdef CONFIG_DRBD_FAULT_INJECTION
70extern int enable_faults;
71extern int fault_rate;
72extern int fault_devs;
73#endif
74
75extern char usermode_helper[];
76
77
78
79
80
81
82
83#define DRBD_SIG SIGXCPU
84
85
86
87
88
89
90#define DRBD_SIGKILL SIGHUP
91
92#define ID_IN_SYNC (4711ULL)
93#define ID_OUT_OF_SYNC (4712ULL)
94#define ID_SYNCER (-1ULL)
95
96#define UUID_NEW_BM_OFFSET ((u64)0x0001000000000000ULL)
97
98struct drbd_conf;
99struct drbd_tconn;
100
101
102
103#define DEV (disk_to_dev(mdev->vdisk))
104
105#define conn_printk(LEVEL, TCONN, FMT, ARGS...) \
106 printk(LEVEL "d-con %s: " FMT, TCONN->name , ## ARGS)
107#define conn_alert(TCONN, FMT, ARGS...) conn_printk(KERN_ALERT, TCONN, FMT, ## ARGS)
108#define conn_crit(TCONN, FMT, ARGS...) conn_printk(KERN_CRIT, TCONN, FMT, ## ARGS)
109#define conn_err(TCONN, FMT, ARGS...) conn_printk(KERN_ERR, TCONN, FMT, ## ARGS)
110#define conn_warn(TCONN, FMT, ARGS...) conn_printk(KERN_WARNING, TCONN, FMT, ## ARGS)
111#define conn_notice(TCONN, FMT, ARGS...) conn_printk(KERN_NOTICE, TCONN, FMT, ## ARGS)
112#define conn_info(TCONN, FMT, ARGS...) conn_printk(KERN_INFO, TCONN, FMT, ## ARGS)
113#define conn_dbg(TCONN, FMT, ARGS...) conn_printk(KERN_DEBUG, TCONN, FMT, ## ARGS)
114
115#define D_ASSERT(exp) if (!(exp)) \
116 dev_err(DEV, "ASSERT( " #exp " ) in %s:%d\n", __FILE__, __LINE__)
117
118
119
120
121
122
123#define expect(exp) ({ \
124 bool _bool = (exp); \
125 if (!_bool) \
126 dev_err(DEV, "ASSERTION %s FAILED in %s\n", \
127 #exp, __func__); \
128 _bool; \
129 })
130
131
132enum {
133 DRBD_FAULT_MD_WR = 0,
134 DRBD_FAULT_MD_RD = 1,
135 DRBD_FAULT_RS_WR = 2,
136 DRBD_FAULT_RS_RD = 3,
137 DRBD_FAULT_DT_WR = 4,
138 DRBD_FAULT_DT_RD = 5,
139 DRBD_FAULT_DT_RA = 6,
140 DRBD_FAULT_BM_ALLOC = 7,
141 DRBD_FAULT_AL_EE = 8,
142 DRBD_FAULT_RECEIVE = 9,
143
144 DRBD_FAULT_MAX,
145};
146
147extern unsigned int
148_drbd_insert_fault(struct drbd_conf *mdev, unsigned int type);
149
150static inline int
151drbd_insert_fault(struct drbd_conf *mdev, unsigned int type) {
152#ifdef CONFIG_DRBD_FAULT_INJECTION
153 return fault_rate &&
154 (enable_faults & (1<<type)) &&
155 _drbd_insert_fault(mdev, type);
156#else
157 return 0;
158#endif
159}
160
161
162#define div_ceil(A, B) ((A)/(B) + ((A)%(B) ? 1 : 0))
163
164#define div_floor(A, B) ((A)/(B))
165
166extern struct ratelimit_state drbd_ratelimit_state;
167extern struct idr minors;
168extern struct list_head drbd_tconns;
169
170
171enum drbd_packet {
172
173 P_DATA = 0x00,
174 P_DATA_REPLY = 0x01,
175 P_RS_DATA_REPLY = 0x02,
176 P_BARRIER = 0x03,
177 P_BITMAP = 0x04,
178 P_BECOME_SYNC_TARGET = 0x05,
179 P_BECOME_SYNC_SOURCE = 0x06,
180 P_UNPLUG_REMOTE = 0x07,
181 P_DATA_REQUEST = 0x08,
182 P_RS_DATA_REQUEST = 0x09,
183 P_SYNC_PARAM = 0x0a,
184 P_PROTOCOL = 0x0b,
185 P_UUIDS = 0x0c,
186 P_SIZES = 0x0d,
187 P_STATE = 0x0e,
188 P_SYNC_UUID = 0x0f,
189 P_AUTH_CHALLENGE = 0x10,
190 P_AUTH_RESPONSE = 0x11,
191 P_STATE_CHG_REQ = 0x12,
192
193
194 P_PING = 0x13,
195 P_PING_ACK = 0x14,
196 P_RECV_ACK = 0x15,
197 P_WRITE_ACK = 0x16,
198 P_RS_WRITE_ACK = 0x17,
199 P_SUPERSEDED = 0x18,
200 P_NEG_ACK = 0x19,
201 P_NEG_DREPLY = 0x1a,
202 P_NEG_RS_DREPLY = 0x1b,
203 P_BARRIER_ACK = 0x1c,
204 P_STATE_CHG_REPLY = 0x1d,
205
206
207
208 P_OV_REQUEST = 0x1e,
209 P_OV_REPLY = 0x1f,
210 P_OV_RESULT = 0x20,
211 P_CSUM_RS_REQUEST = 0x21,
212 P_RS_IS_IN_SYNC = 0x22,
213 P_SYNC_PARAM89 = 0x23,
214 P_COMPRESSED_BITMAP = 0x24,
215
216
217 P_DELAY_PROBE = 0x27,
218 P_OUT_OF_SYNC = 0x28,
219 P_RS_CANCEL = 0x29,
220 P_CONN_ST_CHG_REQ = 0x2a,
221 P_CONN_ST_CHG_REPLY = 0x2b,
222 P_RETRY_WRITE = 0x2c,
223 P_PROTOCOL_UPDATE = 0x2d,
224
225 P_MAY_IGNORE = 0x100,
226 P_MAX_OPT_CMD = 0x101,
227
228
229
230 P_INITIAL_META = 0xfff1,
231 P_INITIAL_DATA = 0xfff2,
232
233 P_CONNECTION_FEATURES = 0xfffe
234};
235
236extern const char *cmdname(enum drbd_packet cmd);
237
238
239
240struct bm_xfer_ctx {
241
242
243
244
245 unsigned long bm_bits;
246 unsigned long bm_words;
247
248 unsigned long bit_offset;
249 unsigned long word_offset;
250
251
252 unsigned packets[2];
253 unsigned bytes[2];
254};
255
256extern void INFO_bm_xfer_stats(struct drbd_conf *mdev,
257 const char *direction, struct bm_xfer_ctx *c);
258
259static inline void bm_xfer_ctx_bit_to_word_offset(struct bm_xfer_ctx *c)
260{
261
262
263
264
265
266
267
268#if BITS_PER_LONG == 64
269 c->word_offset = c->bit_offset >> 6;
270#elif BITS_PER_LONG == 32
271 c->word_offset = c->bit_offset >> 5;
272 c->word_offset &= ~(1UL);
273#else
274# error "unsupported BITS_PER_LONG"
275#endif
276}
277
278#ifndef __packed
279#define __packed __attribute__((packed))
280#endif
281
282
283
284
285
286
287
288
289
290
291
292struct p_header80 {
293 u32 magic;
294 u16 command;
295 u16 length;
296} __packed;
297
298
299struct p_header95 {
300 u16 magic;
301 u16 command;
302 u32 length;
303} __packed;
304
305struct p_header100 {
306 u32 magic;
307 u16 volume;
308 u16 command;
309 u32 length;
310 u32 pad;
311} __packed;
312
313extern unsigned int drbd_header_size(struct drbd_tconn *tconn);
314
315
316#define DP_HARDBARRIER 1
317#define DP_RW_SYNC 2
318#define DP_MAY_SET_IN_SYNC 4
319#define DP_UNPLUG 8
320#define DP_FUA 16
321#define DP_FLUSH 32
322#define DP_DISCARD 64
323#define DP_SEND_RECEIVE_ACK 128
324#define DP_SEND_WRITE_ACK 256
325
326struct p_data {
327 u64 sector;
328 u64 block_id;
329 u32 seq_num;
330 u32 dp_flags;
331} __packed;
332
333
334
335
336
337
338
339
340
341struct p_block_ack {
342 u64 sector;
343 u64 block_id;
344 u32 blksize;
345 u32 seq_num;
346} __packed;
347
348struct p_block_req {
349 u64 sector;
350 u64 block_id;
351 u32 blksize;
352 u32 pad;
353} __packed;
354
355
356
357
358
359
360
361
362
363
364struct p_connection_features {
365 u32 protocol_min;
366 u32 feature_flags;
367 u32 protocol_max;
368
369
370
371
372
373 u32 _pad;
374 u64 reserved[7];
375} __packed;
376
377struct p_barrier {
378 u32 barrier;
379 u32 pad;
380} __packed;
381
382struct p_barrier_ack {
383 u32 barrier;
384 u32 set_size;
385} __packed;
386
387struct p_rs_param {
388 u32 resync_rate;
389
390
391 char verify_alg[0];
392} __packed;
393
394struct p_rs_param_89 {
395 u32 resync_rate;
396
397 char verify_alg[SHARED_SECRET_MAX];
398 char csums_alg[SHARED_SECRET_MAX];
399} __packed;
400
401struct p_rs_param_95 {
402 u32 resync_rate;
403 char verify_alg[SHARED_SECRET_MAX];
404 char csums_alg[SHARED_SECRET_MAX];
405 u32 c_plan_ahead;
406 u32 c_delay_target;
407 u32 c_fill_target;
408 u32 c_max_rate;
409} __packed;
410
411enum drbd_conn_flags {
412 CF_DISCARD_MY_DATA = 1,
413 CF_DRY_RUN = 2,
414};
415
416struct p_protocol {
417 u32 protocol;
418 u32 after_sb_0p;
419 u32 after_sb_1p;
420 u32 after_sb_2p;
421 u32 conn_flags;
422 u32 two_primaries;
423
424
425 char integrity_alg[0];
426
427} __packed;
428
429struct p_uuids {
430 u64 uuid[UI_EXTENDED_SIZE];
431} __packed;
432
433struct p_rs_uuid {
434 u64 uuid;
435} __packed;
436
437struct p_sizes {
438 u64 d_size;
439 u64 u_size;
440 u64 c_size;
441 u32 max_bio_size;
442 u16 queue_order_type;
443 u16 dds_flags;
444} __packed;
445
446struct p_state {
447 u32 state;
448} __packed;
449
450struct p_req_state {
451 u32 mask;
452 u32 val;
453} __packed;
454
455struct p_req_state_reply {
456 u32 retcode;
457} __packed;
458
459struct p_drbd06_param {
460 u64 size;
461 u32 state;
462 u32 blksize;
463 u32 protocol;
464 u32 version;
465 u32 gen_cnt[5];
466 u32 bit_map_gen[5];
467} __packed;
468
469struct p_block_desc {
470 u64 sector;
471 u32 blksize;
472 u32 pad;
473} __packed;
474
475
476
477enum drbd_bitmap_code {
478
479
480
481 RLE_VLI_Bits = 2,
482};
483
484struct p_compressed_bm {
485
486
487
488
489
490 u8 encoding;
491
492 u8 code[0];
493} __packed;
494
495struct p_delay_probe93 {
496 u32 seq_num;
497 u32 offset;
498} __packed;
499
500
501
502
503
504#define DRBD_SOCKET_BUFFER_SIZE 4096
505
506
507enum drbd_thread_state {
508 NONE,
509 RUNNING,
510 EXITING,
511 RESTARTING
512};
513
514struct drbd_thread {
515 spinlock_t t_lock;
516 struct task_struct *task;
517 struct completion stop;
518 enum drbd_thread_state t_state;
519 int (*function) (struct drbd_thread *);
520 struct drbd_tconn *tconn;
521 int reset_cpu_mask;
522 char name[9];
523};
524
525static inline enum drbd_thread_state get_t_state(struct drbd_thread *thi)
526{
527
528
529
530
531 smp_rmb();
532 return thi->t_state;
533}
534
535struct drbd_work {
536 struct list_head list;
537 int (*cb)(struct drbd_work *, int cancel);
538 union {
539 struct drbd_conf *mdev;
540 struct drbd_tconn *tconn;
541 };
542};
543
544#include "drbd_interval.h"
545
546extern int drbd_wait_misc(struct drbd_conf *, struct drbd_interval *);
547
548struct drbd_request {
549 struct drbd_work w;
550
551
552
553
554
555 struct bio *private_bio;
556
557 struct drbd_interval i;
558
559
560
561
562
563
564
565
566
567 unsigned int epoch;
568
569 struct list_head tl_requests;
570 struct bio *master_bio;
571 unsigned long start_time;
572
573
574 atomic_t completion_ref;
575
576 struct kref kref;
577
578 unsigned rq_state;
579};
580
581struct drbd_epoch {
582 struct drbd_tconn *tconn;
583 struct list_head list;
584 unsigned int barrier_nr;
585 atomic_t epoch_size;
586 atomic_t active;
587 unsigned long flags;
588};
589
590
591enum {
592 DE_HAVE_BARRIER_NUMBER,
593};
594
595enum epoch_event {
596 EV_PUT,
597 EV_GOT_BARRIER_NR,
598 EV_BECAME_LAST,
599 EV_CLEANUP = 32,
600};
601
602struct drbd_wq_barrier {
603 struct drbd_work w;
604 struct completion done;
605};
606
607struct digest_info {
608 int digest_size;
609 void *digest;
610};
611
612struct drbd_peer_request {
613 struct drbd_work w;
614 struct drbd_epoch *epoch;
615 struct page *pages;
616 atomic_t pending_bios;
617 struct drbd_interval i;
618
619 unsigned long flags;
620 union {
621 u64 block_id;
622 struct digest_info *digest;
623 };
624};
625
626
627
628
629
630
631
632enum {
633 __EE_CALL_AL_COMPLETE_IO,
634 __EE_MAY_SET_IN_SYNC,
635
636
637
638 __EE_RESUBMITTED,
639
640
641
642
643 __EE_WAS_ERROR,
644
645
646 __EE_HAS_DIGEST,
647
648
649 __EE_RESTART_REQUESTS,
650
651
652 __EE_SEND_WRITE_ACK,
653
654
655 __EE_IN_INTERVAL_TREE,
656};
657#define EE_CALL_AL_COMPLETE_IO (1<<__EE_CALL_AL_COMPLETE_IO)
658#define EE_MAY_SET_IN_SYNC (1<<__EE_MAY_SET_IN_SYNC)
659#define EE_RESUBMITTED (1<<__EE_RESUBMITTED)
660#define EE_WAS_ERROR (1<<__EE_WAS_ERROR)
661#define EE_HAS_DIGEST (1<<__EE_HAS_DIGEST)
662#define EE_RESTART_REQUESTS (1<<__EE_RESTART_REQUESTS)
663#define EE_SEND_WRITE_ACK (1<<__EE_SEND_WRITE_ACK)
664#define EE_IN_INTERVAL_TREE (1<<__EE_IN_INTERVAL_TREE)
665
666
667enum {
668 UNPLUG_REMOTE,
669 MD_DIRTY,
670 USE_DEGR_WFC_T,
671 CL_ST_CHG_SUCCESS,
672 CL_ST_CHG_FAIL,
673 CRASHED_PRIMARY,
674
675
676 CONSIDER_RESYNC,
677
678 MD_NO_FUA,
679 SUSPEND_IO,
680 BITMAP_IO,
681
682 BITMAP_IO_QUEUED,
683 GO_DISKLESS,
684 WAS_IO_ERROR,
685 WAS_READ_ERROR,
686 FORCE_DETACH,
687 RESYNC_AFTER_NEG,
688 RESIZE_PENDING,
689
690 NEW_CUR_UUID,
691 AL_SUSPENDED,
692 AHEAD_TO_SYNC_SOURCE,
693 B_RS_H_DONE,
694 DISCARD_MY_DATA,
695 READ_BALANCE_RR,
696};
697
698struct drbd_bitmap;
699
700
701
702enum bm_flag {
703
704 BM_P_VMALLOCED = 0x10000,
705
706
707 BM_LOCKED_MASK = 0xf,
708
709
710 BM_DONT_CLEAR = 0x1,
711 BM_DONT_SET = 0x2,
712 BM_DONT_TEST = 0x4,
713
714
715
716 BM_IS_LOCKED = 0x8,
717
718
719 BM_LOCKED_TEST_ALLOWED = BM_DONT_CLEAR | BM_DONT_SET | BM_IS_LOCKED,
720
721
722
723
724 BM_LOCKED_SET_ALLOWED = BM_DONT_CLEAR | BM_IS_LOCKED,
725
726
727
728 BM_LOCKED_CHANGE_ALLOWED = BM_IS_LOCKED,
729};
730
731struct drbd_work_queue {
732 struct list_head q;
733 spinlock_t q_lock;
734 wait_queue_head_t q_wait;
735};
736
737struct drbd_socket {
738 struct mutex mutex;
739 struct socket *socket;
740
741
742 void *sbuf;
743 void *rbuf;
744};
745
746struct drbd_md {
747 u64 md_offset;
748
749 u64 la_size_sect;
750 spinlock_t uuid_lock;
751 u64 uuid[UI_SIZE];
752 u64 device_uuid;
753 u32 flags;
754 u32 md_size_sect;
755
756 s32 al_offset;
757 s32 bm_offset;
758
759
760 s32 meta_dev_idx;
761
762
763 u32 al_stripes;
764 u32 al_stripe_size_4k;
765 u32 al_size_4k;
766};
767
768struct drbd_backing_dev {
769 struct block_device *backing_bdev;
770 struct block_device *md_bdev;
771 struct drbd_md md;
772 struct disk_conf *disk_conf;
773 sector_t known_size;
774};
775
776struct drbd_md_io {
777 unsigned int done;
778 int error;
779};
780
781struct bm_io_work {
782 struct drbd_work w;
783 char *why;
784 enum bm_flag flags;
785 int (*io_fn)(struct drbd_conf *mdev);
786 void (*done)(struct drbd_conf *mdev, int rv);
787};
788
789enum write_ordering_e {
790 WO_none,
791 WO_drain_io,
792 WO_bdev_flush,
793};
794
795struct fifo_buffer {
796 unsigned int head_index;
797 unsigned int size;
798 int total;
799 int values[0];
800};
801extern struct fifo_buffer *fifo_alloc(int fifo_size);
802
803
804enum {
805 NET_CONGESTED,
806 RESOLVE_CONFLICTS,
807 SEND_PING,
808 SIGNAL_ASENDER,
809 GOT_PING_ACK,
810 CONN_WD_ST_CHG_REQ,
811 CONN_WD_ST_CHG_OKAY,
812 CONN_WD_ST_CHG_FAIL,
813 CONN_DRY_RUN,
814 CREATE_BARRIER,
815 STATE_SENT,
816 CALLBACK_PENDING,
817
818
819
820
821
822 DISCONNECT_SENT,
823};
824
825struct drbd_tconn {
826 char *name;
827 struct list_head all_tconn;
828 struct kref kref;
829 struct idr volumes;
830 enum drbd_conns cstate;
831 unsigned susp:1;
832 unsigned susp_nod:1;
833 unsigned susp_fen:1;
834 struct mutex cstate_mutex;
835 unsigned int connect_cnt;
836
837 unsigned long flags;
838 struct net_conf *net_conf;
839 struct mutex conf_update;
840 wait_queue_head_t ping_wait;
841 struct res_opts res_opts;
842
843 struct sockaddr_storage my_addr;
844 int my_addr_len;
845 struct sockaddr_storage peer_addr;
846 int peer_addr_len;
847
848 struct drbd_socket data;
849 struct drbd_socket meta;
850 int agreed_pro_version;
851 unsigned long last_received;
852 unsigned int ko_count;
853
854 spinlock_t req_lock;
855
856 struct list_head transfer_log;
857
858 struct crypto_hash *cram_hmac_tfm;
859 struct crypto_hash *integrity_tfm;
860 struct crypto_hash *peer_integrity_tfm;
861 struct crypto_hash *csums_tfm;
862 struct crypto_hash *verify_tfm;
863 void *int_dig_in;
864 void *int_dig_vv;
865
866
867 struct drbd_epoch *current_epoch;
868 spinlock_t epoch_lock;
869 unsigned int epochs;
870 enum write_ordering_e write_ordering;
871 atomic_t current_tle_nr;
872 unsigned current_tle_writes;
873
874 unsigned long last_reconnect_jif;
875 struct drbd_thread receiver;
876 struct drbd_thread worker;
877 struct drbd_thread asender;
878 cpumask_var_t cpu_mask;
879
880
881 struct drbd_work_queue sender_work;
882
883 struct {
884
885
886 bool seen_any_write_yet;
887
888
889 int current_epoch_nr;
890
891
892
893
894 unsigned current_epoch_writes;
895 } send;
896};
897
898struct submit_worker {
899 struct workqueue_struct *wq;
900 struct work_struct worker;
901
902 spinlock_t lock;
903 struct list_head writes;
904};
905
906struct drbd_conf {
907 struct drbd_tconn *tconn;
908 int vnr;
909 struct kref kref;
910
911
912 unsigned long flags;
913
914
915 struct drbd_backing_dev *ldev __protected_by(local);
916
917 sector_t p_size;
918 struct request_queue *rq_queue;
919 struct block_device *this_bdev;
920 struct gendisk *vdisk;
921
922 unsigned long last_reattach_jif;
923 struct drbd_work resync_work,
924 unplug_work,
925 go_diskless,
926 md_sync_work,
927 start_resync_work;
928 struct timer_list resync_timer;
929 struct timer_list md_sync_timer;
930 struct timer_list start_resync_timer;
931 struct timer_list request_timer;
932#ifdef DRBD_DEBUG_MD_SYNC
933 struct {
934 unsigned int line;
935 const char* func;
936 } last_md_mark_dirty;
937#endif
938
939
940 union drbd_state new_state_tmp;
941
942 union drbd_dev_state state;
943 wait_queue_head_t misc_wait;
944 wait_queue_head_t state_wait;
945 unsigned int send_cnt;
946 unsigned int recv_cnt;
947 unsigned int read_cnt;
948 unsigned int writ_cnt;
949 unsigned int al_writ_cnt;
950 unsigned int bm_writ_cnt;
951 atomic_t ap_bio_cnt;
952 atomic_t ap_pending_cnt;
953 atomic_t rs_pending_cnt;
954 atomic_t unacked_cnt;
955 atomic_t local_cnt;
956
957
958 struct rb_root read_requests;
959 struct rb_root write_requests;
960
961
962 unsigned long rs_total;
963
964 unsigned long rs_failed;
965
966 unsigned long rs_start;
967
968 unsigned long rs_paused;
969
970 unsigned long rs_same_csum;
971#define DRBD_SYNC_MARKS 8
972#define DRBD_SYNC_MARK_STEP (3*HZ)
973
974 unsigned long rs_mark_left[DRBD_SYNC_MARKS];
975
976 unsigned long rs_mark_time[DRBD_SYNC_MARKS];
977
978 int rs_last_mark;
979 unsigned long rs_last_bcast;
980
981
982 sector_t ov_start_sector;
983 sector_t ov_stop_sector;
984
985 sector_t ov_position;
986
987 sector_t ov_last_oos_start;
988
989 sector_t ov_last_oos_size;
990 unsigned long ov_left;
991
992 struct drbd_bitmap *bitmap;
993 unsigned long bm_resync_fo;
994
995
996 struct lru_cache *resync;
997
998 unsigned int resync_locked;
999
1000 unsigned int resync_wenr;
1001
1002 int open_cnt;
1003 u64 *p_uuid;
1004
1005 struct list_head active_ee;
1006 struct list_head sync_ee;
1007 struct list_head done_ee;
1008 struct list_head read_ee;
1009 struct list_head net_ee;
1010
1011 int next_barrier_nr;
1012 struct list_head resync_reads;
1013 atomic_t pp_in_use;
1014 atomic_t pp_in_use_by_net;
1015 wait_queue_head_t ee_wait;
1016 struct page *md_io_page;
1017 struct drbd_md_io md_io;
1018 atomic_t md_io_in_use;
1019 spinlock_t al_lock;
1020 wait_queue_head_t al_wait;
1021 struct lru_cache *act_log;
1022 unsigned int al_tr_number;
1023 int al_tr_cycle;
1024 wait_queue_head_t seq_wait;
1025 atomic_t packet_seq;
1026 unsigned int peer_seq;
1027 spinlock_t peer_seq_lock;
1028 unsigned int minor;
1029 unsigned long comm_bm_set;
1030 struct bm_io_work bm_io_work;
1031 u64 ed_uuid;
1032 struct mutex own_state_mutex;
1033 struct mutex *state_mutex;
1034 char congestion_reason;
1035 atomic_t rs_sect_in;
1036 atomic_t rs_sect_ev;
1037 int rs_last_sect_ev;
1038 int rs_last_events;
1039
1040 int c_sync_rate;
1041 struct fifo_buffer *rs_plan_s;
1042 int rs_in_flight;
1043 atomic_t ap_in_flight;
1044 unsigned int peer_max_bio_size;
1045 unsigned int local_max_bio_size;
1046
1047
1048
1049 struct submit_worker submit;
1050};
1051
1052static inline struct drbd_conf *minor_to_mdev(unsigned int minor)
1053{
1054 return (struct drbd_conf *)idr_find(&minors, minor);
1055}
1056
1057static inline unsigned int mdev_to_minor(struct drbd_conf *mdev)
1058{
1059 return mdev->minor;
1060}
1061
1062static inline struct drbd_conf *vnr_to_mdev(struct drbd_tconn *tconn, int vnr)
1063{
1064 return (struct drbd_conf *)idr_find(&tconn->volumes, vnr);
1065}
1066
1067
1068
1069
1070
1071
1072
1073enum dds_flags {
1074 DDSF_FORCED = 1,
1075 DDSF_NO_RESYNC = 2,
1076};
1077
1078extern void drbd_init_set_defaults(struct drbd_conf *mdev);
1079extern int drbd_thread_start(struct drbd_thread *thi);
1080extern void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait);
1081extern char *drbd_task_to_thread_name(struct drbd_tconn *tconn, struct task_struct *task);
1082#ifdef CONFIG_SMP
1083extern void drbd_thread_current_set_cpu(struct drbd_thread *thi);
1084extern void drbd_calc_cpu_mask(struct drbd_tconn *tconn);
1085#else
1086#define drbd_thread_current_set_cpu(A) ({})
1087#define drbd_calc_cpu_mask(A) ({})
1088#endif
1089extern void tl_release(struct drbd_tconn *, unsigned int barrier_nr,
1090 unsigned int set_size);
1091extern void tl_clear(struct drbd_tconn *);
1092extern void drbd_free_sock(struct drbd_tconn *tconn);
1093extern int drbd_send(struct drbd_tconn *tconn, struct socket *sock,
1094 void *buf, size_t size, unsigned msg_flags);
1095extern int drbd_send_all(struct drbd_tconn *, struct socket *, void *, size_t,
1096 unsigned);
1097
1098extern int __drbd_send_protocol(struct drbd_tconn *tconn, enum drbd_packet cmd);
1099extern int drbd_send_protocol(struct drbd_tconn *tconn);
1100extern int drbd_send_uuids(struct drbd_conf *mdev);
1101extern int drbd_send_uuids_skip_initial_sync(struct drbd_conf *mdev);
1102extern void drbd_gen_and_send_sync_uuid(struct drbd_conf *mdev);
1103extern int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags flags);
1104extern int drbd_send_state(struct drbd_conf *mdev, union drbd_state s);
1105extern int drbd_send_current_state(struct drbd_conf *mdev);
1106extern int drbd_send_sync_param(struct drbd_conf *mdev);
1107extern void drbd_send_b_ack(struct drbd_tconn *tconn, u32 barrier_nr,
1108 u32 set_size);
1109extern int drbd_send_ack(struct drbd_conf *, enum drbd_packet,
1110 struct drbd_peer_request *);
1111extern void drbd_send_ack_rp(struct drbd_conf *mdev, enum drbd_packet cmd,
1112 struct p_block_req *rp);
1113extern void drbd_send_ack_dp(struct drbd_conf *mdev, enum drbd_packet cmd,
1114 struct p_data *dp, int data_size);
1115extern int drbd_send_ack_ex(struct drbd_conf *mdev, enum drbd_packet cmd,
1116 sector_t sector, int blksize, u64 block_id);
1117extern int drbd_send_out_of_sync(struct drbd_conf *, struct drbd_request *);
1118extern int drbd_send_block(struct drbd_conf *, enum drbd_packet,
1119 struct drbd_peer_request *);
1120extern int drbd_send_dblock(struct drbd_conf *mdev, struct drbd_request *req);
1121extern int drbd_send_drequest(struct drbd_conf *mdev, int cmd,
1122 sector_t sector, int size, u64 block_id);
1123extern int drbd_send_drequest_csum(struct drbd_conf *mdev, sector_t sector,
1124 int size, void *digest, int digest_size,
1125 enum drbd_packet cmd);
1126extern int drbd_send_ov_request(struct drbd_conf *mdev,sector_t sector,int size);
1127
1128extern int drbd_send_bitmap(struct drbd_conf *mdev);
1129extern void drbd_send_sr_reply(struct drbd_conf *mdev, enum drbd_state_rv retcode);
1130extern void conn_send_sr_reply(struct drbd_tconn *tconn, enum drbd_state_rv retcode);
1131extern void drbd_free_bc(struct drbd_backing_dev *ldev);
1132extern void drbd_mdev_cleanup(struct drbd_conf *mdev);
1133void drbd_print_uuids(struct drbd_conf *mdev, const char *text);
1134
1135extern void conn_md_sync(struct drbd_tconn *tconn);
1136extern void drbd_md_write(struct drbd_conf *mdev, void *buffer);
1137extern void drbd_md_sync(struct drbd_conf *mdev);
1138extern int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev);
1139extern void drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local);
1140extern void _drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local);
1141extern void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local);
1142extern void drbd_uuid_set_bm(struct drbd_conf *mdev, u64 val) __must_hold(local);
1143extern void drbd_uuid_move_history(struct drbd_conf *mdev) __must_hold(local);
1144extern void __drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local);
1145extern void drbd_md_set_flag(struct drbd_conf *mdev, int flags) __must_hold(local);
1146extern void drbd_md_clear_flag(struct drbd_conf *mdev, int flags)__must_hold(local);
1147extern int drbd_md_test_flag(struct drbd_backing_dev *, int);
1148#ifndef DRBD_DEBUG_MD_SYNC
1149extern void drbd_md_mark_dirty(struct drbd_conf *mdev);
1150#else
1151#define drbd_md_mark_dirty(m) drbd_md_mark_dirty_(m, __LINE__ , __func__ )
1152extern void drbd_md_mark_dirty_(struct drbd_conf *mdev,
1153 unsigned int line, const char *func);
1154#endif
1155extern void drbd_queue_bitmap_io(struct drbd_conf *mdev,
1156 int (*io_fn)(struct drbd_conf *),
1157 void (*done)(struct drbd_conf *, int),
1158 char *why, enum bm_flag flags);
1159extern int drbd_bitmap_io(struct drbd_conf *mdev,
1160 int (*io_fn)(struct drbd_conf *),
1161 char *why, enum bm_flag flags);
1162extern int drbd_bitmap_io_from_worker(struct drbd_conf *mdev,
1163 int (*io_fn)(struct drbd_conf *),
1164 char *why, enum bm_flag flags);
1165extern int drbd_bmio_set_n_write(struct drbd_conf *mdev);
1166extern int drbd_bmio_clear_n_write(struct drbd_conf *mdev);
1167extern void drbd_ldev_destroy(struct drbd_conf *mdev);
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202#define MD_128MB_SECT (128LLU << 11)
1203#define MD_4kB_SECT 8
1204#define MD_32kB_SECT 64
1205
1206
1207#define AL_EXTENT_SHIFT 22
1208#define AL_EXTENT_SIZE (1<<AL_EXTENT_SHIFT)
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224#define AL_UPDATES_PER_TRANSACTION 64
1225#define AL_CONTEXT_PER_TRANSACTION 919
1226
1227#if BITS_PER_LONG == 32
1228#define LN2_BPL 5
1229#define cpu_to_lel(A) cpu_to_le32(A)
1230#define lel_to_cpu(A) le32_to_cpu(A)
1231#elif BITS_PER_LONG == 64
1232#define LN2_BPL 6
1233#define cpu_to_lel(A) cpu_to_le64(A)
1234#define lel_to_cpu(A) le64_to_cpu(A)
1235#else
1236#error "LN2 of BITS_PER_LONG unknown!"
1237#endif
1238
1239
1240
1241struct bm_extent {
1242 int rs_left;
1243 int rs_failed;
1244 unsigned long flags;
1245 struct lc_element lce;
1246};
1247
1248#define BME_NO_WRITES 0
1249#define BME_LOCKED 1
1250#define BME_PRIORITY 2
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260#define SLEEP_TIME (HZ/10)
1261
1262
1263
1264#define BM_BLOCK_SHIFT 12
1265#define BM_BLOCK_SIZE (1<<BM_BLOCK_SHIFT)
1266
1267
1268
1269#define BM_EXT_SHIFT 24
1270#define BM_EXT_SIZE (1<<BM_EXT_SHIFT)
1271
1272#if (BM_EXT_SHIFT != 24) || (BM_BLOCK_SHIFT != 12)
1273#error "HAVE YOU FIXED drbdmeta AS WELL??"
1274#endif
1275
1276
1277#define BM_SECT_TO_BIT(x) ((x)>>(BM_BLOCK_SHIFT-9))
1278#define BM_BIT_TO_SECT(x) ((sector_t)(x)<<(BM_BLOCK_SHIFT-9))
1279#define BM_SECT_PER_BIT BM_BIT_TO_SECT(1)
1280
1281
1282#define Bit2KB(bits) ((bits)<<(BM_BLOCK_SHIFT-10))
1283
1284
1285
1286#define BM_SECT_TO_EXT(x) ((x)>>(BM_EXT_SHIFT-9))
1287
1288
1289#define BM_EXT_TO_SECT(x) ((sector_t)(x) << (BM_EXT_SHIFT-9))
1290#define BM_SECT_PER_EXT BM_EXT_TO_SECT(1)
1291
1292
1293#define AL_EXT_PER_BM_SECT (1 << (BM_EXT_SHIFT - AL_EXTENT_SHIFT))
1294
1295#define BM_BLOCKS_PER_BM_EXT_B (BM_EXT_SHIFT - BM_BLOCK_SHIFT)
1296#define BM_BLOCKS_PER_BM_EXT_MASK ((1<<BM_BLOCKS_PER_BM_EXT_B) - 1)
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312#define DRBD_MAX_SECTORS_32 (0xffffffffLU)
1313
1314
1315
1316
1317
1318#define DRBD_MAX_SECTORS_FIXED_BM \
1319 ((MD_128MB_SECT - MD_32kB_SECT - MD_4kB_SECT) * (1LL<<(BM_EXT_SHIFT-9)))
1320#if !defined(CONFIG_LBDAF) && BITS_PER_LONG == 32
1321#define DRBD_MAX_SECTORS DRBD_MAX_SECTORS_32
1322#define DRBD_MAX_SECTORS_FLEX DRBD_MAX_SECTORS_32
1323#else
1324#define DRBD_MAX_SECTORS DRBD_MAX_SECTORS_FIXED_BM
1325
1326#if BITS_PER_LONG == 32
1327
1328
1329
1330#define DRBD_MAX_SECTORS_FLEX BM_BIT_TO_SECT(0xffff7fff)
1331#else
1332
1333#define DRBD_MAX_SECTORS_FLEX (1UL << 51)
1334
1335#endif
1336#endif
1337
1338
1339
1340
1341
1342
1343
1344#define DRBD_MAX_BIO_SIZE (1U << 20)
1345#if DRBD_MAX_BIO_SIZE > BIO_MAX_SIZE
1346#error Architecture not supported: DRBD_MAX_BIO_SIZE > BIO_MAX_SIZE
1347#endif
1348#define DRBD_MAX_BIO_SIZE_SAFE (1U << 12)
1349
1350#define DRBD_MAX_SIZE_H80_PACKET (1U << 15)
1351#define DRBD_MAX_BIO_SIZE_P95 (1U << 17)
1352
1353extern int drbd_bm_init(struct drbd_conf *mdev);
1354extern int drbd_bm_resize(struct drbd_conf *mdev, sector_t sectors, int set_new_bits);
1355extern void drbd_bm_cleanup(struct drbd_conf *mdev);
1356extern void drbd_bm_set_all(struct drbd_conf *mdev);
1357extern void drbd_bm_clear_all(struct drbd_conf *mdev);
1358
1359extern int drbd_bm_set_bits(
1360 struct drbd_conf *mdev, unsigned long s, unsigned long e);
1361extern int drbd_bm_clear_bits(
1362 struct drbd_conf *mdev, unsigned long s, unsigned long e);
1363extern int drbd_bm_count_bits(
1364 struct drbd_conf *mdev, const unsigned long s, const unsigned long e);
1365
1366
1367extern void _drbd_bm_set_bits(struct drbd_conf *mdev,
1368 const unsigned long s, const unsigned long e);
1369extern int drbd_bm_test_bit(struct drbd_conf *mdev, unsigned long bitnr);
1370extern int drbd_bm_e_weight(struct drbd_conf *mdev, unsigned long enr);
1371extern int drbd_bm_write_page(struct drbd_conf *mdev, unsigned int idx) __must_hold(local);
1372extern int drbd_bm_read(struct drbd_conf *mdev) __must_hold(local);
1373extern void drbd_bm_mark_for_writeout(struct drbd_conf *mdev, int page_nr);
1374extern int drbd_bm_write(struct drbd_conf *mdev) __must_hold(local);
1375extern int drbd_bm_write_hinted(struct drbd_conf *mdev) __must_hold(local);
1376extern int drbd_bm_write_all(struct drbd_conf *mdev) __must_hold(local);
1377extern int drbd_bm_write_copy_pages(struct drbd_conf *mdev) __must_hold(local);
1378extern size_t drbd_bm_words(struct drbd_conf *mdev);
1379extern unsigned long drbd_bm_bits(struct drbd_conf *mdev);
1380extern sector_t drbd_bm_capacity(struct drbd_conf *mdev);
1381
1382#define DRBD_END_OF_BITMAP (~(unsigned long)0)
1383extern unsigned long drbd_bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo);
1384
1385extern unsigned long _drbd_bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo);
1386extern unsigned long _drbd_bm_find_next_zero(struct drbd_conf *mdev, unsigned long bm_fo);
1387extern unsigned long _drbd_bm_total_weight(struct drbd_conf *mdev);
1388extern unsigned long drbd_bm_total_weight(struct drbd_conf *mdev);
1389extern int drbd_bm_rs_done(struct drbd_conf *mdev);
1390
1391extern void drbd_bm_merge_lel(struct drbd_conf *mdev, size_t offset,
1392 size_t number, unsigned long *buffer);
1393
1394extern void drbd_bm_get_lel(struct drbd_conf *mdev, size_t offset,
1395 size_t number, unsigned long *buffer);
1396
1397extern void drbd_bm_lock(struct drbd_conf *mdev, char *why, enum bm_flag flags);
1398extern void drbd_bm_unlock(struct drbd_conf *mdev);
1399
1400
1401extern struct kmem_cache *drbd_request_cache;
1402extern struct kmem_cache *drbd_ee_cache;
1403extern struct kmem_cache *drbd_bm_ext_cache;
1404extern struct kmem_cache *drbd_al_ext_cache;
1405extern mempool_t *drbd_request_mempool;
1406extern mempool_t *drbd_ee_mempool;
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421extern struct page *drbd_pp_pool;
1422extern spinlock_t drbd_pp_lock;
1423extern int drbd_pp_vacant;
1424extern wait_queue_head_t drbd_pp_wait;
1425
1426
1427
1428
1429
1430
1431#define DRBD_MIN_POOL_PAGES 128
1432extern mempool_t *drbd_md_io_page_pool;
1433
1434
1435
1436extern struct bio_set *drbd_md_io_bio_set;
1437
1438extern struct bio *bio_alloc_drbd(gfp_t gfp_mask);
1439
1440extern rwlock_t global_state_lock;
1441
1442extern int conn_lowest_minor(struct drbd_tconn *tconn);
1443enum drbd_ret_code conn_new_minor(struct drbd_tconn *tconn, unsigned int minor, int vnr);
1444extern void drbd_minor_destroy(struct kref *kref);
1445
1446extern int set_resource_options(struct drbd_tconn *tconn, struct res_opts *res_opts);
1447extern struct drbd_tconn *conn_create(const char *name, struct res_opts *res_opts);
1448extern void conn_destroy(struct kref *kref);
1449struct drbd_tconn *conn_get_by_name(const char *name);
1450extern struct drbd_tconn *conn_get_by_addrs(void *my_addr, int my_addr_len,
1451 void *peer_addr, int peer_addr_len);
1452extern void conn_free_crypto(struct drbd_tconn *tconn);
1453
1454extern int proc_details;
1455
1456
1457extern void do_submit(struct work_struct *ws);
1458extern void __drbd_make_request(struct drbd_conf *, struct bio *, unsigned long);
1459extern void drbd_make_request(struct request_queue *q, struct bio *bio);
1460extern int drbd_read_remote(struct drbd_conf *mdev, struct drbd_request *req);
1461extern int drbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bvm, struct bio_vec *bvec);
1462extern int is_valid_ar_handle(struct drbd_request *, sector_t);
1463
1464
1465
1466extern int drbd_msg_put_info(const char *info);
1467extern void drbd_suspend_io(struct drbd_conf *mdev);
1468extern void drbd_resume_io(struct drbd_conf *mdev);
1469extern char *ppsize(char *buf, unsigned long long size);
1470extern sector_t drbd_new_dev_size(struct drbd_conf *, struct drbd_backing_dev *, sector_t, int);
1471enum determine_dev_size {
1472 DS_ERROR_SHRINK = -3,
1473 DS_ERROR_SPACE_MD = -2,
1474 DS_ERROR = -1,
1475 DS_UNCHANGED = 0,
1476 DS_SHRUNK = 1,
1477 DS_GREW = 2
1478};
1479extern enum determine_dev_size
1480drbd_determine_dev_size(struct drbd_conf *, enum dds_flags, struct resize_parms *) __must_hold(local);
1481extern void resync_after_online_grow(struct drbd_conf *);
1482extern void drbd_reconsider_max_bio_size(struct drbd_conf *mdev);
1483extern enum drbd_state_rv drbd_set_role(struct drbd_conf *mdev,
1484 enum drbd_role new_role,
1485 int force);
1486extern bool conn_try_outdate_peer(struct drbd_tconn *tconn);
1487extern void conn_try_outdate_peer_async(struct drbd_tconn *tconn);
1488extern int drbd_khelper(struct drbd_conf *mdev, char *cmd);
1489
1490
1491extern int drbd_worker(struct drbd_thread *thi);
1492enum drbd_ret_code drbd_resync_after_valid(struct drbd_conf *mdev, int o_minor);
1493void drbd_resync_after_changed(struct drbd_conf *mdev);
1494extern void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side);
1495extern void resume_next_sg(struct drbd_conf *mdev);
1496extern void suspend_other_sg(struct drbd_conf *mdev);
1497extern int drbd_resync_finished(struct drbd_conf *mdev);
1498
1499extern void *drbd_md_get_buffer(struct drbd_conf *mdev);
1500extern void drbd_md_put_buffer(struct drbd_conf *mdev);
1501extern int drbd_md_sync_page_io(struct drbd_conf *mdev,
1502 struct drbd_backing_dev *bdev, sector_t sector, int rw);
1503extern void drbd_ov_out_of_sync_found(struct drbd_conf *, sector_t, int);
1504extern void wait_until_done_or_force_detached(struct drbd_conf *mdev,
1505 struct drbd_backing_dev *bdev, unsigned int *done);
1506extern void drbd_rs_controller_reset(struct drbd_conf *mdev);
1507
1508static inline void ov_out_of_sync_print(struct drbd_conf *mdev)
1509{
1510 if (mdev->ov_last_oos_size) {
1511 dev_err(DEV, "Out of sync: start=%llu, size=%lu (sectors)\n",
1512 (unsigned long long)mdev->ov_last_oos_start,
1513 (unsigned long)mdev->ov_last_oos_size);
1514 }
1515 mdev->ov_last_oos_size=0;
1516}
1517
1518
1519extern void drbd_csum_bio(struct drbd_conf *, struct crypto_hash *, struct bio *, void *);
1520extern void drbd_csum_ee(struct drbd_conf *, struct crypto_hash *,
1521 struct drbd_peer_request *, void *);
1522
1523extern int w_e_end_data_req(struct drbd_work *, int);
1524extern int w_e_end_rsdata_req(struct drbd_work *, int);
1525extern int w_e_end_csum_rs_req(struct drbd_work *, int);
1526extern int w_e_end_ov_reply(struct drbd_work *, int);
1527extern int w_e_end_ov_req(struct drbd_work *, int);
1528extern int w_ov_finished(struct drbd_work *, int);
1529extern int w_resync_timer(struct drbd_work *, int);
1530extern int w_send_write_hint(struct drbd_work *, int);
1531extern int w_make_resync_request(struct drbd_work *, int);
1532extern int w_send_dblock(struct drbd_work *, int);
1533extern int w_send_read_req(struct drbd_work *, int);
1534extern int w_prev_work_done(struct drbd_work *, int);
1535extern int w_e_reissue(struct drbd_work *, int);
1536extern int w_restart_disk_io(struct drbd_work *, int);
1537extern int w_send_out_of_sync(struct drbd_work *, int);
1538extern int w_start_resync(struct drbd_work *, int);
1539
1540extern void resync_timer_fn(unsigned long data);
1541extern void start_resync_timer_fn(unsigned long data);
1542
1543
1544extern int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector);
1545extern int drbd_submit_peer_request(struct drbd_conf *,
1546 struct drbd_peer_request *, const unsigned,
1547 const int);
1548extern int drbd_free_peer_reqs(struct drbd_conf *, struct list_head *);
1549extern struct drbd_peer_request *drbd_alloc_peer_req(struct drbd_conf *, u64,
1550 sector_t, unsigned int,
1551 gfp_t) __must_hold(local);
1552extern void __drbd_free_peer_req(struct drbd_conf *, struct drbd_peer_request *,
1553 int);
1554#define drbd_free_peer_req(m,e) __drbd_free_peer_req(m, e, 0)
1555#define drbd_free_net_peer_req(m,e) __drbd_free_peer_req(m, e, 1)
1556extern struct page *drbd_alloc_pages(struct drbd_conf *, unsigned int, bool);
1557extern void drbd_set_recv_tcq(struct drbd_conf *mdev, int tcq_enabled);
1558extern void _drbd_clear_done_ee(struct drbd_conf *mdev, struct list_head *to_be_freed);
1559extern void conn_flush_workqueue(struct drbd_tconn *tconn);
1560extern int drbd_connected(struct drbd_conf *mdev);
1561static inline void drbd_flush_workqueue(struct drbd_conf *mdev)
1562{
1563 conn_flush_workqueue(mdev->tconn);
1564}
1565
1566
1567
1568static inline int drbd_setsockopt(struct socket *sock, int level, int optname,
1569 char *optval, int optlen)
1570{
1571 mm_segment_t oldfs = get_fs();
1572 char __user *uoptval;
1573 int err;
1574
1575 uoptval = (char __user __force *)optval;
1576
1577 set_fs(KERNEL_DS);
1578 if (level == SOL_SOCKET)
1579 err = sock_setsockopt(sock, level, optname, uoptval, optlen);
1580 else
1581 err = sock->ops->setsockopt(sock, level, optname, uoptval,
1582 optlen);
1583 set_fs(oldfs);
1584 return err;
1585}
1586
1587static inline void drbd_tcp_cork(struct socket *sock)
1588{
1589 int val = 1;
1590 (void) drbd_setsockopt(sock, SOL_TCP, TCP_CORK,
1591 (char*)&val, sizeof(val));
1592}
1593
1594static inline void drbd_tcp_uncork(struct socket *sock)
1595{
1596 int val = 0;
1597 (void) drbd_setsockopt(sock, SOL_TCP, TCP_CORK,
1598 (char*)&val, sizeof(val));
1599}
1600
1601static inline void drbd_tcp_nodelay(struct socket *sock)
1602{
1603 int val = 1;
1604 (void) drbd_setsockopt(sock, SOL_TCP, TCP_NODELAY,
1605 (char*)&val, sizeof(val));
1606}
1607
1608static inline void drbd_tcp_quickack(struct socket *sock)
1609{
1610 int val = 2;
1611 (void) drbd_setsockopt(sock, SOL_TCP, TCP_QUICKACK,
1612 (char*)&val, sizeof(val));
1613}
1614
1615void drbd_bump_write_ordering(struct drbd_tconn *tconn, enum write_ordering_e wo);
1616
1617
1618extern struct proc_dir_entry *drbd_proc;
1619extern const struct file_operations drbd_proc_fops;
1620extern const char *drbd_conn_str(enum drbd_conns s);
1621extern const char *drbd_role_str(enum drbd_role s);
1622
1623
1624extern int drbd_al_begin_io_nonblock(struct drbd_conf *mdev, struct drbd_interval *i);
1625extern void drbd_al_begin_io_commit(struct drbd_conf *mdev, bool delegate);
1626extern bool drbd_al_begin_io_fastpath(struct drbd_conf *mdev, struct drbd_interval *i);
1627extern void drbd_al_begin_io(struct drbd_conf *mdev, struct drbd_interval *i, bool delegate);
1628extern void drbd_al_complete_io(struct drbd_conf *mdev, struct drbd_interval *i);
1629extern void drbd_rs_complete_io(struct drbd_conf *mdev, sector_t sector);
1630extern int drbd_rs_begin_io(struct drbd_conf *mdev, sector_t sector);
1631extern int drbd_try_rs_begin_io(struct drbd_conf *mdev, sector_t sector);
1632extern void drbd_rs_cancel_all(struct drbd_conf *mdev);
1633extern int drbd_rs_del_all(struct drbd_conf *mdev);
1634extern void drbd_rs_failed_io(struct drbd_conf *mdev,
1635 sector_t sector, int size);
1636extern void drbd_advance_rs_marks(struct drbd_conf *mdev, unsigned long still_to_go);
1637extern void __drbd_set_in_sync(struct drbd_conf *mdev, sector_t sector,
1638 int size, const char *file, const unsigned int line);
1639#define drbd_set_in_sync(mdev, sector, size) \
1640 __drbd_set_in_sync(mdev, sector, size, __FILE__, __LINE__)
1641extern int __drbd_set_out_of_sync(struct drbd_conf *mdev, sector_t sector,
1642 int size, const char *file, const unsigned int line);
1643#define drbd_set_out_of_sync(mdev, sector, size) \
1644 __drbd_set_out_of_sync(mdev, sector, size, __FILE__, __LINE__)
1645extern void drbd_al_shrink(struct drbd_conf *mdev);
1646extern int drbd_initialize_al(struct drbd_conf *, void *);
1647
1648
1649
1650struct sib_info {
1651 enum drbd_state_info_bcast_reason sib_reason;
1652 union {
1653 struct {
1654 char *helper_name;
1655 unsigned helper_exit_code;
1656 };
1657 struct {
1658 union drbd_state os;
1659 union drbd_state ns;
1660 };
1661 };
1662};
1663void drbd_bcast_event(struct drbd_conf *mdev, const struct sib_info *sib);
1664
1665
1666
1667
1668
1669
1670static inline struct page *page_chain_next(struct page *page)
1671{
1672 return (struct page *)page_private(page);
1673}
1674#define page_chain_for_each(page) \
1675 for (; page && ({ prefetch(page_chain_next(page)); 1; }); \
1676 page = page_chain_next(page))
1677#define page_chain_for_each_safe(page, n) \
1678 for (; page && ({ n = page_chain_next(page); 1; }); page = n)
1679
1680
1681static inline int drbd_peer_req_has_active_page(struct drbd_peer_request *peer_req)
1682{
1683 struct page *page = peer_req->pages;
1684 page_chain_for_each(page) {
1685 if (page_count(page) > 1)
1686 return 1;
1687 }
1688 return 0;
1689}
1690
1691static inline enum drbd_state_rv
1692_drbd_set_state(struct drbd_conf *mdev, union drbd_state ns,
1693 enum chg_state_flags flags, struct completion *done)
1694{
1695 enum drbd_state_rv rv;
1696
1697 read_lock(&global_state_lock);
1698 rv = __drbd_set_state(mdev, ns, flags, done);
1699 read_unlock(&global_state_lock);
1700
1701 return rv;
1702}
1703
1704static inline union drbd_state drbd_read_state(struct drbd_conf *mdev)
1705{
1706 union drbd_state rv;
1707
1708 rv.i = mdev->state.i;
1709 rv.susp = mdev->tconn->susp;
1710 rv.susp_nod = mdev->tconn->susp_nod;
1711 rv.susp_fen = mdev->tconn->susp_fen;
1712
1713 return rv;
1714}
1715
1716enum drbd_force_detach_flags {
1717 DRBD_READ_ERROR,
1718 DRBD_WRITE_ERROR,
1719 DRBD_META_IO_ERROR,
1720 DRBD_FORCE_DETACH,
1721};
1722
1723#define __drbd_chk_io_error(m,f) __drbd_chk_io_error_(m,f, __func__)
1724static inline void __drbd_chk_io_error_(struct drbd_conf *mdev,
1725 enum drbd_force_detach_flags df,
1726 const char *where)
1727{
1728 enum drbd_io_error_p ep;
1729
1730 rcu_read_lock();
1731 ep = rcu_dereference(mdev->ldev->disk_conf)->on_io_error;
1732 rcu_read_unlock();
1733 switch (ep) {
1734 case EP_PASS_ON:
1735 if (df == DRBD_READ_ERROR || df == DRBD_WRITE_ERROR) {
1736 if (__ratelimit(&drbd_ratelimit_state))
1737 dev_err(DEV, "Local IO failed in %s.\n", where);
1738 if (mdev->state.disk > D_INCONSISTENT)
1739 _drbd_set_state(_NS(mdev, disk, D_INCONSISTENT), CS_HARD, NULL);
1740 break;
1741 }
1742
1743 case EP_DETACH:
1744 case EP_CALL_HELPER:
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765 set_bit(WAS_IO_ERROR, &mdev->flags);
1766 if (df == DRBD_READ_ERROR)
1767 set_bit(WAS_READ_ERROR, &mdev->flags);
1768 if (df == DRBD_FORCE_DETACH)
1769 set_bit(FORCE_DETACH, &mdev->flags);
1770 if (mdev->state.disk > D_FAILED) {
1771 _drbd_set_state(_NS(mdev, disk, D_FAILED), CS_HARD, NULL);
1772 dev_err(DEV,
1773 "Local IO failed in %s. Detaching...\n", where);
1774 }
1775 break;
1776 }
1777}
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787#define drbd_chk_io_error(m,e,f) drbd_chk_io_error_(m,e,f, __func__)
1788static inline void drbd_chk_io_error_(struct drbd_conf *mdev,
1789 int error, enum drbd_force_detach_flags forcedetach, const char *where)
1790{
1791 if (error) {
1792 unsigned long flags;
1793 spin_lock_irqsave(&mdev->tconn->req_lock, flags);
1794 __drbd_chk_io_error_(mdev, forcedetach, where);
1795 spin_unlock_irqrestore(&mdev->tconn->req_lock, flags);
1796 }
1797}
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807static inline sector_t drbd_md_first_sector(struct drbd_backing_dev *bdev)
1808{
1809 switch (bdev->md.meta_dev_idx) {
1810 case DRBD_MD_INDEX_INTERNAL:
1811 case DRBD_MD_INDEX_FLEX_INT:
1812 return bdev->md.md_offset + bdev->md.bm_offset;
1813 case DRBD_MD_INDEX_FLEX_EXT:
1814 default:
1815 return bdev->md.md_offset;
1816 }
1817}
1818
1819
1820
1821
1822
1823static inline sector_t drbd_md_last_sector(struct drbd_backing_dev *bdev)
1824{
1825 switch (bdev->md.meta_dev_idx) {
1826 case DRBD_MD_INDEX_INTERNAL:
1827 case DRBD_MD_INDEX_FLEX_INT:
1828 return bdev->md.md_offset + MD_4kB_SECT -1;
1829 case DRBD_MD_INDEX_FLEX_EXT:
1830 default:
1831 return bdev->md.md_offset + bdev->md.md_size_sect -1;
1832 }
1833}
1834
1835
1836static inline sector_t drbd_get_capacity(struct block_device *bdev)
1837{
1838
1839 return bdev ? i_size_read(bdev->bd_inode) >> 9 : 0;
1840}
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850static inline sector_t drbd_get_max_capacity(struct drbd_backing_dev *bdev)
1851{
1852 sector_t s;
1853
1854 switch (bdev->md.meta_dev_idx) {
1855 case DRBD_MD_INDEX_INTERNAL:
1856 case DRBD_MD_INDEX_FLEX_INT:
1857 s = drbd_get_capacity(bdev->backing_bdev)
1858 ? min_t(sector_t, DRBD_MAX_SECTORS_FLEX,
1859 drbd_md_first_sector(bdev))
1860 : 0;
1861 break;
1862 case DRBD_MD_INDEX_FLEX_EXT:
1863 s = min_t(sector_t, DRBD_MAX_SECTORS_FLEX,
1864 drbd_get_capacity(bdev->backing_bdev));
1865
1866 s = min_t(sector_t, s,
1867 BM_EXT_TO_SECT(bdev->md.md_size_sect
1868 - bdev->md.bm_offset));
1869 break;
1870 default:
1871 s = min_t(sector_t, DRBD_MAX_SECTORS,
1872 drbd_get_capacity(bdev->backing_bdev));
1873 }
1874 return s;
1875}
1876
1877
1878
1879
1880
1881static inline sector_t drbd_md_ss(struct drbd_backing_dev *bdev)
1882{
1883 const int meta_dev_idx = bdev->md.meta_dev_idx;
1884
1885 if (meta_dev_idx == DRBD_MD_INDEX_FLEX_EXT)
1886 return 0;
1887
1888
1889
1890 if (meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
1891 meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)
1892 return (drbd_get_capacity(bdev->backing_bdev) & ~7ULL) - 8;
1893
1894
1895 return MD_128MB_SECT * bdev->md.meta_dev_idx;
1896}
1897
1898static inline void
1899drbd_queue_work_front(struct drbd_work_queue *q, struct drbd_work *w)
1900{
1901 unsigned long flags;
1902 spin_lock_irqsave(&q->q_lock, flags);
1903 list_add(&w->list, &q->q);
1904 spin_unlock_irqrestore(&q->q_lock, flags);
1905 wake_up(&q->q_wait);
1906}
1907
1908static inline void
1909drbd_queue_work(struct drbd_work_queue *q, struct drbd_work *w)
1910{
1911 unsigned long flags;
1912 spin_lock_irqsave(&q->q_lock, flags);
1913 list_add_tail(&w->list, &q->q);
1914 spin_unlock_irqrestore(&q->q_lock, flags);
1915 wake_up(&q->q_wait);
1916}
1917
1918static inline void wake_asender(struct drbd_tconn *tconn)
1919{
1920 if (test_bit(SIGNAL_ASENDER, &tconn->flags))
1921 force_sig(DRBD_SIG, tconn->asender.task);
1922}
1923
1924static inline void request_ping(struct drbd_tconn *tconn)
1925{
1926 set_bit(SEND_PING, &tconn->flags);
1927 wake_asender(tconn);
1928}
1929
1930extern void *conn_prepare_command(struct drbd_tconn *, struct drbd_socket *);
1931extern void *drbd_prepare_command(struct drbd_conf *, struct drbd_socket *);
1932extern int conn_send_command(struct drbd_tconn *, struct drbd_socket *,
1933 enum drbd_packet, unsigned int, void *,
1934 unsigned int);
1935extern int drbd_send_command(struct drbd_conf *, struct drbd_socket *,
1936 enum drbd_packet, unsigned int, void *,
1937 unsigned int);
1938
1939extern int drbd_send_ping(struct drbd_tconn *tconn);
1940extern int drbd_send_ping_ack(struct drbd_tconn *tconn);
1941extern int drbd_send_state_req(struct drbd_conf *, union drbd_state, union drbd_state);
1942extern int conn_send_state_req(struct drbd_tconn *, union drbd_state, union drbd_state);
1943
1944static inline void drbd_thread_stop(struct drbd_thread *thi)
1945{
1946 _drbd_thread_stop(thi, false, true);
1947}
1948
1949static inline void drbd_thread_stop_nowait(struct drbd_thread *thi)
1950{
1951 _drbd_thread_stop(thi, false, false);
1952}
1953
1954static inline void drbd_thread_restart_nowait(struct drbd_thread *thi)
1955{
1956 _drbd_thread_stop(thi, true, false);
1957}
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981static inline void inc_ap_pending(struct drbd_conf *mdev)
1982{
1983 atomic_inc(&mdev->ap_pending_cnt);
1984}
1985
1986#define ERR_IF_CNT_IS_NEGATIVE(which, func, line) \
1987 if (atomic_read(&mdev->which) < 0) \
1988 dev_err(DEV, "in %s:%d: " #which " = %d < 0 !\n", \
1989 func, line, \
1990 atomic_read(&mdev->which))
1991
1992#define dec_ap_pending(mdev) _dec_ap_pending(mdev, __FUNCTION__, __LINE__)
1993static inline void _dec_ap_pending(struct drbd_conf *mdev, const char *func, int line)
1994{
1995 if (atomic_dec_and_test(&mdev->ap_pending_cnt))
1996 wake_up(&mdev->misc_wait);
1997 ERR_IF_CNT_IS_NEGATIVE(ap_pending_cnt, func, line);
1998}
1999
2000
2001
2002
2003
2004
2005
2006static inline void inc_rs_pending(struct drbd_conf *mdev)
2007{
2008 atomic_inc(&mdev->rs_pending_cnt);
2009}
2010
2011#define dec_rs_pending(mdev) _dec_rs_pending(mdev, __FUNCTION__, __LINE__)
2012static inline void _dec_rs_pending(struct drbd_conf *mdev, const char *func, int line)
2013{
2014 atomic_dec(&mdev->rs_pending_cnt);
2015 ERR_IF_CNT_IS_NEGATIVE(rs_pending_cnt, func, line);
2016}
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027static inline void inc_unacked(struct drbd_conf *mdev)
2028{
2029 atomic_inc(&mdev->unacked_cnt);
2030}
2031
2032#define dec_unacked(mdev) _dec_unacked(mdev, __FUNCTION__, __LINE__)
2033static inline void _dec_unacked(struct drbd_conf *mdev, const char *func, int line)
2034{
2035 atomic_dec(&mdev->unacked_cnt);
2036 ERR_IF_CNT_IS_NEGATIVE(unacked_cnt, func, line);
2037}
2038
2039#define sub_unacked(mdev, n) _sub_unacked(mdev, n, __FUNCTION__, __LINE__)
2040static inline void _sub_unacked(struct drbd_conf *mdev, int n, const char *func, int line)
2041{
2042 atomic_sub(n, &mdev->unacked_cnt);
2043 ERR_IF_CNT_IS_NEGATIVE(unacked_cnt, func, line);
2044}
2045
2046
2047
2048
2049
2050
2051
2052#define get_ldev(M) __cond_lock(local, _get_ldev_if_state(M,D_INCONSISTENT))
2053#define get_ldev_if_state(M,MINS) __cond_lock(local, _get_ldev_if_state(M,MINS))
2054
2055static inline void put_ldev(struct drbd_conf *mdev)
2056{
2057 int i = atomic_dec_return(&mdev->local_cnt);
2058
2059
2060
2061
2062 __release(local);
2063 D_ASSERT(i >= 0);
2064 if (i == 0) {
2065 if (mdev->state.disk == D_DISKLESS)
2066
2067 drbd_ldev_destroy(mdev);
2068 if (mdev->state.disk == D_FAILED) {
2069
2070 if (!test_and_set_bit(GO_DISKLESS, &mdev->flags))
2071 drbd_queue_work(&mdev->tconn->sender_work, &mdev->go_diskless);
2072 }
2073 wake_up(&mdev->misc_wait);
2074 }
2075}
2076
2077#ifndef __CHECKER__
2078static inline int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_state mins)
2079{
2080 int io_allowed;
2081
2082
2083 if (mdev->state.disk == D_DISKLESS)
2084 return 0;
2085
2086 atomic_inc(&mdev->local_cnt);
2087 io_allowed = (mdev->state.disk >= mins);
2088 if (!io_allowed)
2089 put_ldev(mdev);
2090 return io_allowed;
2091}
2092#else
2093extern int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_state mins);
2094#endif
2095
2096
2097static inline void drbd_get_syncer_progress(struct drbd_conf *mdev,
2098 unsigned long *bits_left, unsigned int *per_mil_done)
2099{
2100
2101
2102 typecheck(unsigned long, mdev->rs_total);
2103
2104
2105
2106
2107
2108 if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T)
2109 *bits_left = mdev->ov_left;
2110 else
2111 *bits_left = drbd_bm_total_weight(mdev) - mdev->rs_failed;
2112
2113
2114 if (*bits_left > mdev->rs_total) {
2115
2116
2117
2118
2119
2120 smp_rmb();
2121 dev_warn(DEV, "cs:%s rs_left=%lu > rs_total=%lu (rs_failed %lu)\n",
2122 drbd_conn_str(mdev->state.conn),
2123 *bits_left, mdev->rs_total, mdev->rs_failed);
2124 *per_mil_done = 0;
2125 } else {
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135 unsigned int shift = mdev->rs_total > UINT_MAX ? 16 : 10;
2136 unsigned long left = *bits_left >> shift;
2137 unsigned long total = 1UL + (mdev->rs_total >> shift);
2138 unsigned long tmp = 1000UL - left * 1000UL/total;
2139 *per_mil_done = tmp;
2140 }
2141}
2142
2143
2144
2145
2146
2147static inline int drbd_get_max_buffers(struct drbd_conf *mdev)
2148{
2149 struct net_conf *nc;
2150 int mxb;
2151
2152 rcu_read_lock();
2153 nc = rcu_dereference(mdev->tconn->net_conf);
2154 mxb = nc ? nc->max_buffers : 1000000;
2155 rcu_read_unlock();
2156
2157 return mxb;
2158}
2159
2160static inline int drbd_state_is_stable(struct drbd_conf *mdev)
2161{
2162 union drbd_dev_state s = mdev->state;
2163
2164
2165
2166
2167 switch ((enum drbd_conns)s.conn) {
2168
2169 case C_STANDALONE:
2170 case C_WF_CONNECTION:
2171
2172 case C_CONNECTED:
2173 case C_SYNC_SOURCE:
2174 case C_SYNC_TARGET:
2175 case C_VERIFY_S:
2176 case C_VERIFY_T:
2177 case C_PAUSED_SYNC_S:
2178 case C_PAUSED_SYNC_T:
2179 case C_AHEAD:
2180 case C_BEHIND:
2181
2182 case C_DISCONNECTING:
2183 case C_UNCONNECTED:
2184 case C_TIMEOUT:
2185 case C_BROKEN_PIPE:
2186 case C_NETWORK_FAILURE:
2187 case C_PROTOCOL_ERROR:
2188 case C_TEAR_DOWN:
2189 case C_WF_REPORT_PARAMS:
2190 case C_STARTING_SYNC_S:
2191 case C_STARTING_SYNC_T:
2192 break;
2193
2194
2195 case C_WF_BITMAP_S:
2196 if (mdev->tconn->agreed_pro_version < 96)
2197 return 0;
2198 break;
2199
2200
2201 case C_WF_BITMAP_T:
2202 case C_WF_SYNC_UUID:
2203 case C_MASK:
2204
2205 return 0;
2206 }
2207
2208 switch ((enum drbd_disk_state)s.disk) {
2209 case D_DISKLESS:
2210 case D_INCONSISTENT:
2211 case D_OUTDATED:
2212 case D_CONSISTENT:
2213 case D_UP_TO_DATE:
2214 case D_FAILED:
2215
2216 break;
2217
2218
2219 case D_ATTACHING:
2220 case D_NEGOTIATING:
2221 case D_UNKNOWN:
2222 case D_MASK:
2223
2224 return 0;
2225 }
2226
2227 return 1;
2228}
2229
2230static inline int drbd_suspended(struct drbd_conf *mdev)
2231{
2232 struct drbd_tconn *tconn = mdev->tconn;
2233
2234 return tconn->susp || tconn->susp_fen || tconn->susp_nod;
2235}
2236
2237static inline bool may_inc_ap_bio(struct drbd_conf *mdev)
2238{
2239 int mxb = drbd_get_max_buffers(mdev);
2240
2241 if (drbd_suspended(mdev))
2242 return false;
2243 if (test_bit(SUSPEND_IO, &mdev->flags))
2244 return false;
2245
2246
2247
2248
2249
2250
2251 if (!drbd_state_is_stable(mdev))
2252 return false;
2253
2254
2255
2256 if (atomic_read(&mdev->ap_bio_cnt) > mxb)
2257 return false;
2258 if (test_bit(BITMAP_IO, &mdev->flags))
2259 return false;
2260 return true;
2261}
2262
2263static inline bool inc_ap_bio_cond(struct drbd_conf *mdev)
2264{
2265 bool rv = false;
2266
2267 spin_lock_irq(&mdev->tconn->req_lock);
2268 rv = may_inc_ap_bio(mdev);
2269 if (rv)
2270 atomic_inc(&mdev->ap_bio_cnt);
2271 spin_unlock_irq(&mdev->tconn->req_lock);
2272
2273 return rv;
2274}
2275
2276static inline void inc_ap_bio(struct drbd_conf *mdev)
2277{
2278
2279
2280
2281
2282
2283
2284
2285
2286 wait_event(mdev->misc_wait, inc_ap_bio_cond(mdev));
2287}
2288
2289static inline void dec_ap_bio(struct drbd_conf *mdev)
2290{
2291 int mxb = drbd_get_max_buffers(mdev);
2292 int ap_bio = atomic_dec_return(&mdev->ap_bio_cnt);
2293
2294 D_ASSERT(ap_bio >= 0);
2295
2296 if (ap_bio == 0 && test_bit(BITMAP_IO, &mdev->flags)) {
2297 if (!test_and_set_bit(BITMAP_IO_QUEUED, &mdev->flags))
2298 drbd_queue_work(&mdev->tconn->sender_work, &mdev->bm_io_work.w);
2299 }
2300
2301
2302
2303
2304 if (ap_bio < mxb)
2305 wake_up(&mdev->misc_wait);
2306}
2307
2308static inline bool verify_can_do_stop_sector(struct drbd_conf *mdev)
2309{
2310 return mdev->tconn->agreed_pro_version >= 97 &&
2311 mdev->tconn->agreed_pro_version != 100;
2312}
2313
2314static inline int drbd_set_ed_uuid(struct drbd_conf *mdev, u64 val)
2315{
2316 int changed = mdev->ed_uuid != val;
2317 mdev->ed_uuid = val;
2318 return changed;
2319}
2320
2321static inline int drbd_queue_order_type(struct drbd_conf *mdev)
2322{
2323
2324
2325#ifndef QUEUE_ORDERED_NONE
2326#define QUEUE_ORDERED_NONE 0
2327#endif
2328 return QUEUE_ORDERED_NONE;
2329}
2330
2331static inline void drbd_md_flush(struct drbd_conf *mdev)
2332{
2333 int r;
2334
2335 if (mdev->ldev == NULL) {
2336 dev_warn(DEV, "mdev->ldev == NULL in drbd_md_flush\n");
2337 return;
2338 }
2339
2340 if (test_bit(MD_NO_FUA, &mdev->flags))
2341 return;
2342
2343 r = blkdev_issue_flush(mdev->ldev->md_bdev, GFP_NOIO, NULL);
2344 if (r) {
2345 set_bit(MD_NO_FUA, &mdev->flags);
2346 dev_err(DEV, "meta data flush failed with status %d, disabling md-flushes\n", r);
2347 }
2348}
2349
2350#endif
2351