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