1/*
2 drbd_int.h
3
4 This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
5
6 Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
7 Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
8 Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
9
10 drbd is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
13 any later version.
14
15 drbd is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with drbd; see the file COPYING. If not, write to
22 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
23
24*/
25
26#ifndef _DRBD_INT_H
27#define _DRBD_INT_H
28
29#include <crypto/hash.h>
30#include <linux/compiler.h>
31#include <linux/types.h>
32#include <linux/list.h>
33#include <linux/sched/signal.h>
34#include <linux/bitops.h>
35#include <linux/slab.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/backing-dev.h>
42#include <linux/genhd.h>
43#include <linux/idr.h>
44#include <linux/dynamic_debug.h>
45#include <net/tcp.h>
46#include <linux/lru_cache.h>
47#include <linux/prefetch.h>
48#include <linux/drbd_genl_api.h>
49#include <linux/drbd.h>
50#include "drbd_strings.h"
51#include "drbd_state.h"
52#include "drbd_protocol.h"
53
54#ifdef __CHECKER__
55# define __protected_by(x) __attribute__((require_context(x,1,999,"rdwr")))
56# define __protected_read_by(x) __attribute__((require_context(x,1,999,"read")))
57# define __protected_write_by(x) __attribute__((require_context(x,1,999,"write")))
58#else
59# define __protected_by(x)
60# define __protected_read_by(x)
61# define __protected_write_by(x)
62#endif
63
64/* shared module parameters, defined in drbd_main.c */
65#ifdef CONFIG_DRBD_FAULT_INJECTION
66extern int drbd_enable_faults;
67extern int drbd_fault_rate;
68#endif
69
70extern unsigned int drbd_minor_count;
71extern char drbd_usermode_helper[];
72extern int drbd_proc_details;
73
74
75/* This is used to stop/restart our threads.
76 * Cannot use SIGTERM nor SIGKILL, since these
77 * are sent out by init on runlevel changes
78 * I choose SIGHUP for now.
79 */
80#define DRBD_SIGKILL SIGHUP
81
82#define ID_IN_SYNC (4711ULL)
83#define ID_OUT_OF_SYNC (4712ULL)
84#define ID_SYNCER (-1ULL)
85
86#define UUID_NEW_BM_OFFSET ((u64)0x0001000000000000ULL)
87
88struct drbd_device;
89struct drbd_connection;
90
91#define __drbd_printk_device(level, device, fmt, args...) \
92 dev_printk(level, disk_to_dev((device)->vdisk), fmt, ## args)
93#define __drbd_printk_peer_device(level, peer_device, fmt, args...) \
94 dev_printk(level, disk_to_dev((peer_device)->device->vdisk), fmt, ## args)
95#define __drbd_printk_resource(level, resource, fmt, args...) \
96 printk(level "drbd %s: " fmt, (resource)->name, ## args)
97#define __drbd_printk_connection(level, connection, fmt, args...) \
98 printk(level "drbd %s: " fmt, (connection)->resource->name, ## args)
99
100void drbd_printk_with_wrong_object_type(void);
101
102#define __drbd_printk_if_same_type(obj, type, func, level, fmt, args...) \
103 (__builtin_types_compatible_p(typeof(obj), type) || \
104 __builtin_types_compatible_p(typeof(obj), const type)), \
105 func(level, (const type)(obj), fmt, ## args)
106
107#define drbd_printk(level, obj, fmt, args...) \
108 __builtin_choose_expr( \
109 __drbd_printk_if_same_type(obj, struct drbd_device *, \
110 __drbd_printk_device, level, fmt, ## args), \
111 __builtin_choose_expr( \
112 __drbd_printk_if_same_type(obj, struct drbd_resource *, \
113 __drbd_printk_resource, level, fmt, ## args), \
114 __builtin_choose_expr( \
115 __drbd_printk_if_same_type(obj, struct drbd_connection *, \
116 __drbd_printk_connection, level, fmt, ## args), \
117 __builtin_choose_expr( \
118 __drbd_printk_if_same_type(obj, struct drbd_peer_device *, \
119 __drbd_printk_peer_device, level, fmt, ## args), \
120 drbd_printk_with_wrong_object_type()))))
121
122#define drbd_dbg(obj, fmt, args...) \
123 drbd_printk(KERN_DEBUG, obj, fmt, ## args)
124#define drbd_alert(obj, fmt, args...) \
125 drbd_printk(KERN_ALERT, obj, fmt, ## args)
126#define drbd_err(obj, fmt, args...) \
127 drbd_printk(KERN_ERR, obj, fmt, ## args)
128#define drbd_warn(obj, fmt, args...) \
129 drbd_printk(KERN_WARNING, obj, fmt, ## args)
130#define drbd_info(obj, fmt, args...) \
131 drbd_printk(KERN_INFO, obj, fmt, ## args)
132#define drbd_emerg(obj, fmt, args...) \
133 drbd_printk(KERN_EMERG, obj, fmt, ## args)
134
135#define dynamic_drbd_dbg(device, fmt, args...) \
136 dynamic_dev_dbg(disk_to_dev(device->vdisk), fmt, ## args)
137
138#define D_ASSERT(device, exp) do { \
139 if (!(exp)) \
140 drbd_err(device, "ASSERT( " #exp " ) in %s:%d\n", __FILE__, __LINE__); \
141 } while (0)
142
143/**
144 * expect - Make an assertion
145 *
146 * Unlike the assert macro, this macro returns a boolean result.
147 */
148#define expect(exp) ({ \
149 bool _bool = (exp); \
150 if (!_bool) \
151 drbd_err(device, "ASSERTION %s FAILED in %s\n", \
152 #exp, __func__); \
153 _bool; \
154 })
155
156/* Defines to control fault insertion */
157enum {
158 DRBD_FAULT_MD_WR = 0, /* meta data write */
159 DRBD_FAULT_MD_RD = 1, /* read */
160 DRBD_FAULT_RS_WR = 2, /* resync */
161 DRBD_FAULT_RS_RD = 3,
162 DRBD_FAULT_DT_WR = 4, /* data */
163 DRBD_FAULT_DT_RD = 5,
164 DRBD_FAULT_DT_RA = 6, /* data read ahead */
165 DRBD_FAULT_BM_ALLOC = 7, /* bitmap allocation */
166 DRBD_FAULT_AL_EE = 8, /* alloc ee */
167 DRBD_FAULT_RECEIVE = 9, /* Changes some bytes upon receiving a [rs]data block */
168
169 DRBD_FAULT_MAX,
170};
171
172extern unsigned int
173_drbd_insert_fault(struct drbd_device *device, unsigned int type);
174
175static inline int
176drbd_insert_fault(struct drbd_device *device, unsigned int type) {
177#ifdef CONFIG_DRBD_FAULT_INJECTION
178 return drbd_fault_rate &&
179 (drbd_enable_faults & (1<<type)) &&
180 _drbd_insert_fault(device, type);
181#else
182 return 0;
183#endif
184}
185
186/* integer division, round _UP_ to the next integer */
187#define div_ceil(A, B) ((A)/(B) + ((A)%(B) ? 1 : 0))
188/* usual integer division */
189#define div_floor(A, B) ((A)/(B))
190
191extern struct ratelimit_state drbd_ratelimit_state;
192extern struct idr drbd_devices; /* RCU, updates: genl_lock() */
193extern struct list_head drbd_resources; /* RCU, updates: genl_lock() */
194
195extern const char *cmdname(enum drbd_packet cmd);
196
197/* for sending/receiving the bitmap,
198 * possibly in some encoding scheme */
199struct bm_xfer_ctx {
200 /* "const"
201 * stores total bits and long words
202 * of the bitmap, so we don't need to
203 * call the accessor functions over and again. */
204 unsigned long bm_bits;
205 unsigned long bm_words;
206 /* during xfer, current position within the bitmap */
207 unsigned long bit_offset;
208 unsigned long word_offset;
209
210 /* statistics; index: (h->command == P_BITMAP) */
211 unsigned packets[2];
212 unsigned bytes[2];
213};
214
215extern void INFO_bm_xfer_stats(struct drbd_device *device,
216 const char *direction, struct bm_xfer_ctx *c);
217
218static inline void bm_xfer_ctx_bit_to_word_offset(struct bm_xfer_ctx *c)
219{
220 /* word_offset counts "native long words" (32 or 64 bit),
221 * aligned at 64 bit.
222 * Encoded packet may end at an unaligned bit offset.
223 * In case a fallback clear text packet is transmitted in
224 * between, we adjust this offset back to the last 64bit
225 * aligned "native long word", which makes coding and decoding
226 * the plain text bitmap much more convenient. */
227#if BITS_PER_LONG == 64
228 c->word_offset = c->bit_offset >> 6;
229#elif BITS_PER_LONG == 32
230 c->word_offset = c->bit_offset >> 5;
231 c->word_offset &= ~(1UL);
232#else
233# error "unsupported BITS_PER_LONG"
234#endif
235}
236
237extern unsigned int drbd_header_size(struct drbd_connection *connection);
238
239/**********************************************************************/
240enum drbd_thread_state {
241 NONE,
242 RUNNING,
243 EXITING,
244 RESTARTING
245};
246
247struct drbd_thread {
248 spinlock_t t_lock;
249 struct task_struct *task;
250 struct completion stop;
251 enum drbd_thread_state t_state;
252 int (*function) (struct drbd_thread *);
253 struct drbd_resource *resource;
254 struct drbd_connection *connection;
255 int reset_cpu_mask;
256 const char *name;
257};
258
259static inline enum drbd_thread_state get_t_state(struct drbd_thread *thi)
260{
261 /* THINK testing the t_state seems to be uncritical in all cases
262 * (but thread_{start,stop}), so we can read it *without* the lock.
263 * --lge */
264
265 smp_rmb();
266 return thi->t_state;
267}
268
269struct drbd_work {
270 struct list_head list;
271 int (*cb)(struct drbd_work *, int cancel);
272};
273
274struct drbd_device_work {
275 struct drbd_work w;
276 struct drbd_device *device;
277};
278
279#include "drbd_interval.h"
280
281extern int drbd_wait_misc(struct drbd_device *, struct drbd_interval *);
282
283extern void lock_all_resources(void);
284extern void unlock_all_resources(void);
285
286struct drbd_request {
287 struct drbd_work w;
288 struct drbd_device *device;
289
290 /* if local IO is not allowed, will be NULL.
291 * if local IO _is_ allowed, holds the locally submitted bio clone,
292 * or, after local IO completion, the ERR_PTR(error).
293 * see drbd_request_endio(). */
294 struct bio *private_bio;
295
296 struct drbd_interval i;
297
298 /* epoch: used to check on "completion" whether this req was in
299 * the current epoch, and we therefore have to close it,
300 * causing a p_barrier packet to be send, starting a new epoch.
301 *
302 * This corresponds to "barrier" in struct p_barrier[_ack],
303 * and to "barrier_nr" in struct drbd_epoch (and various
304 * comments/function parameters/local variable names).
305 */
306 unsigned int epoch;
307
308 struct list_head tl_requests; /* ring list in the transfer log */
309 struct bio *master_bio; /* master bio pointer */
310
311 /* see struct drbd_device */
312 struct list_head req_pending_master_completion;
313 struct list_head req_pending_local;
314
315 /* for generic IO accounting */
316 unsigned long start_jif;
317
318 /* for DRBD internal statistics */
319
320 /* Minimal set of time stamps to determine if we wait for activity log
321 * transactions, local disk or peer. 32 bit "jiffies" are good enough,
322 * we don't expect a DRBD request to be stalled for several month.
323 */
324
325 /* before actual request processing */
326 unsigned long in_actlog_jif;
327
328 /* local disk */
329 unsigned long pre_submit_jif;
330
331 /* per connection */
332 unsigned long pre_send_jif;
333 unsigned long acked_jif;
334 unsigned long net_done_jif;
335
336 /* Possibly even more detail to track each phase:
337 * master_completion_jif
338 * how long did it take to complete the master bio
339 * (application visible latency)
340 * allocated_jif
341 * how long the master bio was blocked until we finally allocated
342 * a tracking struct
343 * in_actlog_jif
344 * how long did we wait for activity log transactions
345 *
346 * net_queued_jif
347 * when did we finally queue it for sending
348 * pre_send_jif
349 * when did we start sending it
350 * post_send_jif
351 * how long did we block in the network stack trying to send it
352 * acked_jif
353 * when did we receive (or fake, in protocol A) a remote ACK
354 * net_done_jif
355 * when did we receive final acknowledgement (P_BARRIER_ACK),
356 * or decide, e.g. on connection loss, that we do no longer expect
357 * anything from this peer for this request.
358 *
359 * pre_submit_jif
360 * post_sub_jif
361 * when did we start submiting to the lower level device,
362 * and how long did we block in that submit function
363 * local_completion_jif
364 * how long did it take the lower level device to complete this request
365 */
366
367
368 /* once it hits 0, we may complete the master_bio */
369 atomic_t completion_ref;
370 /* once it hits 0, we may destroy this drbd_request object */
371 struct kref kref;
372
373 unsigned rq_state; /* see comments above _req_mod() */
374};
375
376struct drbd_epoch {
377 struct drbd_connection *connection;
378 struct list_head list;
379 unsigned int barrier_nr;
380 atomic_t epoch_size; /* increased on every request added. */
381 atomic_t active; /* increased on every req. added, and dec on every finished. */
382 unsigned long flags;
383};
384
385/* Prototype declaration of function defined in drbd_receiver.c */
386int drbdd_init(struct drbd_thread *);
387int drbd_asender(struct drbd_thread *);
388
389/* drbd_epoch flag bits */
390enum {
391 DE_HAVE_BARRIER_NUMBER,
392};
393
394enum epoch_event {
395 EV_PUT,
396 EV_GOT_BARRIER_NR,
397 EV_BECAME_LAST,
398 EV_CLEANUP = 32, /* used as flag */
399};
400
401struct digest_info {
402 int digest_size;
403 void *digest;
404};
405
406struct drbd_peer_request {
407 struct drbd_work w;
408 struct drbd_peer_device *peer_device;
409 struct drbd_epoch *epoch; /* for writes */
410 struct page *pages;
411 atomic_t pending_bios;
412 struct drbd_interval i;
413 /* see comments on ee flag bits below */
414 unsigned long flags;
415 unsigned long submit_jif;
416 union {
417 u64 block_id;
418 struct digest_info *digest;
419 };
420};
421
422/* ee flag bits.
423 * While corresponding bios are in flight, the only modification will be
424 * set_bit WAS_ERROR, which has to be atomic.
425 * If no bios are in flight yet, or all have been completed,
426 * non-atomic modification to ee->flags is ok.
427 */
428enum {
429 __EE_CALL_AL_COMPLETE_IO,
430 __EE_MAY_SET_IN_SYNC,
431
432 /* is this a TRIM aka REQ_OP_DISCARD? */
433 __EE_TRIM,
434 /* explicit zero-out requested, or
435 * our lower level cannot handle trim,
436 * and we want to fall back to zeroout instead */
437 __EE_ZEROOUT,
438
439 /* In case a barrier failed,
440 * we need to resubmit without the barrier flag. */
441 __EE_RESUBMITTED,
442
443 /* we may have several bios per peer request.
444 * if any of those fail, we set this flag atomically
445 * from the endio callback */
446 __EE_WAS_ERROR,
447
448 /* This ee has a pointer to a digest instead of a block id */
449 __EE_HAS_DIGEST,
450
451 /* Conflicting local requests need to be restarted after this request */
452 __EE_RESTART_REQUESTS,
453
454 /* The peer wants a write ACK for this (wire proto C) */
455 __EE_SEND_WRITE_ACK,
456
457 /* Is set when net_conf had two_primaries set while creating this peer_req */
458 __EE_IN_INTERVAL_TREE,
459
460 /* for debugfs: */
461 /* has this been submitted, or does it still wait for something else? */
462 __EE_SUBMITTED,
463
464 /* this is/was a write request */
465 __EE_WRITE,
466
467 /* this is/was a write same request */
468 __EE_WRITE_SAME,
469
470 /* this originates from application on peer
471 * (not some resync or verify or other DRBD internal request) */
472 __EE_APPLICATION,
473
474 /* If it contains only 0 bytes, send back P_RS_DEALLOCATED */
475 __EE_RS_THIN_REQ,
476};
477#define EE_CALL_AL_COMPLETE_IO (1<<__EE_CALL_AL_COMPLETE_IO)
478#define EE_MAY_SET_IN_SYNC (1<<__EE_MAY_SET_IN_SYNC)
479#define EE_TRIM (1<<__EE_TRIM)
480#define EE_ZEROOUT (1<<__EE_ZEROOUT)
481#define EE_RESUBMITTED (1<<__EE_RESUBMITTED)
482#define EE_WAS_ERROR (1<<__EE_WAS_ERROR)
483#define EE_HAS_DIGEST (1<<__EE_HAS_DIGEST)
484#define EE_RESTART_REQUESTS (1<<__EE_RESTART_REQUESTS)
485#define EE_SEND_WRITE_ACK (1<<__EE_SEND_WRITE_ACK)
486#define EE_IN_INTERVAL_TREE (1<<__EE_IN_INTERVAL_TREE)
487#define EE_SUBMITTED (1<<__EE_SUBMITTED)
488#define EE_WRITE (1<<__EE_WRITE)
489#define EE_WRITE_SAME (1<<__EE_WRITE_SAME)
490#define EE_APPLICATION (1<<__EE_APPLICATION)
491#define EE_RS_THIN_REQ (1<<__EE_RS_THIN_REQ)
492
493/* flag bits per device */
494enum {
495 UNPLUG_REMOTE, /* sending a "UnplugRemote" could help */
496 MD_DIRTY, /* current uuids and flags not yet on disk */
497 USE_DEGR_WFC_T, /* degr-wfc-timeout instead of wfc-timeout. */
498 CL_ST_CHG_SUCCESS,
499 CL_ST_CHG_FAIL,
500 CRASHED_PRIMARY, /* This node was a crashed primary.
501 * Gets cleared when the state.conn
502 * goes into C_CONNECTED state. */
503 CONSIDER_RESYNC,
504
505 MD_NO_FUA, /* Users wants us to not use FUA/FLUSH on meta data dev */
506
507 BITMAP_IO, /* suspend application io;
508 once no more io in flight, start bitmap io */
509 BITMAP_IO_QUEUED, /* Started bitmap IO */
510 WAS_IO_ERROR, /* Local disk failed, returned IO error */
511 WAS_READ_ERROR, /* Local disk READ failed (set additionally to the above) */
512 FORCE_DETACH, /* Force-detach from local disk, aborting any pending local IO */
513 RESYNC_AFTER_NEG, /* Resync after online grow after the attach&negotiate finished. */
514 RESIZE_PENDING, /* Size change detected locally, waiting for the response from
515 * the peer, if it changed there as well. */
516 NEW_CUR_UUID, /* Create new current UUID when thawing IO */
517 AL_SUSPENDED, /* Activity logging is currently suspended. */
518 AHEAD_TO_SYNC_SOURCE, /* Ahead -> SyncSource queued */
519 B_RS_H_DONE, /* Before resync handler done (already executed) */
520 DISCARD_MY_DATA, /* discard_my_data flag per volume */
521 READ_BALANCE_RR,
522
523 FLUSH_PENDING, /* if set, device->flush_jif is when we submitted that flush
524 * from drbd_flush_after_epoch() */
525
526 /* cleared only after backing device related structures have been destroyed. */
527 GOING_DISKLESS, /* Disk is being detached, because of io-error, or admin request. */
528
529 /* to be used in drbd_device_post_work() */
530 GO_DISKLESS, /* tell worker to schedule cleanup before detach */
531 DESTROY_DISK, /* tell worker to close backing devices and destroy related structures. */
532 MD_SYNC, /* tell worker to call drbd_md_sync() */
533 RS_START, /* tell worker to start resync/OV */
534 RS_PROGRESS, /* tell worker that resync made significant progress */
535 RS_DONE, /* tell worker that resync is done */
536};
537
538struct drbd_bitmap; /* opaque for drbd_device */
539
540/* definition of bits in bm_flags to be used in drbd_bm_lock
541 * and drbd_bitmap_io and friends. */
542enum bm_flag {
543 /* currently locked for bulk operation */
544 BM_LOCKED_MASK = 0xf,
545
546 /* in detail, that is: */
547 BM_DONT_CLEAR = 0x1,
548 BM_DONT_SET = 0x2,
549 BM_DONT_TEST = 0x4,
550
551 /* so we can mark it locked for bulk operation,
552 * and still allow all non-bulk operations */
553 BM_IS_LOCKED = 0x8,
554
555 /* (test bit, count bit) allowed (common case) */
556 BM_LOCKED_TEST_ALLOWED = BM_DONT_CLEAR | BM_DONT_SET | BM_IS_LOCKED,
557
558 /* testing bits, as well as setting new bits allowed, but clearing bits
559 * would be unexpected. Used during bitmap receive. Setting new bits
560 * requires sending of "out-of-sync" information, though. */
561 BM_LOCKED_SET_ALLOWED = BM_DONT_CLEAR | BM_IS_LOCKED,
562
563 /* for drbd_bm_write_copy_pages, everything is allowed,
564 * only concurrent bulk operations are locked out. */
565 BM_LOCKED_CHANGE_ALLOWED = BM_IS_LOCKED,
566};
567
568struct drbd_work_queue {
569 struct list_head q;
570 spinlock_t q_lock; /* to protect the list. */
571 wait_queue_head_t q_wait;
572};
573
574struct drbd_socket {
575 struct mutex mutex;
576 struct socket *socket;
577 /* this way we get our
578 * send/receive buffers off the stack */
579 void *sbuf;
580 void *rbuf;
581};
582
583struct drbd_md {
584 u64 md_offset; /* sector offset to 'super' block */
585
586 u64 la_size_sect; /* last agreed size, unit sectors */
587 spinlock_t uuid_lock;
588 u64 uuid[UI_SIZE];
589 u64 device_uuid;
590 u32 flags;
591 u32 md_size_sect;
592
593 s32 al_offset; /* signed relative sector offset to activity log */
594 s32 bm_offset; /* signed relative sector offset to bitmap */
595
596 /* cached value of bdev->disk_conf->meta_dev_idx (see below) */
597 s32 meta_dev_idx;
598
599 /* see al_tr_number_to_on_disk_sector() */
600 u32 al_stripes;
601 u32 al_stripe_size_4k;
602 u32 al_size_4k; /* cached product of the above */
603};
604
605struct drbd_backing_dev {
606 struct block_device *backing_bdev;
607 struct block_device *md_bdev;
608 struct drbd_md md;
609 struct disk_conf *disk_conf; /* RCU, for updates: resource->conf_update */
610 sector_t known_size; /* last known size of that backing device */
611};
612
613struct drbd_md_io {
614 struct page *page;
615 unsigned long start_jif; /* last call to drbd_md_get_buffer */
616 unsigned long submit_jif; /* last _drbd_md_sync_page_io() submit */
617 const char *current_use;
618 atomic_t in_use;
619 unsigned int done;
620 int error;
621};
622
623struct bm_io_work {
624 struct drbd_work w;
625 char *why;
626 enum bm_flag flags;
627 int (*io_fn)(struct drbd_device *device);
628 void (*done)(struct drbd_device *device, int rv);
629};
630
631struct fifo_buffer {
632 unsigned int head_index;
633 unsigned int size;
634 int total; /* sum of all values */
635 int values[0];
636};
637extern struct fifo_buffer *fifo_alloc(int fifo_size);
638
639/* flag bits per connection */
640enum {
641 NET_CONGESTED, /* The data socket is congested */
642 RESOLVE_CONFLICTS, /* Set on one node, cleared on the peer! */
643 SEND_PING,
644 GOT_PING_ACK, /* set when we receive a ping_ack packet, ping_wait gets woken */
645 CONN_WD_ST_CHG_REQ, /* A cluster wide state change on the connection is active */
646 CONN_WD_ST_CHG_OKAY,
647 CONN_WD_ST_CHG_FAIL,
648 CONN_DRY_RUN, /* Expect disconnect after resync handshake. */
649 CREATE_BARRIER, /* next P_DATA is preceded by a P_BARRIER */
650 STATE_SENT, /* Do not change state/UUIDs while this is set */
651 CALLBACK_PENDING, /* Whether we have a call_usermodehelper(, UMH_WAIT_PROC)
652 * pending, from drbd worker context.
653 * If set, bdi_write_congested() returns true,
654 * so shrink_page_list() would not recurse into,
655 * and potentially deadlock on, this drbd worker.
656 */
657 DISCONNECT_SENT,
658
659 DEVICE_WORK_PENDING, /* tell worker that some device has pending work */
660};
661
662enum which_state { NOW, OLD = NOW, NEW };
663
664struct drbd_resource {
665 char *name;
666#ifdef CONFIG_DEBUG_FS
667 struct dentry *debugfs_res;
668 struct dentry *debugfs_res_volumes;
669 struct dentry *debugfs_res_connections;
670 struct dentry *debugfs_res_in_flight_summary;
671#endif
672 struct kref kref;
673 struct idr devices; /* volume number to device mapping */
674 struct list_head connections;
675 struct list_head resources;
676 struct res_opts res_opts;
677 struct mutex conf_update; /* mutex for ready-copy-update of net_conf and disk_conf */
678 struct mutex adm_mutex; /* mutex to serialize administrative requests */
679 spinlock_t req_lock;
680
681 unsigned susp:1; /* IO suspended by user */
682 unsigned susp_nod:1; /* IO suspended because no data */
683 unsigned susp_fen:1; /* IO suspended because fence peer handler runs */
684
685 enum write_ordering_e write_ordering;
686
687 cpumask_var_t cpu_mask;
688};
689
690struct drbd_thread_timing_details
691{
692 unsigned long start_jif;
693 void *cb_addr;
694 const char *caller_fn;
695 unsigned int line;
696 unsigned int cb_nr;
697};
698
699struct drbd_connection {
700 struct list_head connections;
701 struct drbd_resource *resource;
702#ifdef CONFIG_DEBUG_FS
703 struct dentry *debugfs_conn;
704 struct dentry *debugfs_conn_callback_history;
705 struct dentry *debugfs_conn_oldest_requests;
706#endif
707 struct kref kref;
708 struct idr peer_devices; /* volume number to peer device mapping */
709 enum drbd_conns cstate; /* Only C_STANDALONE to C_WF_REPORT_PARAMS */
710 struct mutex cstate_mutex; /* Protects graceful disconnects */
711 unsigned int connect_cnt; /* Inc each time a connection is established */
712
713 unsigned long flags;
714 struct net_conf *net_conf; /* content protected by rcu */
715 wait_queue_head_t ping_wait; /* Woken upon reception of a ping, and a state change */
716
717 struct sockaddr_storage my_addr;
718 int my_addr_len;
719 struct sockaddr_storage peer_addr;
720 int peer_addr_len;
721
722 struct drbd_socket data; /* data/barrier/cstate/parameter packets */
723 struct drbd_socket meta; /* ping/ack (metadata) packets */
724 int agreed_pro_version; /* actually used protocol version */
725 u32 agreed_features;
726 unsigned long last_received; /* in jiffies, either socket */
727 unsigned int ko_count;
728
729 struct list_head transfer_log; /* all requests not yet fully processed */
730
731 struct crypto_shash *cram_hmac_tfm;
732 struct crypto_shash *integrity_tfm; /* checksums we compute, updates protected by connection->data->mutex */
733 struct crypto_shash *peer_integrity_tfm; /* checksums we verify, only accessed from receiver thread */
734 struct crypto_shash *csums_tfm;
735 struct crypto_shash *verify_tfm;
736 void *int_dig_in;
737 void *int_dig_vv;
738
739 /* receiver side */
740 struct drbd_epoch *current_epoch;
741 spinlock_t epoch_lock;
742 unsigned int epochs;
743 atomic_t current_tle_nr; /* transfer log epoch number */
744 unsigned current_tle_writes; /* writes seen within this tl epoch */
745
746 unsigned long last_reconnect_jif;
747 /* empty member on older kernels without blk_start_plug() */
748 struct blk_plug receiver_plug;
749 struct drbd_thread receiver;
750 struct drbd_thread worker;
751 struct drbd_thread ack_receiver;
752 struct workqueue_struct *ack_sender;
753
754 /* cached pointers,
755 * so we can look up the oldest pending requests more quickly.
756 * protected by resource->req_lock */
757 struct drbd_request *req_next; /* DRBD 9: todo.req_next */
758 struct drbd_request *req_ack_pending;
759 struct drbd_request *req_not_net_done;
760
761 /* sender side */
762 struct drbd_work_queue sender_work;
763
764#define DRBD_THREAD_DETAILS_HIST 16
765 unsigned int w_cb_nr; /* keeps counting up */
766 unsigned int r_cb_nr; /* keeps counting up */
767 struct drbd_thread_timing_details w_timing_details[DRBD_THREAD_DETAILS_HIST];
768 struct drbd_thread_timing_details r_timing_details[DRBD_THREAD_DETAILS_HIST];
769
770 struct {
771 unsigned long last_sent_barrier_jif;
772
773 /* whether this sender thread
774 * has processed a single write yet. */
775 bool seen_any_write_yet;
776
777 /* Which barrier number to send with the next P_BARRIER */
778 int current_epoch_nr;
779
780 /* how many write requests have been sent
781 * with req->epoch == current_epoch_nr.
782 * If none, no P_BARRIER will be sent. */
783 unsigned current_epoch_writes;
784 } send;
785};
786
787static inline bool has_net_conf(struct drbd_connection *connection)
788{
789 bool has_net_conf;
790
791 rcu_read_lock();
792 has_net_conf = rcu_dereference(connection->net_conf);
793 rcu_read_unlock();
794
795 return has_net_conf;
796}
797
798void __update_timing_details(
799 struct drbd_thread_timing_details *tdp,
800 unsigned int *cb_nr,
801 void *cb,
802 const char *fn, const unsigned int line);
803
804#define update_worker_timing_details(c, cb) \
805 __update_timing_details(c->w_timing_details, &c->w_cb_nr, cb, __func__ , __LINE__ )
806#define update_receiver_timing_details(c, cb) \
807 __update_timing_details(c->r_timing_details, &c->r_cb_nr, cb, __func__ , __LINE__ )
808
809struct submit_worker {
810 struct workqueue_struct *wq;
811 struct work_struct worker;
812
813 /* protected by ..->resource->req_lock */
814 struct list_head writes;
815};
816
817struct drbd_peer_device {
818 struct list_head peer_devices;
819 struct drbd_device *device;
820 struct drbd_connection *connection;
821 struct work_struct send_acks_work;
822#ifdef CONFIG_DEBUG_FS
823 struct dentry *debugfs_peer_dev;
824#endif
825};
826
827struct drbd_device {
828 struct drbd_resource *resource;
829 struct list_head peer_devices;
830 struct list_head pending_bitmap_io;
831
832 unsigned long flush_jif;
833#ifdef CONFIG_DEBUG_FS
834 struct dentry *debugfs_minor;
835 struct dentry *debugfs_vol;
836 struct dentry *debugfs_vol_oldest_requests;
837 struct dentry *debugfs_vol_act_log_extents;
838 struct dentry *debugfs_vol_resync_extents;
839 struct dentry *debugfs_vol_data_gen_id;
840 struct dentry *debugfs_vol_ed_gen_id;
841#endif
842
843 unsigned int vnr; /* volume number within the connection */
844 unsigned int minor; /* device minor number */
845
846 struct kref kref;
847
848 /* things that are stored as / read from meta data on disk */
849 unsigned long flags;
850
851 /* configured by drbdsetup */
852 struct drbd_backing_dev *ldev __protected_by(local);
853
854 sector_t p_size; /* partner's disk size */
855 struct request_queue *rq_queue;
856 struct block_device *this_bdev;
857 struct gendisk *vdisk;
858
859 unsigned long last_reattach_jif;
860 struct drbd_work resync_work;
861 struct drbd_work unplug_work;
862 struct timer_list resync_timer;
863 struct timer_list md_sync_timer;
864 struct timer_list start_resync_timer;
865 struct timer_list request_timer;
866
867 /* Used after attach while negotiating new disk state. */
868 union drbd_state new_state_tmp;
869
870 union drbd_dev_state state;
871 wait_queue_head_t misc_wait;
872 wait_queue_head_t state_wait; /* upon each state change. */
873 unsigned int send_cnt;
874 unsigned int recv_cnt;
875 unsigned int read_cnt;
876 unsigned int writ_cnt;
877 unsigned int al_writ_cnt;
878 unsigned int bm_writ_cnt;
879 atomic_t ap_bio_cnt; /* Requests we need to complete */
880 atomic_t ap_actlog_cnt; /* Requests waiting for activity log */
881 atomic_t ap_pending_cnt; /* AP data packets on the wire, ack expected */
882 atomic_t rs_pending_cnt; /* RS request/data packets on the wire */
883 atomic_t unacked_cnt; /* Need to send replies for */
884 atomic_t local_cnt; /* Waiting for local completion */
885 atomic_t suspend_cnt;
886
887 /* Interval tree of pending local requests */
888 struct rb_root read_requests;
889 struct rb_root write_requests;
890
891 /* for statistics and timeouts */
892 /* [0] read, [1] write */
893 struct list_head pending_master_completion[2];
894 struct list_head pending_completion[2];
895
896 /* use checksums for *this* resync */
897 bool use_csums;
898 /* blocks to resync in this run [unit BM_BLOCK_SIZE] */
899 unsigned long rs_total;
900 /* number of resync blocks that failed in this run */
901 unsigned long rs_failed;
902 /* Syncer's start time [unit jiffies] */
903 unsigned long rs_start;
904 /* cumulated time in PausedSyncX state [unit jiffies] */
905 unsigned long rs_paused;
906 /* skipped because csum was equal [unit BM_BLOCK_SIZE] */
907 unsigned long rs_same_csum;
908#define DRBD_SYNC_MARKS 8
909#define DRBD_SYNC_MARK_STEP (3*HZ)
910 /* block not up-to-date at mark [unit BM_BLOCK_SIZE] */
911 unsigned long rs_mark_left[DRBD_SYNC_MARKS];
912 /* marks's time [unit jiffies] */
913 unsigned long rs_mark_time[DRBD_SYNC_MARKS];
914 /* current index into rs_mark_{left,time} */
915 int rs_last_mark;
916 unsigned long rs_last_bcast; /* [unit jiffies] */
917
918 /* where does the admin want us to start? (sector) */
919 sector_t ov_start_sector;
920 sector_t ov_stop_sector;
921 /* where are we now? (sector) */
922 sector_t ov_position;
923 /* Start sector of out of sync range (to merge printk reporting). */
924 sector_t ov_last_oos_start;
925 /* size of out-of-sync range in sectors. */
926 sector_t ov_last_oos_size;
927 unsigned long ov_left; /* in bits */
928
929 struct drbd_bitmap *bitmap;
930 unsigned long bm_resync_fo; /* bit offset for drbd_bm_find_next */
931
932 /* Used to track operations of resync... */
933 struct lru_cache *resync;
934 /* Number of locked elements in resync LRU */
935 unsigned int resync_locked;
936 /* resync extent number waiting for application requests */
937 unsigned int resync_wenr;
938
939 int open_cnt;
940 u64 *p_uuid;
941
942 struct list_head active_ee; /* IO in progress (P_DATA gets written to disk) */
943 struct list_head sync_ee; /* IO in progress (P_RS_DATA_REPLY gets written to disk) */
944 struct list_head done_ee; /* need to send P_WRITE_ACK */
945 struct list_head read_ee; /* [RS]P_DATA_REQUEST being read */
946 struct list_head net_ee; /* zero-copy network send in progress */
947
948 int next_barrier_nr;
949 struct list_head resync_reads;
950 atomic_t pp_in_use; /* allocated from page pool */
951 atomic_t pp_in_use_by_net; /* sendpage()d, still referenced by tcp */
952 wait_queue_head_t ee_wait;
953 struct drbd_md_io md_io;
954 spinlock_t al_lock;
955 wait_queue_head_t al_wait;
956 struct lru_cache *act_log; /* activity log */
957 unsigned int al_tr_number;
958 int al_tr_cycle;
959 wait_queue_head_t seq_wait;
960 atomic_t packet_seq;
961 unsigned int peer_seq;
962 spinlock_t peer_seq_lock;
963 unsigned long comm_bm_set; /* communicated number of set bits. */
964 struct bm_io_work bm_io_work;
965 u64 ed_uuid; /* UUID of the exposed data */
966 struct mutex own_state_mutex;
967 struct mutex *state_mutex; /* either own_state_mutex or first_peer_device(device)->connection->cstate_mutex */
968 char congestion_reason; /* Why we where congested... */
969 atomic_t rs_sect_in; /* for incoming resync data rate, SyncTarget */
970 atomic_t rs_sect_ev; /* for submitted resync data rate, both */
971 int rs_last_sect_ev; /* counter to compare with */
972 int rs_last_events; /* counter of read or write "events" (unit sectors)
973 * on the lower level device when we last looked. */
974 int c_sync_rate; /* current resync rate after syncer throttle magic */
975 struct fifo_buffer *rs_plan_s; /* correction values of resync planer (RCU, connection->conn_update) */
976 int rs_in_flight; /* resync sectors in flight (to proxy, in proxy and from proxy) */
977 atomic_t ap_in_flight; /* App sectors in flight (waiting for ack) */
978 unsigned int peer_max_bio_size;
979 unsigned int local_max_bio_size;
980
981 /* any requests that would block in drbd_make_request()
982 * are deferred to this single-threaded work queue */
983 struct submit_worker submit;
984};
985
986struct drbd_bm_aio_ctx {
987 struct drbd_device *device;
988 struct list_head list; /* on device->pending_bitmap_io */;
989 unsigned long start_jif;
990 atomic_t in_flight;
991 unsigned int done;
992 unsigned flags;
993#define BM_AIO_COPY_PAGES 1
994#define BM_AIO_WRITE_HINTED 2
995#define BM_AIO_WRITE_ALL_PAGES 4
996#define BM_AIO_READ 8
997 int error;
998 struct kref kref;
999};
1000
1001struct drbd_config_context {
1002 /* assigned from drbd_genlmsghdr */
1003 unsigned int minor;
1004 /* assigned from request attributes, if present */
1005 unsigned int volume;
1006#define VOLUME_UNSPECIFIED (-1U)
1007 /* pointer into the request skb,
1008 * limited lifetime! */
1009 char *resource_name;
1010 struct nlattr *my_addr;
1011 struct nlattr *peer_addr;
1012
1013 /* reply buffer */
1014 struct sk_buff *reply_skb;
1015 /* pointer into reply buffer */
1016 struct drbd_genlmsghdr *reply_dh;
1017 /* resolved from attributes, if possible */
1018 struct drbd_device *device;
1019 struct drbd_resource *resource;
1020 struct drbd_connection *connection;
1021};
1022
1023static inline struct drbd_device *minor_to_device(unsigned int minor)
1024{
1025 return (struct drbd_device *)idr_find(&drbd_devices, minor);
1026}
1027
1028static inline struct drbd_peer_device *first_peer_device(struct drbd_device *device)
1029{
1030 return list_first_entry_or_null(&device->peer_devices, struct drbd_peer_device, peer_devices);
1031}
1032
1033static inline struct drbd_peer_device *
1034conn_peer_device(struct drbd_connection *connection, int volume_number)
1035{
1036 return idr_find(&connection->peer_devices, volume_number);
1037}
1038
1039#define for_each_resource(resource, _resources) \
1040 list_for_each_entry(resource, _resources, resources)
1041
1042#define for_each_resource_rcu(resource, _resources) \
1043 list_for_each_entry_rcu(resource, _resources, resources)
1044
1045#define for_each_resource_safe(resource, tmp, _resources) \
1046 list_for_each_entry_safe(resource, tmp, _resources, resources)
1047
1048#define for_each_connection(connection, resource) \
1049 list_for_each_entry(connection, &resource->connections, connections)
1050
1051#define for_each_connection_rcu(connection, resource) \
1052 list_for_each_entry_rcu(connection, &resource->connections, connections)
1053
1054#define for_each_connection_safe(connection, tmp, resource) \
1055 list_for_each_entry_safe(connection, tmp, &resource->connections, connections)
1056
1057#define for_each_peer_device(peer_device, device) \
1058 list_for_each_entry(peer_device, &device->peer_devices, peer_devices)
1059
1060#define for_each_peer_device_rcu(peer_device, device) \
1061 list_for_each_entry_rcu(peer_device, &device->peer_devices, peer_devices)
1062
1063#define for_each_peer_device_safe(peer_device, tmp, device) \
1064 list_for_each_entry_safe(peer_device, tmp, &device->peer_devices, peer_devices)
1065
1066static inline unsigned int device_to_minor(struct drbd_device *device)
1067{
1068 return device->minor;
1069}
1070
1071/*
1072 * function declarations
1073 *************************/
1074
1075/* drbd_main.c */
1076
1077enum dds_flags {
1078 DDSF_FORCED = 1,
1079 DDSF_NO_RESYNC = 2, /* Do not run a resync for the new space */
1080};
1081
1082extern void drbd_init_set_defaults(struct drbd_device *device);
1083extern int drbd_thread_start(struct drbd_thread *thi);
1084extern void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait);
1085#ifdef CONFIG_SMP
1086extern void drbd_thread_current_set_cpu(struct drbd_thread *thi);
1087#else
1088#define drbd_thread_current_set_cpu(A) ({})
1089#endif
1090extern void tl_release(struct drbd_connection *, unsigned int barrier_nr,
1091 unsigned int set_size);
1092extern void tl_clear(struct drbd_connection *);
1093extern void drbd_free_sock(struct drbd_connection *connection);
1094extern int drbd_send(struct drbd_connection *connection, struct socket *sock,
1095 void *buf, size_t size, unsigned msg_flags);
1096extern int drbd_send_all(struct drbd_connection *, struct socket *, void *, size_t,
1097 unsigned);
1098
1099extern int __drbd_send_protocol(struct drbd_connection *connection, enum drbd_packet cmd);
1100extern int drbd_send_protocol(struct drbd_connection *connection);
1101extern int drbd_send_uuids(struct drbd_peer_device *);
1102extern int drbd_send_uuids_skip_initial_sync(struct drbd_peer_device *);
1103extern void drbd_gen_and_send_sync_uuid(struct drbd_peer_device *);
1104extern int drbd_send_sizes(struct drbd_peer_device *, int trigger_reply, enum dds_flags flags);
1105extern int drbd_send_state(struct drbd_peer_device *, union drbd_state s);
1106extern int drbd_send_current_state(struct drbd_peer_device *);
1107extern int drbd_send_sync_param(struct drbd_peer_device *);
1108extern void drbd_send_b_ack(struct drbd_connection *connection, u32 barrier_nr,
1109 u32 set_size);
1110extern int drbd_send_ack(struct drbd_peer_device *, enum drbd_packet,
1111 struct drbd_peer_request *);
1112extern void drbd_send_ack_rp(struct drbd_peer_device *, enum drbd_packet,
1113 struct p_block_req *rp);
1114extern void drbd_send_ack_dp(struct drbd_peer_device *, enum drbd_packet,
1115 struct p_data *dp, int data_size);
1116extern int drbd_send_ack_ex(struct drbd_peer_device *, enum drbd_packet,
1117 sector_t sector, int blksize, u64 block_id);
1118extern int drbd_send_out_of_sync(struct drbd_peer_device *, struct drbd_request *);
1119extern int drbd_send_block(struct drbd_peer_device *, enum drbd_packet,
1120 struct drbd_peer_request *);
1121extern int drbd_send_dblock(struct drbd_peer_device *, struct drbd_request *req);
1122extern int drbd_send_drequest(struct drbd_peer_device *, int cmd,
1123 sector_t sector, int size, u64 block_id);
1124extern int drbd_send_drequest_csum(struct drbd_peer_device *, sector_t sector,
1125 int size, void *digest, int digest_size,
1126 enum drbd_packet cmd);
1127extern int drbd_send_ov_request(struct drbd_peer_device *, sector_t sector, int size);
1128
1129extern int drbd_send_bitmap(struct drbd_device *device);
1130extern void drbd_send_sr_reply(struct drbd_peer_device *, enum drbd_state_rv retcode);
1131extern void conn_send_sr_reply(struct drbd_connection *connection, enum drbd_state_rv retcode);
1132extern int drbd_send_rs_deallocated(struct drbd_peer_device *, struct drbd_peer_request *);
1133extern void drbd_backing_dev_free(struct drbd_device *device, struct drbd_backing_dev *ldev);
1134extern void drbd_device_cleanup(struct drbd_device *device);
1135extern void drbd_print_uuids(struct drbd_device *device, const char *text);
1136extern void drbd_queue_unplug(struct drbd_device *device);
1137
1138extern void conn_md_sync(struct drbd_connection *connection);
1139extern void drbd_md_write(struct drbd_device *device, void *buffer);
1140extern void drbd_md_sync(struct drbd_device *device);
1141extern int drbd_md_read(struct drbd_device *device, struct drbd_backing_dev *bdev);
1142extern void drbd_uuid_set(struct drbd_device *device, int idx, u64 val) __must_hold(local);
1143extern void _drbd_uuid_set(struct drbd_device *device, int idx, u64 val) __must_hold(local);
1144extern void drbd_uuid_new_current(struct drbd_device *device) __must_hold(local);
1145extern void drbd_uuid_set_bm(struct drbd_device *device, u64 val) __must_hold(local);
1146extern void drbd_uuid_move_history(struct drbd_device *device) __must_hold(local);
1147extern void __drbd_uuid_set(struct drbd_device *device, int idx, u64 val) __must_hold(local);
1148extern void drbd_md_set_flag(struct drbd_device *device, int flags) __must_hold(local);
1149extern void drbd_md_clear_flag(struct drbd_device *device, int flags)__must_hold(local);
1150extern int drbd_md_test_flag(struct drbd_backing_dev *, int);
1151extern void drbd_md_mark_dirty(struct drbd_device *device);
1152extern void drbd_queue_bitmap_io(struct drbd_device *device,
1153 int (*io_fn)(struct drbd_device *),
1154 void (*done)(struct drbd_device *, int),
1155 char *why, enum bm_flag flags);
1156extern int drbd_bitmap_io(struct drbd_device *device,
1157 int (*io_fn)(struct drbd_device *),
1158 char *why, enum bm_flag flags);
1159extern int drbd_bitmap_io_from_worker(struct drbd_device *device,
1160 int (*io_fn)(struct drbd_device *),
1161 char *why, enum bm_flag flags);
1162extern int drbd_bmio_set_n_write(struct drbd_device *device) __must_hold(local);
1163extern int drbd_bmio_clear_n_write(struct drbd_device *device) __must_hold(local);
1164
1165/* Meta data layout
1166 *
1167 * We currently have two possible layouts.
1168 * Offsets in (512 byte) sectors.
1169 * external:
1170 * |----------- md_size_sect ------------------|
1171 * [ 4k superblock ][ activity log ][ Bitmap ]
1172 * | al_offset == 8 |
1173 * | bm_offset = al_offset + X |
1174 * ==> bitmap sectors = md_size_sect - bm_offset
1175 *
1176 * Variants:
1177 * old, indexed fixed size meta data:
1178 *
1179 * internal:
1180 * |----------- md_size_sect ------------------|
1181 * [data.....][ Bitmap ][ activity log ][ 4k superblock ][padding*]
1182 * | al_offset < 0 |
1183 * | bm_offset = al_offset - Y |
1184 * ==> bitmap sectors = Y = al_offset - bm_offset
1185 *
1186 * [padding*] are zero or up to 7 unused 512 Byte sectors to the
1187 * end of the device, so that the [4k superblock] will be 4k aligned.
1188 *
1189 * The activity log consists of 4k transaction blocks,
1190 * which are written in a ring-buffer, or striped ring-buffer like fashion,
1191 * which are writtensize used to be fixed 32kB,
1192 * but is about to become configurable.
1193 */
1194
1195/* Our old fixed size meta data layout
1196 * allows up to about 3.8TB, so if you want more,
1197 * you need to use the "flexible" meta data format. */
1198#define MD_128MB_SECT (128LLU << 11) /* 128 MB, unit sectors */
1199#define MD_4kB_SECT 8
1200#define MD_32kB_SECT 64
1201
1202/* One activity log extent represents 4M of storage */
1203#define AL_EXTENT_SHIFT 22
1204#define AL_EXTENT_SIZE (1<<AL_EXTENT_SHIFT)
1205
1206/* We could make these currently hardcoded constants configurable
1207 * variables at create-md time (or even re-configurable at runtime?).
1208 * Which will require some more changes to the DRBD "super block"
1209 * and attach code.
1210 *
1211 * updates per transaction:
1212 * This many changes to the active set can be logged with one transaction.
1213 * This number is arbitrary.
1214 * context per transaction:
1215 * This many context extent numbers are logged with each transaction.
1216 * This number is resulting from the transaction block size (4k), the layout
1217 * of the transaction header, and the number of updates per transaction.
1218 * See drbd_actlog.c:struct al_transaction_on_disk
1219 * */
1220#define AL_UPDATES_PER_TRANSACTION 64 // arbitrary
1221#define AL_CONTEXT_PER_TRANSACTION 919 // (4096 - 36 - 6*64)/4
1222
1223#if BITS_PER_LONG == 32
1224#define LN2_BPL 5
1225#define cpu_to_lel(A) cpu_to_le32(A)
1226#define lel_to_cpu(A) le32_to_cpu(A)
1227#elif BITS_PER_LONG == 64
1228#define LN2_BPL 6
1229#define cpu_to_lel(A) cpu_to_le64(A)
1230#define lel_to_cpu(A) le64_to_cpu(A)
1231#else
1232#error "LN2 of BITS_PER_LONG unknown!"
1233#endif
1234
1235/* resync bitmap */
1236/* 16MB sized 'bitmap extent' to track syncer usage */
1237struct bm_extent {
1238 int rs_left; /* number of bits set (out of sync) in this extent. */
1239 int rs_failed; /* number of failed resync requests in this extent. */
1240 unsigned long flags;
1241 struct lc_element lce;
1242};
1243
1244#define BME_NO_WRITES 0 /* bm_extent.flags: no more requests on this one! */
1245#define BME_LOCKED 1 /* bm_extent.flags: syncer active on this one. */
1246#define BME_PRIORITY 2 /* finish resync IO on this extent ASAP! App IO waiting! */
1247
1248/* drbd_bitmap.c */
1249/*
1250 * We need to store one bit for a block.
1251 * Example: 1GB disk @ 4096 byte blocks ==> we need 32 KB bitmap.
1252 * Bit 0 ==> local node thinks this block is binary identical on both nodes
1253 * Bit 1 ==> local node thinks this block needs to be synced.
1254 */
1255
1256#define SLEEP_TIME (HZ/10)
1257
1258/* We do bitmap IO in units of 4k blocks.
1259 * We also still have a hardcoded 4k per bit relation. */
1260#define BM_BLOCK_SHIFT 12 /* 4k per bit */
1261#define BM_BLOCK_SIZE (1<<BM_BLOCK_SHIFT)
1262/* mostly arbitrarily set the represented size of one bitmap extent,
1263 * aka resync extent, to 16 MiB (which is also 512 Byte worth of bitmap
1264 * at 4k per bit resolution) */
1265#define BM_EXT_SHIFT 24 /* 16 MiB per resync extent */
1266#define BM_EXT_SIZE (1<<BM_EXT_SHIFT)
1267
1268#if (BM_EXT_SHIFT != 24) || (BM_BLOCK_SHIFT != 12)
1269#error "HAVE YOU FIXED drbdmeta AS WELL??"
1270#endif
1271
1272/* thus many _storage_ sectors are described by one bit */
1273#define BM_SECT_TO_BIT(x) ((x)>>(BM_BLOCK_SHIFT-9))
1274#define BM_BIT_TO_SECT(x) ((sector_t)(x)<<(BM_BLOCK_SHIFT-9))
1275#define BM_SECT_PER_BIT BM_BIT_TO_SECT(1)
1276
1277/* bit to represented kilo byte conversion */
1278#define Bit2KB(bits) ((bits)<<(BM_BLOCK_SHIFT-10))
1279
1280/* in which _bitmap_ extent (resp. sector) the bit for a certain
1281 * _storage_ sector is located in */
1282#define BM_SECT_TO_EXT(x) ((x)>>(BM_EXT_SHIFT-9))
1283#define BM_BIT_TO_EXT(x) ((x) >> (BM_EXT_SHIFT - BM_BLOCK_SHIFT))
1284
1285/* first storage sector a bitmap extent corresponds to */
1286#define BM_EXT_TO_SECT(x) ((sector_t)(x) << (BM_EXT_SHIFT-9))
1287/* how much _storage_ sectors we have per bitmap extent */
1288#define BM_SECT_PER_EXT BM_EXT_TO_SECT(1)
1289/* how many bits are covered by one bitmap extent (resync extent) */
1290#define BM_BITS_PER_EXT (1UL << (BM_EXT_SHIFT - BM_BLOCK_SHIFT))
1291
1292#define BM_BLOCKS_PER_BM_EXT_MASK (BM_BITS_PER_EXT - 1)
1293
1294
1295/* in one sector of the bitmap, we have this many activity_log extents. */
1296#define AL_EXT_PER_BM_SECT (1 << (BM_EXT_SHIFT - AL_EXTENT_SHIFT))
1297
1298/* the extent in "PER_EXTENT" below is an activity log extent
1299 * we need that many (long words/bytes) to store the bitmap
1300 * of one AL_EXTENT_SIZE chunk of storage.
1301 * we can store the bitmap for that many AL_EXTENTS within
1302 * one sector of the _on_disk_ bitmap:
1303 * bit 0 bit 37 bit 38 bit (512*8)-1
1304 * ...|........|........|.. // ..|........|
1305 * sect. 0 `296 `304 ^(512*8*8)-1
1306 *
1307#define BM_WORDS_PER_EXT ( (AL_EXT_SIZE/BM_BLOCK_SIZE) / BITS_PER_LONG )
1308#define BM_BYTES_PER_EXT ( (AL_EXT_SIZE/BM_BLOCK_SIZE) / 8 ) // 128
1309#define BM_EXT_PER_SECT ( 512 / BM_BYTES_PER_EXTENT ) // 4
1310 */
1311
1312#define DRBD_MAX_SECTORS_32 (0xffffffffLU)
1313/* we have a certain meta data variant that has a fixed on-disk size of 128
1314 * MiB, of which 4k are our "superblock", and 32k are the fixed size activity
1315 * log, leaving this many sectors for the bitmap.
1316 */
1317
1318#define DRBD_MAX_SECTORS_FIXED_BM \
1319 ((MD_128MB_SECT - MD_32kB_SECT - MD_4kB_SECT) * (1LL<<(BM_EXT_SHIFT-9)))
1320#if !defined(CONFIG_LBDAF) && BITS_PER_LONG == 32
1321#define DRBD_MAX_SECTORS DRBD_MAX_SECTORS_32
1322#define DRBD_MAX_SECTORS_FLEX DRBD_MAX_SECTORS_32
1323#else
1324#define DRBD_MAX_SECTORS DRBD_MAX_SECTORS_FIXED_BM
1325/* 16 TB in units of sectors */
1326#if BITS_PER_LONG == 32
1327/* adjust by one page worth of bitmap,
1328 * so we won't wrap around in drbd_bm_find_next_bit.
1329 * you should use 64bit OS for that much storage, anyways. */
1330#define DRBD_MAX_SECTORS_FLEX BM_BIT_TO_SECT(0xffff7fff)
1331#else
1332/* we allow up to 1 PiB now on 64bit architecture with "flexible" meta data */
1333#define DRBD_MAX_SECTORS_FLEX (1UL << 51)
1334/* corresponds to (1UL << 38) bits right now. */
1335#endif
1336#endif
1337
1338/* Estimate max bio size as 256 * PAGE_SIZE,
1339 * so for typical PAGE_SIZE of 4k, that is (1<<20) Byte.
1340 * Since we may live in a mixed-platform cluster,
1341 * we limit us to a platform agnostic constant here for now.
1342 * A followup commit may allow even bigger BIO sizes,
1343 * once we thought that through. */
1344#define DRBD_MAX_BIO_SIZE (1U << 20)
1345#if DRBD_MAX_BIO_SIZE > (BIO_MAX_PAGES << PAGE_SHIFT)
1346#error Architecture not supported: DRBD_MAX_BIO_SIZE > BIO_MAX_SIZE
1347#endif
1348#define DRBD_MAX_BIO_SIZE_SAFE (1U << 12) /* Works always = 4k */
1349
1350#define DRBD_MAX_SIZE_H80_PACKET (1U << 15) /* Header 80 only allows packets up to 32KiB data */
1351#define DRBD_MAX_BIO_SIZE_P95 (1U << 17) /* Protocol 95 to 99 allows bios up to 128KiB */
1352
1353/* For now, don't allow more than half of what we can "activate" in one
1354 * activity log transaction to be discarded in one go. We may need to rework
1355 * drbd_al_begin_io() to allow for even larger discard ranges */
1356#define DRBD_MAX_BATCH_BIO_SIZE (AL_UPDATES_PER_TRANSACTION/2*AL_EXTENT_SIZE)
1357#define DRBD_MAX_BBIO_SECTORS (DRBD_MAX_BATCH_BIO_SIZE >> 9)
1358
1359extern int drbd_bm_init(struct drbd_device *device);
1360extern int drbd_bm_resize(struct drbd_device *device, sector_t sectors, int set_new_bits);
1361extern void drbd_bm_cleanup(struct drbd_device *device);
1362extern void drbd_bm_set_all(struct drbd_device *device);
1363extern void drbd_bm_clear_all(struct drbd_device *device);
1364/* set/clear/test only a few bits at a time */
1365extern int drbd_bm_set_bits(
1366 struct drbd_device *device, unsigned long s, unsigned long e);
1367extern int drbd_bm_clear_bits(
1368 struct drbd_device *device, unsigned long s, unsigned long e);
1369extern int drbd_bm_count_bits(
1370 struct drbd_device *device, const unsigned long s, const unsigned long e);
1371/* bm_set_bits variant for use while holding drbd_bm_lock,
1372 * may process the whole bitmap in one go */
1373extern void _drbd_bm_set_bits(struct drbd_device *device,
1374 const unsigned long s, const unsigned long e);
1375extern int drbd_bm_test_bit(struct drbd_device *device, unsigned long bitnr);
1376extern int drbd_bm_e_weight(struct drbd_device *device, unsigned long enr);
1377extern int drbd_bm_read(struct drbd_device *device) __must_hold(local);
1378extern void drbd_bm_mark_for_writeout(struct drbd_device *device, int page_nr);
1379extern int drbd_bm_write(struct drbd_device *device) __must_hold(local);
1380extern void drbd_bm_reset_al_hints(struct drbd_device *device) __must_hold(local);
1381extern int drbd_bm_write_hinted(struct drbd_device *device) __must_hold(local);
1382extern int drbd_bm_write_lazy(struct drbd_device *device, unsigned upper_idx) __must_hold(local);
1383extern int drbd_bm_write_all(struct drbd_device *device) __must_hold(local);
1384extern int drbd_bm_write_copy_pages(struct drbd_device *device) __must_hold(local);
1385extern size_t drbd_bm_words(struct drbd_device *device);
1386extern unsigned long drbd_bm_bits(struct drbd_device *device);
1387extern sector_t drbd_bm_capacity(struct drbd_device *device);
1388
1389#define DRBD_END_OF_BITMAP (~(unsigned long)0)
1390extern unsigned long drbd_bm_find_next(struct drbd_device *device, unsigned long bm_fo);
1391/* bm_find_next variants for use while you hold drbd_bm_lock() */
1392extern unsigned long _drbd_bm_find_next(struct drbd_device *device, unsigned long bm_fo);
1393extern unsigned long _drbd_bm_find_next_zero(struct drbd_device *device, unsigned long bm_fo);
1394extern unsigned long _drbd_bm_total_weight(struct drbd_device *device);
1395extern unsigned long drbd_bm_total_weight(struct drbd_device *device);
1396/* for receive_bitmap */
1397extern void drbd_bm_merge_lel(struct drbd_device *device, size_t offset,
1398 size_t number, unsigned long *buffer);
1399/* for _drbd_send_bitmap */
1400extern void drbd_bm_get_lel(struct drbd_device *device, size_t offset,
1401 size_t number, unsigned long *buffer);
1402
1403extern void drbd_bm_lock(struct drbd_device *device, char *why, enum bm_flag flags);
1404extern void drbd_bm_unlock(struct drbd_device *device);
1405/* drbd_main.c */
1406
1407extern struct kmem_cache *drbd_request_cache;
1408extern struct kmem_cache *drbd_ee_cache; /* peer requests */
1409extern struct kmem_cache *drbd_bm_ext_cache; /* bitmap extents */
1410extern struct kmem_cache *drbd_al_ext_cache; /* activity log extents */
1411extern mempool_t drbd_request_mempool;
1412extern mempool_t drbd_ee_mempool;
1413
1414/* drbd's page pool, used to buffer data received from the peer,
1415 * or data requested by the peer.
1416 *
1417 * This does not have an emergency reserve.
1418 *
1419 * When allocating from this pool, it first takes pages from the pool.
1420 * Only if the pool is depleted will try to allocate from the system.
1421 *
1422 * The assumption is that pages taken from this pool will be processed,
1423 * and given back, "quickly", and then can be recycled, so we can avoid
1424 * frequent calls to alloc_page(), and still will be able to make progress even
1425 * under memory pressure.
1426 */
1427extern struct page *drbd_pp_pool;
1428extern spinlock_t drbd_pp_lock;
1429extern int drbd_pp_vacant;
1430extern wait_queue_head_t drbd_pp_wait;
1431
1432/* We also need a standard (emergency-reserve backed) page pool
1433 * for meta data IO (activity log, bitmap).
1434 * We can keep it global, as long as it is used as "N pages at a time".
1435 * 128 should be plenty, currently we probably can get away with as few as 1.
1436 */
1437#define DRBD_MIN_POOL_PAGES 128
1438extern mempool_t drbd_md_io_page_pool;
1439
1440/* We also need to make sure we get a bio
1441 * when we need it for housekeeping purposes */
1442extern struct bio_set drbd_md_io_bio_set;
1443/* to allocate from that set */
1444extern struct bio *bio_alloc_drbd(gfp_t gfp_mask);
1445
1446/* And a bio_set for cloning */
1447extern struct bio_set drbd_io_bio_set;
1448
1449extern struct mutex resources_mutex;
1450
1451extern int conn_lowest_minor(struct drbd_connection *connection);
1452extern enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsigned int minor);
1453extern void drbd_destroy_device(struct kref *kref);
1454extern void drbd_delete_device(struct drbd_device *device);
1455
1456extern struct drbd_resource *drbd_create_resource(const char *name);
1457extern void drbd_free_resource(struct drbd_resource *resource);
1458
1459extern int set_resource_options(struct drbd_resource *resource, struct res_opts *res_opts);
1460extern struct drbd_connection *conn_create(const char *name, struct res_opts *res_opts);
1461extern void drbd_destroy_connection(struct kref *kref);
1462extern struct drbd_connection *conn_get_by_addrs(void *my_addr, int my_addr_len,
1463 void *peer_addr, int peer_addr_len);
1464extern struct drbd_resource *drbd_find_resource(const char *name);
1465extern void drbd_destroy_resource(struct kref *kref);
1466extern void conn_free_crypto(struct drbd_connection *connection);
1467
1468/* drbd_req */
1469extern void do_submit(struct work_struct *ws);
1470extern void __drbd_make_request(struct drbd_device *, struct bio *, unsigned long);
1471extern blk_qc_t drbd_make_request(struct request_queue *q, struct bio *bio);
1472extern int drbd_read_remote(struct drbd_device *device, struct drbd_request *req);
1473extern int is_valid_ar_handle(struct drbd_request *, sector_t);
1474
1475
1476/* drbd_nl.c */
1477
1478extern struct mutex notification_mutex;
1479
1480extern void drbd_suspend_io(struct drbd_device *device);
1481extern void drbd_resume_io(struct drbd_device *device);
1482extern char *ppsize(char *buf, unsigned long long size);
1483extern sector_t drbd_new_dev_size(struct drbd_device *, struct drbd_backing_dev *, sector_t, int);
1484enum determine_dev_size {
1485 DS_ERROR_SHRINK = -3,
1486 DS_ERROR_SPACE_MD = -2,
1487 DS_ERROR = -1,
1488 DS_UNCHANGED = 0,
1489 DS_SHRUNK = 1,
1490 DS_GREW = 2,
1491 DS_GREW_FROM_ZERO = 3,
1492};
1493extern enum determine_dev_size
1494drbd_determine_dev_size(struct drbd_device *, enum dds_flags, struct resize_parms *) __must_hold(local);
1495extern void resync_after_online_grow(struct drbd_device *);
1496extern void drbd_reconsider_queue_parameters(struct drbd_device *device,
1497 struct drbd_backing_dev *bdev, struct o_qlim *o);
1498extern enum drbd_state_rv drbd_set_role(struct drbd_device *device,
1499 enum drbd_role new_role,
1500 int force);
1501extern bool conn_try_outdate_peer(struct drbd_connection *connection);
1502extern void conn_try_outdate_peer_async(struct drbd_connection *connection);
1503extern enum drbd_peer_state conn_khelper(struct drbd_connection *connection, char *cmd);
1504extern int drbd_khelper(struct drbd_device *device, char *cmd);
1505
1506/* drbd_worker.c */
1507/* bi_end_io handlers */
1508extern void drbd_md_endio(struct bio *bio);
1509extern void drbd_peer_request_endio(struct bio *bio);
1510extern void drbd_request_endio(struct bio *bio);
1511extern int drbd_worker(struct drbd_thread *thi);
1512enum drbd_ret_code drbd_resync_after_valid(struct drbd_device *device, int o_minor);
1513void drbd_resync_after_changed(struct drbd_device *device);
1514extern void drbd_start_resync(struct drbd_device *device, enum drbd_conns side);
1515extern void resume_next_sg(struct drbd_device *device);
1516extern void suspend_other_sg(struct drbd_device *device);
1517extern int drbd_resync_finished(struct drbd_device *device);
1518/* maybe rather drbd_main.c ? */
1519extern void *drbd_md_get_buffer(struct drbd_device *device, const char *intent);
1520extern void drbd_md_put_buffer(struct drbd_device *device);
1521extern int drbd_md_sync_page_io(struct drbd_device *device,
1522 struct drbd_backing_dev *bdev, sector_t sector, int op);
1523extern void drbd_ov_out_of_sync_found(struct drbd_device *, sector_t, int);
1524extern void wait_until_done_or_force_detached(struct drbd_device *device,
1525 struct drbd_backing_dev *bdev, unsigned int *done);
1526extern void drbd_rs_controller_reset(struct drbd_device *device);
1527
1528static inline void ov_out_of_sync_print(struct drbd_device *device)
1529{
1530 if (device->ov_last_oos_size) {
1531 drbd_err(device, "Out of sync: start=%llu, size=%lu (sectors)\n",
1532 (unsigned long long)device->ov_last_oos_start,
1533 (unsigned long)device->ov_last_oos_size);
1534 }
1535 device->ov_last_oos_size = 0;
1536}
1537
1538
1539extern void drbd_csum_bio(struct crypto_shash *, struct bio *, void *);
1540extern void drbd_csum_ee(struct crypto_shash *, struct drbd_peer_request *,
1541 void *);
1542/* worker callbacks */
1543extern int w_e_end_data_req(struct drbd_work *, int);
1544extern int w_e_end_rsdata_req(struct drbd_work *, int);
1545extern int w_e_end_csum_rs_req(struct drbd_work *, int);
1546extern int w_e_end_ov_reply(struct drbd_work *, int);
1547extern int w_e_end_ov_req(struct drbd_work *, int);
1548extern int w_ov_finished(struct drbd_work *, int);
1549extern int w_resync_timer(struct drbd_work *, int);
1550extern int w_send_write_hint(struct drbd_work *, int);
1551extern int w_send_dblock(struct drbd_work *, int);
1552extern int w_send_read_req(struct drbd_work *, int);
1553extern int w_e_reissue(struct drbd_work *, int);
1554extern int w_restart_disk_io(struct drbd_work *, int);
1555extern int w_send_out_of_sync(struct drbd_work *, int);
1556extern int w_start_resync(struct drbd_work *, int);
1557
1558extern void resync_timer_fn(struct timer_list *t);
1559extern void start_resync_timer_fn(struct timer_list *t);
1560
1561extern void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req);
1562
1563/* drbd_receiver.c */
1564extern int drbd_issue_discard_or_zero_out(struct drbd_device *device,
1565 sector_t start, unsigned int nr_sectors, int flags);
1566extern int drbd_receiver(struct drbd_thread *thi);
1567extern int drbd_ack_receiver(struct drbd_thread *thi);
1568extern void drbd_send_ping_wf(struct work_struct *ws);
1569extern void drbd_send_acks_wf(struct work_struct *ws);
1570extern bool drbd_rs_c_min_rate_throttle(struct drbd_device *device);
1571extern bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector,
1572 bool throttle_if_app_is_waiting);
1573extern int drbd_submit_peer_request(struct drbd_device *,
1574 struct drbd_peer_request *, const unsigned,
1575 const unsigned, const int);
1576extern int drbd_free_peer_reqs(struct drbd_device *, struct list_head *);
1577extern struct drbd_peer_request *drbd_alloc_peer_req(struct drbd_peer_device *, u64,
1578 sector_t, unsigned int,
1579 unsigned int,
1580 gfp_t) __must_hold(local);
1581extern void __drbd_free_peer_req(struct drbd_device *, struct drbd_peer_request *,
1582 int);
1583#define drbd_free_peer_req(m,e) __drbd_free_peer_req(m, e, 0)
1584#define drbd_free_net_peer_req(m,e) __drbd_free_peer_req(m, e, 1)
1585extern struct page *drbd_alloc_pages(struct drbd_peer_device *, unsigned int, bool);
1586extern void drbd_set_recv_tcq(struct drbd_device *device, int tcq_enabled);
1587extern void _drbd_clear_done_ee(struct drbd_device *device, struct list_head *to_be_freed);
1588extern int drbd_connected(struct drbd_peer_device *);
1589
1590static inline void drbd_tcp_cork(struct socket *sock)
1591{
1592 int val = 1;
1593 (void) kernel_setsockopt(sock, SOL_TCP, TCP_CORK,
1594 (char*)&val, sizeof(val));
1595}
1596
1597static inline void drbd_tcp_uncork(struct socket *sock)
1598{
1599 int val = 0;
1600 (void) kernel_setsockopt(sock, SOL_TCP, TCP_CORK,
1601 (char*)&val, sizeof(val));
1602}
1603
1604static inline void drbd_tcp_nodelay(struct socket *sock)
1605{
1606 int val = 1;
1607 (void) kernel_setsockopt(sock, SOL_TCP, TCP_NODELAY,
1608 (char*)&val, sizeof(val));
1609}
1610
1611static inline void drbd_tcp_quickack(struct socket *sock)
1612{
1613 int val = 2;
1614 (void) kernel_setsockopt(sock, SOL_TCP, TCP_QUICKACK,
1615 (char*)&val, sizeof(val));
1616}
1617
1618/* sets the number of 512 byte sectors of our virtual device */
1619void drbd_set_my_capacity(struct drbd_device *device, sector_t size);
1620
1621/*
1622 * used to submit our private bio
1623 */
1624static inline void drbd_generic_make_request(struct drbd_device *device,
1625 int fault_type, struct bio *bio)
1626{
1627 __release(local);
1628 if (!bio->bi_disk) {
1629 drbd_err(device, "drbd_generic_make_request: bio->bi_disk == NULL\n");
1630 bio->bi_status = BLK_STS_IOERR;
1631 bio_endio(bio);
1632 return;
1633 }
1634
1635 if (drbd_insert_fault(device, fault_type))
1636 bio_io_error(bio);
1637 else
1638 generic_make_request(bio);
1639}
1640
1641void drbd_bump_write_ordering(struct drbd_resource *resource, struct drbd_backing_dev *bdev,
1642 enum write_ordering_e wo);
1643
1644/* drbd_proc.c */
1645extern struct proc_dir_entry *drbd_proc;
1646int drbd_seq_show(struct seq_file *seq, void *v);
1647
1648/* drbd_actlog.c */
1649extern bool drbd_al_begin_io_prepare(struct drbd_device *device, struct drbd_interval *i);
1650extern int drbd_al_begin_io_nonblock(struct drbd_device *device, struct drbd_interval *i);
1651extern void drbd_al_begin_io_commit(struct drbd_device *device);
1652extern bool drbd_al_begin_io_fastpath(struct drbd_device *device, struct drbd_interval *i);
1653extern void drbd_al_begin_io(struct drbd_device *device, struct drbd_interval *i);
1654extern void drbd_al_complete_io(struct drbd_device *device, struct drbd_interval *i);
1655extern void drbd_rs_complete_io(struct drbd_device *device, sector_t sector);
1656extern int drbd_rs_begin_io(struct drbd_device *device, sector_t sector);
1657extern int drbd_try_rs_begin_io(struct drbd_device *device, sector_t sector);
1658extern void drbd_rs_cancel_all(struct drbd_device *device);
1659extern int drbd_rs_del_all(struct drbd_device *device);
1660extern void drbd_rs_failed_io(struct drbd_device *device,
1661 sector_t sector, int size);
1662extern void drbd_advance_rs_marks(struct drbd_device *device, unsigned long still_to_go);
1663
1664enum update_sync_bits_mode { RECORD_RS_FAILED, SET_OUT_OF_SYNC, SET_IN_SYNC };
1665extern int __drbd_change_sync(struct drbd_device *device, sector_t sector, int size,
1666 enum update_sync_bits_mode mode);
1667#define drbd_set_in_sync(device, sector, size) \
1668 __drbd_change_sync(device, sector, size, SET_IN_SYNC)
1669#define drbd_set_out_of_sync(device, sector, size) \
1670 __drbd_change_sync(device, sector, size, SET_OUT_OF_SYNC)
1671#define drbd_rs_failed_io(device, sector, size) \
1672 __drbd_change_sync(device, sector, size, RECORD_RS_FAILED)
1673extern void drbd_al_shrink(struct drbd_device *device);
1674extern int drbd_al_initialize(struct drbd_device *, void *);
1675
1676/* drbd_nl.c */
1677/* state info broadcast */
1678struct sib_info {
1679 enum drbd_state_info_bcast_reason sib_reason;
1680 union {
1681 struct {
1682 char *helper_name;
1683 unsigned helper_exit_code;
1684 };
1685 struct {
1686 union drbd_state os;
1687 union drbd_state ns;
1688 };
1689 };
1690};
1691void drbd_bcast_event(struct drbd_device *device, const struct sib_info *sib);
1692
1693extern void notify_resource_state(struct sk_buff *,
1694 unsigned int,
1695 struct drbd_resource *,
1696 struct resource_info *,
1697 enum drbd_notification_type);
1698extern void notify_device_state(struct sk_buff *,
1699 unsigned int,
1700 struct drbd_device *,
1701 struct device_info *,
1702 enum drbd_notification_type);
1703extern void notify_connection_state(struct sk_buff *,
1704 unsigned int,
1705 struct drbd_connection *,
1706 struct connection_info *,
1707 enum drbd_notification_type);
1708extern void notify_peer_device_state(struct sk_buff *,
1709 unsigned int,
1710 struct drbd_peer_device *,
1711 struct peer_device_info *,
1712 enum drbd_notification_type);
1713extern void notify_helper(enum drbd_notification_type, struct drbd_device *,
1714 struct drbd_connection *, const char *, int);
1715
1716/*
1717 * inline helper functions
1718 *************************/
1719
1720/* see also page_chain_add and friends in drbd_receiver.c */
1721static inline struct page *page_chain_next(struct page *page)
1722{
1723 return (struct page *)page_private(page);
1724}
1725#define page_chain_for_each(page) \
1726 for (; page && ({ prefetch(page_chain_next(page)); 1; }); \
1727 page = page_chain_next(page))
1728#define page_chain_for_each_safe(page, n) \
1729 for (; page && ({ n = page_chain_next(page); 1; }); page = n)
1730
1731
1732static inline int drbd_peer_req_has_active_page(struct drbd_peer_request *peer_req)
1733{
1734 struct page *page = peer_req->pages;
1735 page_chain_for_each(page) {
1736 if (page_count(page) > 1)
1737 return 1;
1738 }
1739 return 0;
1740}
1741
1742static inline union drbd_state drbd_read_state(struct drbd_device *device)
1743{
1744 struct drbd_resource *resource = device->resource;
1745 union drbd_state rv;
1746
1747 rv.i = device->state.i;
1748 rv.susp = resource->susp;
1749 rv.susp_nod = resource->susp_nod;
1750 rv.susp_fen = resource->susp_fen;
1751
1752 return rv;
1753}
1754
1755enum drbd_force_detach_flags {
1756 DRBD_READ_ERROR,
1757 DRBD_WRITE_ERROR,
1758 DRBD_META_IO_ERROR,
1759 DRBD_FORCE_DETACH,
1760};
1761
1762#define __drbd_chk_io_error(m,f) __drbd_chk_io_error_(m,f, __func__)
1763static inline void __drbd_chk_io_error_(struct drbd_device *device,
1764 enum drbd_force_detach_flags df,
1765 const char *where)
1766{
1767 enum drbd_io_error_p ep;
1768
1769 rcu_read_lock();
1770 ep = rcu_dereference(device->ldev->disk_conf)->on_io_error;
1771 rcu_read_unlock();
1772 switch (ep) {
1773 case EP_PASS_ON: /* FIXME would this be better named "Ignore"? */
1774 if (df == DRBD_READ_ERROR || df == DRBD_WRITE_ERROR) {
1775 if (__ratelimit(&drbd_ratelimit_state))
1776 drbd_err(device, "Local IO failed in %s.\n", where);
1777 if (device->state.disk > D_INCONSISTENT)
1778 _drbd_set_state(_NS(device, disk, D_INCONSISTENT), CS_HARD, NULL);
1779 break;
1780 }
1781 /* NOTE fall through for DRBD_META_IO_ERROR or DRBD_FORCE_DETACH */
1782 case EP_DETACH:
1783 case EP_CALL_HELPER:
1784 /* Remember whether we saw a READ or WRITE error.
1785 *
1786 * Recovery of the affected area for WRITE failure is covered
1787 * by the activity log.
1788 * READ errors may fall outside that area though. Certain READ
1789 * errors can be "healed" by writing good data to the affected
1790 * blocks, which triggers block re-allocation in lower layers.
1791 *
1792 * If we can not write the bitmap after a READ error,
1793 * we may need to trigger a full sync (see w_go_diskless()).
1794 *
1795 * Force-detach is not really an IO error, but rather a
1796 * desperate measure to try to deal with a completely
1797 * unresponsive lower level IO stack.
1798 * Still it should be treated as a WRITE error.
1799 *
1800 * Meta IO error is always WRITE error:
1801 * we read meta data only once during attach,
1802 * which will fail in case of errors.
1803 */
1804 set_bit(WAS_IO_ERROR, &device->flags);
1805 if (df == DRBD_READ_ERROR)
1806 set_bit(WAS_READ_ERROR, &device->flags);
1807 if (df == DRBD_FORCE_DETACH)
1808 set_bit(FORCE_DETACH, &device->flags);
1809 if (device->state.disk > D_FAILED) {
1810 _drbd_set_state(_NS(device, disk, D_FAILED), CS_HARD, NULL);
1811 drbd_err(device,
1812 "Local IO failed in %s. Detaching...\n", where);
1813 }
1814 break;
1815 }
1816}
1817
1818/**
1819 * drbd_chk_io_error: Handle the on_io_error setting, should be called from all io completion handlers
1820 * @device: DRBD device.
1821 * @error: Error code passed to the IO completion callback
1822 * @forcedetach: Force detach. I.e. the error happened while accessing the meta data
1823 *
1824 * See also drbd_main.c:after_state_ch() if (os.disk > D_FAILED && ns.disk == D_FAILED)
1825 */
1826#define drbd_chk_io_error(m,e,f) drbd_chk_io_error_(m,e,f, __func__)
1827static inline void drbd_chk_io_error_(struct drbd_device *device,
1828 int error, enum drbd_force_detach_flags forcedetach, const char *where)
1829{
1830 if (error) {
1831 unsigned long flags;
1832 spin_lock_irqsave(&device->resource->req_lock, flags);
1833 __drbd_chk_io_error_(device, forcedetach, where);
1834 spin_unlock_irqrestore(&device->resource->req_lock, flags);
1835 }
1836}
1837
1838
1839/**
1840 * drbd_md_first_sector() - Returns the first sector number of the meta data area
1841 * @bdev: Meta data block device.
1842 *
1843 * BTW, for internal meta data, this happens to be the maximum capacity
1844 * we could agree upon with our peer node.
1845 */
1846static inline sector_t drbd_md_first_sector(struct drbd_backing_dev *bdev)
1847{
1848 switch (bdev->md.meta_dev_idx) {
1849 case DRBD_MD_INDEX_INTERNAL:
1850 case DRBD_MD_INDEX_FLEX_INT:
1851 return bdev->md.md_offset + bdev->md.bm_offset;
1852 case DRBD_MD_INDEX_FLEX_EXT:
1853 default:
1854 return bdev->md.md_offset;
1855 }
1856}
1857
1858/**
1859 * drbd_md_last_sector() - Return the last sector number of the meta data area
1860 * @bdev: Meta data block device.
1861 */
1862static inline sector_t drbd_md_last_sector(struct drbd_backing_dev *bdev)
1863{
1864 switch (bdev->md.meta_dev_idx) {
1865 case DRBD_MD_INDEX_INTERNAL:
1866 case DRBD_MD_INDEX_FLEX_INT:
1867 return bdev->md.md_offset + MD_4kB_SECT -1;
1868 case DRBD_MD_INDEX_FLEX_EXT:
1869 default:
1870 return bdev->md.md_offset + bdev->md.md_size_sect -1;
1871 }
1872}
1873
1874/* Returns the number of 512 byte sectors of the device */
1875static inline sector_t drbd_get_capacity(struct block_device *bdev)
1876{
1877 /* return bdev ? get_capacity(bdev->bd_disk) : 0; */
1878 return bdev ? i_size_read(bdev->bd_inode) >> 9 : 0;
1879}
1880
1881/**
1882 * drbd_get_max_capacity() - Returns the capacity we announce to out peer
1883 * @bdev: Meta data block device.
1884 *
1885 * returns the capacity we announce to out peer. we clip ourselves at the
1886 * various MAX_SECTORS, because if we don't, current implementation will
1887 * oops sooner or later
1888 */
1889static inline sector_t drbd_get_max_capacity(struct drbd_backing_dev *bdev)
1890{
1891 sector_t s;
1892
1893 switch (bdev->md.meta_dev_idx) {
1894 case DRBD_MD_INDEX_INTERNAL:
1895 case DRBD_MD_INDEX_FLEX_INT:
1896 s = drbd_get_capacity(bdev->backing_bdev)
1897 ? min_t(sector_t, DRBD_MAX_SECTORS_FLEX,
1898 drbd_md_first_sector(bdev))
1899 : 0;
1900 break;
1901 case DRBD_MD_INDEX_FLEX_EXT:
1902 s = min_t(sector_t, DRBD_MAX_SECTORS_FLEX,
1903 drbd_get_capacity(bdev->backing_bdev));
1904 /* clip at maximum size the meta device can support */
1905 s = min_t(sector_t, s,
1906 BM_EXT_TO_SECT(bdev->md.md_size_sect
1907 - bdev->md.bm_offset));
1908 break;
1909 default:
1910 s = min_t(sector_t, DRBD_MAX_SECTORS,
1911 drbd_get_capacity(bdev->backing_bdev));
1912 }
1913 return s;
1914}
1915
1916/**
1917 * drbd_md_ss() - Return the sector number of our meta data super block
1918 * @bdev: Meta data block device.
1919 */
1920static inline sector_t drbd_md_ss(struct drbd_backing_dev *bdev)
1921{
1922 const int meta_dev_idx = bdev->md.meta_dev_idx;
1923
1924 if (meta_dev_idx == DRBD_MD_INDEX_FLEX_EXT)
1925 return 0;
1926
1927 /* Since drbd08, internal meta data is always "flexible".
1928 * position: last 4k aligned block of 4k size */
1929 if (meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
1930 meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)
1931 return (drbd_get_capacity(bdev->backing_bdev) & ~7ULL) - 8;
1932
1933 /* external, some index; this is the old fixed size layout */
1934 return MD_128MB_SECT * bdev->md.meta_dev_idx;
1935}
1936
1937static inline void
1938drbd_queue_work(struct drbd_work_queue *q, struct drbd_work *w)
1939{
1940 unsigned long flags;
1941 spin_lock_irqsave(&q->q_lock, flags);
1942 list_add_tail(&w->list, &q->q);
1943 spin_unlock_irqrestore(&q->q_lock, flags);
1944 wake_up(&q->q_wait);
1945}
1946
1947static inline void
1948drbd_queue_work_if_unqueued(struct drbd_work_queue *q, struct drbd_work *w)
1949{
1950 unsigned long flags;
1951 spin_lock_irqsave(&q->q_lock, flags);
1952 if (list_empty_careful(&w->list))
1953 list_add_tail(&w->list, &q->q);
1954 spin_unlock_irqrestore(&q->q_lock, flags);
1955 wake_up(&q->q_wait);
1956}
1957
1958static inline void
1959drbd_device_post_work(struct drbd_device *device, int work_bit)
1960{
1961 if (!test_and_set_bit(work_bit, &device->flags)) {
1962 struct drbd_connection *connection =
1963 first_peer_device(device)->connection;
1964 struct drbd_work_queue *q = &connection->sender_work;
1965 if (!test_and_set_bit(DEVICE_WORK_PENDING, &connection->flags))
1966 wake_up(&q->q_wait);
1967 }
1968}
1969
1970extern void drbd_flush_workqueue(struct drbd_work_queue *work_queue);
1971
1972/* To get the ack_receiver out of the blocking network stack,
1973 * so it can change its sk_rcvtimeo from idle- to ping-timeout,
1974 * and send a ping, we need to send a signal.
1975 * Which signal we send is irrelevant. */
1976static inline void wake_ack_receiver(struct drbd_connection *connection)
1977{
1978 struct task_struct *task = connection->ack_receiver.task;
1979 if (task && get_t_state(&connection->ack_receiver) == RUNNING)
1980 force_sig(SIGXCPU, task);
1981}
1982
1983static inline void request_ping(struct drbd_connection *connection)
1984{
1985 set_bit(SEND_PING, &connection->flags);
1986 wake_ack_receiver(connection);
1987}
1988
1989extern void *conn_prepare_command(struct drbd_connection *, struct drbd_socket *);
1990extern void *drbd_prepare_command(struct drbd_peer_device *, struct drbd_socket *);
1991extern int conn_send_command(struct drbd_connection *, struct drbd_socket *,
1992 enum drbd_packet, unsigned int, void *,
1993 unsigned int);
1994extern int drbd_send_command(struct drbd_peer_device *, struct drbd_socket *,
1995 enum drbd_packet, unsigned int, void *,
1996 unsigned int);
1997
1998extern int drbd_send_ping(struct drbd_connection *connection);
1999extern int drbd_send_ping_ack(struct drbd_connection *connection);
2000extern int drbd_send_state_req(struct drbd_peer_device *, union drbd_state, union drbd_state);
2001extern int conn_send_state_req(struct drbd_connection *, union drbd_state, union drbd_state);
2002
2003static inline void drbd_thread_stop(struct drbd_thread *thi)
2004{
2005 _drbd_thread_stop(thi, false, true);
2006}
2007
2008static inline void drbd_thread_stop_nowait(struct drbd_thread *thi)
2009{
2010 _drbd_thread_stop(thi, false, false);
2011}
2012
2013static inline void drbd_thread_restart_nowait(struct drbd_thread *thi)
2014{
2015 _drbd_thread_stop(thi, true, false);
2016}
2017
2018/* counts how many answer packets packets we expect from our peer,
2019 * for either explicit application requests,
2020 * or implicit barrier packets as necessary.
2021 * increased:
2022 * w_send_barrier
2023 * _req_mod(req, QUEUE_FOR_NET_WRITE or QUEUE_FOR_NET_READ);
2024 * it is much easier and equally valid to count what we queue for the
2025 * worker, even before it actually was queued or send.
2026 * (drbd_make_request_common; recovery path on read io-error)
2027 * decreased:
2028 * got_BarrierAck (respective tl_clear, tl_clear_barrier)
2029 * _req_mod(req, DATA_RECEIVED)
2030 * [from receive_DataReply]
2031 * _req_mod(req, WRITE_ACKED_BY_PEER or RECV_ACKED_BY_PEER or NEG_ACKED)
2032 * [from got_BlockAck (P_WRITE_ACK, P_RECV_ACK)]
2033 * for some reason it is NOT decreased in got_NegAck,
2034 * but in the resulting cleanup code from report_params.
2035 * we should try to remember the reason for that...
2036 * _req_mod(req, SEND_FAILED or SEND_CANCELED)
2037 * _req_mod(req, CONNECTION_LOST_WHILE_PENDING)
2038 * [from tl_clear_barrier]
2039 */
2040static inline void inc_ap_pending(struct drbd_device *device)
2041{
2042 atomic_inc(&device->ap_pending_cnt);
2043}
2044
2045#define ERR_IF_CNT_IS_NEGATIVE(which, func, line) \
2046 if (atomic_read(&device->which) < 0) \
2047 drbd_err(device, "in %s:%d: " #which " = %d < 0 !\n", \
2048 func, line, \
2049 atomic_read(&device->which))
2050
2051#define dec_ap_pending(device) _dec_ap_pending(device, __func__, __LINE__)
2052static inline void _dec_ap_pending(struct drbd_device *device, const char *func, int line)
2053{
2054 if (atomic_dec_and_test(&device->ap_pending_cnt))
2055 wake_up(&device->misc_wait);
2056 ERR_IF_CNT_IS_NEGATIVE(ap_pending_cnt, func, line);
2057}
2058
2059/* counts how many resync-related answers we still expect from the peer
2060 * increase decrease
2061 * C_SYNC_TARGET sends P_RS_DATA_REQUEST (and expects P_RS_DATA_REPLY)
2062 * C_SYNC_SOURCE sends P_RS_DATA_REPLY (and expects P_WRITE_ACK with ID_SYNCER)
2063 * (or P_NEG_ACK with ID_SYNCER)
2064 */
2065static inline void inc_rs_pending(struct drbd_device *device)
2066{
2067 atomic_inc(&device->rs_pending_cnt);
2068}
2069
2070#define dec_rs_pending(device) _dec_rs_pending(device, __func__, __LINE__)
2071static inline void _dec_rs_pending(struct drbd_device *device, const char *func, int line)
2072{
2073 atomic_dec(&device->rs_pending_cnt);
2074 ERR_IF_CNT_IS_NEGATIVE(rs_pending_cnt, func, line);
2075}
2076
2077/* counts how many answers we still need to send to the peer.
2078 * increased on
2079 * receive_Data unless protocol A;
2080 * we need to send a P_RECV_ACK (proto B)
2081 * or P_WRITE_ACK (proto C)
2082 * receive_RSDataReply (recv_resync_read) we need to send a P_WRITE_ACK
2083 * receive_DataRequest (receive_RSDataRequest) we need to send back P_DATA
2084 * receive_Barrier_* we need to send a P_BARRIER_ACK
2085 */
2086static inline void inc_unacked(struct drbd_device *device)
2087{
2088 atomic_inc(&device->unacked_cnt);
2089}
2090
2091#define dec_unacked(device) _dec_unacked(device, __func__, __LINE__)
2092static inline void _dec_unacked(struct drbd_device *device, const char *func, int line)
2093{
2094 atomic_dec(&device->unacked_cnt);
2095 ERR_IF_CNT_IS_NEGATIVE(unacked_cnt, func, line);
2096}
2097
2098#define sub_unacked(device, n) _sub_unacked(device, n, __func__, __LINE__)
2099static inline void _sub_unacked(struct drbd_device *device, int n, const char *func, int line)
2100{
2101 atomic_sub(n, &device->unacked_cnt);
2102 ERR_IF_CNT_IS_NEGATIVE(unacked_cnt, func, line);
2103}
2104
2105static inline bool is_sync_target_state(enum drbd_conns connection_state)
2106{
2107 return connection_state == C_SYNC_TARGET ||
2108 connection_state == C_PAUSED_SYNC_T;
2109}
2110
2111static inline bool is_sync_source_state(enum drbd_conns connection_state)
2112{
2113 return connection_state == C_SYNC_SOURCE ||
2114 connection_state == C_PAUSED_SYNC_S;
2115}
2116
2117static inline bool is_sync_state(enum drbd_conns connection_state)
2118{
2119 return is_sync_source_state(connection_state) ||
2120 is_sync_target_state(connection_state);
2121}
2122
2123/**
2124 * get_ldev() - Increase the ref count on device->ldev. Returns 0 if there is no ldev
2125 * @_device: DRBD device.
2126 * @_min_state: Minimum device state required for success.
2127 *
2128 * You have to call put_ldev() when finished working with device->ldev.
2129 */
2130#define get_ldev_if_state(_device, _min_state) \
2131 (_get_ldev_if_state((_device), (_min_state)) ? \
2132 ({ __acquire(x); true; }) : false)
2133#define get_ldev(_device) get_ldev_if_state(_device, D_INCONSISTENT)
2134
2135static inline void put_ldev(struct drbd_device *device)
2136{
2137 enum drbd_disk_state disk_state = device->state.disk;
2138 /* We must check the state *before* the atomic_dec becomes visible,
2139 * or we have a theoretical race where someone hitting zero,
2140 * while state still D_FAILED, will then see D_DISKLESS in the
2141 * condition below and calling into destroy, where he must not, yet. */
2142 int i = atomic_dec_return(&device->local_cnt);
2143
2144 /* This may be called from some endio handler,
2145 * so we must not sleep here. */
2146
2147 __release(local);
2148 D_ASSERT(device, i >= 0);
2149 if (i == 0) {
2150 if (disk_state == D_DISKLESS)
2151 /* even internal references gone, safe to destroy */
2152 drbd_device_post_work(device, DESTROY_DISK);
2153 if (disk_state == D_FAILED)
2154 /* all application IO references gone. */
2155 if (!test_and_set_bit(GOING_DISKLESS, &device->flags))
2156 drbd_device_post_work(device, GO_DISKLESS);
2157 wake_up(&device->misc_wait);
2158 }
2159}
2160
2161#ifndef __CHECKER__
2162static inline int _get_ldev_if_state(struct drbd_device *device, enum drbd_disk_state mins)
2163{
2164 int io_allowed;
2165
2166 /* never get a reference while D_DISKLESS */
2167 if (device->state.disk == D_DISKLESS)
2168 return 0;
2169
2170 atomic_inc(&device->local_cnt);
2171 io_allowed = (device->state.disk >= mins);
2172 if (!io_allowed)
2173 put_ldev(device);
2174 return io_allowed;
2175}
2176#else
2177extern int _get_ldev_if_state(struct drbd_device *device, enum drbd_disk_state mins);
2178#endif
2179
2180/* this throttles on-the-fly application requests
2181 * according to max_buffers settings;
2182 * maybe re-implement using semaphores? */
2183static inline int drbd_get_max_buffers(struct drbd_device *device)
2184{
2185 struct net_conf *nc;
2186 int mxb;
2187
2188 rcu_read_lock();
2189 nc = rcu_dereference(first_peer_device(device)->connection->net_conf);
2190 mxb = nc ? nc->max_buffers : 1000000; /* arbitrary limit on open requests */
2191 rcu_read_unlock();
2192
2193 return mxb;
2194}
2195
2196static inline int drbd_state_is_stable(struct drbd_device *device)
2197{
2198 union drbd_dev_state s = device->state;
2199
2200 /* DO NOT add a default clause, we want the compiler to warn us
2201 * for any newly introduced state we may have forgotten to add here */
2202
2203 switch ((enum drbd_conns)s.conn) {
2204 /* new io only accepted when there is no connection, ... */
2205 case C_STANDALONE:
2206 case C_WF_CONNECTION:
2207 /* ... or there is a well established connection. */
2208 case C_CONNECTED:
2209 case C_SYNC_SOURCE:
2210 case C_SYNC_TARGET:
2211 case C_VERIFY_S:
2212 case C_VERIFY_T:
2213 case C_PAUSED_SYNC_S:
2214 case C_PAUSED_SYNC_T:
2215 case C_AHEAD:
2216 case C_BEHIND:
2217 /* transitional states, IO allowed */
2218 case C_DISCONNECTING:
2219 case C_UNCONNECTED:
2220 case C_TIMEOUT:
2221 case C_BROKEN_PIPE:
2222 case C_NETWORK_FAILURE:
2223 case C_PROTOCOL_ERROR:
2224 case C_TEAR_DOWN:
2225 case C_WF_REPORT_PARAMS:
2226 case C_STARTING_SYNC_S:
2227 case C_STARTING_SYNC_T:
2228 break;
2229
2230 /* Allow IO in BM exchange states with new protocols */
2231 case C_WF_BITMAP_S:
2232 if (first_peer_device(device)->connection->agreed_pro_version < 96)
2233 return 0;
2234 break;
2235
2236 /* no new io accepted in these states */
2237 case C_WF_BITMAP_T:
2238 case C_WF_SYNC_UUID:
2239 case C_MASK:
2240 /* not "stable" */
2241 return 0;
2242 }
2243
2244 switch ((enum drbd_disk_state)s.disk) {
2245 case D_DISKLESS:
2246 case D_INCONSISTENT:
2247 case D_OUTDATED:
2248 case D_CONSISTENT:
2249 case D_UP_TO_DATE:
2250 case D_FAILED:
2251 /* disk state is stable as well. */
2252 break;
2253
2254 /* no new io accepted during transitional states */
2255 case D_ATTACHING:
2256 case D_NEGOTIATING:
2257 case D_UNKNOWN:
2258 case D_MASK:
2259 /* not "stable" */
2260 return 0;
2261 }
2262
2263 return 1;
2264}
2265
2266static inline int drbd_suspended(struct drbd_device *device)
2267{
2268 struct drbd_resource *resource = device->resource;
2269
2270 return resource->susp || resource->susp_fen || resource->susp_nod;
2271}
2272
2273static inline bool may_inc_ap_bio(struct drbd_device *device)
2274{
2275 int mxb = drbd_get_max_buffers(device);
2276
2277 if (drbd_suspended(device))
2278 return false;
2279 if (atomic_read(&device->suspend_cnt))
2280 return false;
2281
2282 /* to avoid potential deadlock or bitmap corruption,
2283 * in various places, we only allow new application io
2284 * to start during "stable" states. */
2285
2286 /* no new io accepted when attaching or detaching the disk */
2287 if (!drbd_state_is_stable(device))
2288 return false;
2289
2290 /* since some older kernels don't have atomic_add_unless,
2291 * and we are within the spinlock anyways, we have this workaround. */
2292 if (atomic_read(&device->ap_bio_cnt) > mxb)
2293 return false;
2294 if (test_bit(BITMAP_IO, &device->flags))
2295 return false;
2296 return true;
2297}
2298
2299static inline bool inc_ap_bio_cond(struct drbd_device *device)
2300{
2301 bool rv = false;
2302
2303 spin_lock_irq(&device->resource->req_lock);
2304 rv = may_inc_ap_bio(device);
2305 if (rv)
2306 atomic_inc(&device->ap_bio_cnt);
2307 spin_unlock_irq(&device->resource->req_lock);
2308
2309 return rv;
2310}
2311
2312static inline void inc_ap_bio(struct drbd_device *device)
2313{
2314 /* we wait here
2315 * as long as the device is suspended
2316 * until the bitmap is no longer on the fly during connection
2317 * handshake as long as we would exceed the max_buffer limit.
2318 *
2319 * to avoid races with the reconnect code,
2320 * we need to atomic_inc within the spinlock. */
2321
2322 wait_event(device->misc_wait, inc_ap_bio_cond(device));
2323}
2324
2325static inline void dec_ap_bio(struct drbd_device *device)
2326{
2327 int mxb = drbd_get_max_buffers(device);
2328 int ap_bio = atomic_dec_return(&device->ap_bio_cnt);
2329
2330 D_ASSERT(device, ap_bio >= 0);
2331
2332 if (ap_bio == 0 && test_bit(BITMAP_IO, &device->flags)) {
2333 if (!test_and_set_bit(BITMAP_IO_QUEUED, &device->flags))
2334 drbd_queue_work(&first_peer_device(device)->
2335 connection->sender_work,
2336 &device->bm_io_work.w);
2337 }
2338
2339 /* this currently does wake_up for every dec_ap_bio!
2340 * maybe rather introduce some type of hysteresis?
2341 * e.g. (ap_bio == mxb/2 || ap_bio == 0) ? */
2342 if (ap_bio < mxb)
2343 wake_up(&device->misc_wait);
2344}
2345
2346static inline bool verify_can_do_stop_sector(struct drbd_device *device)
2347{
2348 return first_peer_device(device)->connection->agreed_pro_version >= 97 &&
2349 first_peer_device(device)->connection->agreed_pro_version != 100;
2350}
2351
2352static inline int drbd_set_ed_uuid(struct drbd_device *device, u64 val)
2353{
2354 int changed = device->ed_uuid != val;
2355 device->ed_uuid = val;
2356 return changed;
2357}
2358
2359static inline int drbd_queue_order_type(struct drbd_device *device)
2360{
2361 /* sorry, we currently have no working implementation
2362 * of distributed TCQ stuff */
2363#ifndef QUEUE_ORDERED_NONE
2364#define QUEUE_ORDERED_NONE 0
2365#endif
2366 return QUEUE_ORDERED_NONE;
2367}
2368
2369static inline struct drbd_connection *first_connection(struct drbd_resource *resource)
2370{
2371 return list_first_entry_or_null(&resource->connections,
2372 struct drbd_connection, connections);
2373}
2374
2375#endif
2376