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