blob: 3abf982ec5593968366f350375ab587b009811e7 [file] [log] [blame]
Philipp Reisnerb411b362009-09-25 16:07:19 -07001/*
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 <linux/compiler.h>
30#include <linux/types.h>
31#include <linux/version.h>
32#include <linux/list.h>
33#include <linux/sched.h>
34#include <linux/bitops.h>
35#include <linux/slab.h>
36#include <linux/crypto.h>
Randy Dunlap132cc532009-10-07 19:26:00 +020037#include <linux/ratelimit.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070038#include <linux/tcp.h>
39#include <linux/mutex.h>
40#include <linux/major.h>
41#include <linux/blkdev.h>
42#include <linux/genhd.h>
Philipp Reisner062e8792011-02-08 11:09:18 +010043#include <linux/idr.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070044#include <net/tcp.h>
45#include <linux/lru_cache.h>
Paul Gortmaker70c71602011-05-22 16:47:17 -040046#include <linux/prefetch.h>
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +010047#include <linux/drbd_genl_api.h>
Philipp Reisnerb8907332011-01-27 14:07:51 +010048#include <linux/drbd.h>
49#include "drbd_state.h"
Philipp Reisnerb411b362009-09-25 16:07:19 -070050
51#ifdef __CHECKER__
52# define __protected_by(x) __attribute__((require_context(x,1,999,"rdwr")))
53# define __protected_read_by(x) __attribute__((require_context(x,1,999,"read")))
54# define __protected_write_by(x) __attribute__((require_context(x,1,999,"write")))
55# define __must_hold(x) __attribute__((context(x,1,1), require_context(x,1,999,"call")))
56#else
57# define __protected_by(x)
58# define __protected_read_by(x)
59# define __protected_write_by(x)
60# define __must_hold(x)
61#endif
62
63#define __no_warn(lock, stmt) do { __acquire(lock); stmt; __release(lock); } while (0)
64
65/* module parameter, defined in drbd_main.c */
66extern unsigned int minor_count;
67extern int disable_sendpage;
68extern int allow_oos;
Philipp Reisnerb411b362009-09-25 16:07:19 -070069
70#ifdef CONFIG_DRBD_FAULT_INJECTION
71extern int enable_faults;
72extern int fault_rate;
73extern int fault_devs;
74#endif
75
76extern char usermode_helper[];
77
78
Philipp Reisnerb411b362009-09-25 16:07:19 -070079/* I don't remember why XCPU ...
80 * This is used to wake the asender,
81 * and to interrupt sending the sending task
82 * on disconnect.
83 */
84#define DRBD_SIG SIGXCPU
85
86/* This is used to stop/restart our threads.
87 * Cannot use SIGTERM nor SIGKILL, since these
88 * are sent out by init on runlevel changes
89 * I choose SIGHUP for now.
90 */
91#define DRBD_SIGKILL SIGHUP
92
Philipp Reisnerb411b362009-09-25 16:07:19 -070093#define ID_IN_SYNC (4711ULL)
94#define ID_OUT_OF_SYNC (4712ULL)
Philipp Reisnerb411b362009-09-25 16:07:19 -070095#define ID_SYNCER (-1ULL)
Andreas Gruenbacher579b57e2011-01-13 18:40:57 +010096
Philipp Reisner4a23f262011-01-11 17:42:17 +010097#define UUID_NEW_BM_OFFSET ((u64)0x0001000000000000ULL)
Philipp Reisnerb411b362009-09-25 16:07:19 -070098
99struct drbd_conf;
Philipp Reisner21114382011-01-19 12:26:59 +0100100struct drbd_tconn;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700101
102
103/* to shorten dev_warn(DEV, "msg"); and relatives statements */
104#define DEV (disk_to_dev(mdev->vdisk))
105
Philipp Reisner60ae4962011-02-07 14:01:51 +0100106#define conn_printk(LEVEL, TCONN, FMT, ARGS...) \
107 printk(LEVEL "d-con %s: " FMT, TCONN->name , ## ARGS)
108#define conn_alert(TCONN, FMT, ARGS...) conn_printk(KERN_ALERT, TCONN, FMT, ## ARGS)
109#define conn_crit(TCONN, FMT, ARGS...) conn_printk(KERN_CRIT, TCONN, FMT, ## ARGS)
110#define conn_err(TCONN, FMT, ARGS...) conn_printk(KERN_ERR, TCONN, FMT, ## ARGS)
111#define conn_warn(TCONN, FMT, ARGS...) conn_printk(KERN_WARNING, TCONN, FMT, ## ARGS)
112#define conn_notice(TCONN, FMT, ARGS...) conn_printk(KERN_NOTICE, TCONN, FMT, ## ARGS)
113#define conn_info(TCONN, FMT, ARGS...) conn_printk(KERN_INFO, TCONN, FMT, ## ARGS)
114#define conn_dbg(TCONN, FMT, ARGS...) conn_printk(KERN_DEBUG, TCONN, FMT, ## ARGS)
115
Philipp Reisnerb411b362009-09-25 16:07:19 -0700116#define D_ASSERT(exp) if (!(exp)) \
117 dev_err(DEV, "ASSERT( " #exp " ) in %s:%d\n", __FILE__, __LINE__)
118
Andreas Gruenbacher841ce242010-12-15 19:31:20 +0100119/**
120 * expect - Make an assertion
121 *
122 * Unlike the assert macro, this macro returns a boolean result.
123 */
124#define expect(exp) ({ \
125 bool _bool = (exp); \
126 if (!_bool) \
127 dev_err(DEV, "ASSERTION %s FAILED in %s\n", \
128 #exp, __func__); \
129 _bool; \
130 })
Philipp Reisnerb411b362009-09-25 16:07:19 -0700131
132/* Defines to control fault insertion */
133enum {
134 DRBD_FAULT_MD_WR = 0, /* meta data write */
135 DRBD_FAULT_MD_RD = 1, /* read */
136 DRBD_FAULT_RS_WR = 2, /* resync */
137 DRBD_FAULT_RS_RD = 3,
138 DRBD_FAULT_DT_WR = 4, /* data */
139 DRBD_FAULT_DT_RD = 5,
140 DRBD_FAULT_DT_RA = 6, /* data read ahead */
141 DRBD_FAULT_BM_ALLOC = 7, /* bitmap allocation */
142 DRBD_FAULT_AL_EE = 8, /* alloc ee */
Philipp Reisner6b4388a2010-04-26 14:11:45 +0200143 DRBD_FAULT_RECEIVE = 9, /* Changes some bytes upon receiving a [rs]data block */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700144
145 DRBD_FAULT_MAX,
146};
147
Philipp Reisnerb411b362009-09-25 16:07:19 -0700148extern unsigned int
149_drbd_insert_fault(struct drbd_conf *mdev, unsigned int type);
Andreas Gruenbacher0cf9d272010-12-07 10:43:29 +0100150
Philipp Reisnerb411b362009-09-25 16:07:19 -0700151static inline int
152drbd_insert_fault(struct drbd_conf *mdev, unsigned int type) {
Andreas Gruenbacher0cf9d272010-12-07 10:43:29 +0100153#ifdef CONFIG_DRBD_FAULT_INJECTION
Philipp Reisnerb411b362009-09-25 16:07:19 -0700154 return fault_rate &&
155 (enable_faults & (1<<type)) &&
156 _drbd_insert_fault(mdev, type);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700157#else
Andreas Gruenbacher0cf9d272010-12-07 10:43:29 +0100158 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700159#endif
Andreas Gruenbacher0cf9d272010-12-07 10:43:29 +0100160}
Philipp Reisnerb411b362009-09-25 16:07:19 -0700161
162/* integer division, round _UP_ to the next integer */
163#define div_ceil(A, B) ((A)/(B) + ((A)%(B) ? 1 : 0))
164/* usual integer division */
165#define div_floor(A, B) ((A)/(B))
166
167/* drbd_meta-data.c (still in drbd_main.c) */
168/* 4th incarnation of the disk layout. */
169#define DRBD_MD_MAGIC (DRBD_MAGIC+4)
170
Philipp Reisnerb411b362009-09-25 16:07:19 -0700171extern struct ratelimit_state drbd_ratelimit_state;
Philipp Reisner81a5d602011-02-22 19:53:16 -0500172extern struct idr minors;
Philipp Reisner80883192011-02-18 14:56:45 +0100173extern struct list_head drbd_tconns;
Philipp Reisneref356262011-04-13 14:21:29 -0700174extern struct rw_semaphore drbd_cfg_rwsem;
Philipp Reisnerd3fcb492011-04-13 14:46:05 -0700175/* drbd_cfg_rwsem protects: drbd_tconns list, minors idr, tconn->volumes idr
Philipp Reisneref356262011-04-13 14:21:29 -0700176 note: non sleeping iterations over the idrs are protoected by RCU */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700177
178/* on the wire */
Andreas Gruenbacherd8763022011-01-26 17:39:41 +0100179enum drbd_packet {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700180 /* receiver (data socket) */
181 P_DATA = 0x00,
182 P_DATA_REPLY = 0x01, /* Response to P_DATA_REQUEST */
183 P_RS_DATA_REPLY = 0x02, /* Response to P_RS_DATA_REQUEST */
184 P_BARRIER = 0x03,
185 P_BITMAP = 0x04,
186 P_BECOME_SYNC_TARGET = 0x05,
187 P_BECOME_SYNC_SOURCE = 0x06,
188 P_UNPLUG_REMOTE = 0x07, /* Used at various times to hint the peer */
189 P_DATA_REQUEST = 0x08, /* Used to ask for a data block */
190 P_RS_DATA_REQUEST = 0x09, /* Used to ask for a data block for resync */
191 P_SYNC_PARAM = 0x0a,
192 P_PROTOCOL = 0x0b,
193 P_UUIDS = 0x0c,
194 P_SIZES = 0x0d,
195 P_STATE = 0x0e,
196 P_SYNC_UUID = 0x0f,
197 P_AUTH_CHALLENGE = 0x10,
198 P_AUTH_RESPONSE = 0x11,
199 P_STATE_CHG_REQ = 0x12,
200
201 /* asender (meta socket */
202 P_PING = 0x13,
203 P_PING_ACK = 0x14,
204 P_RECV_ACK = 0x15, /* Used in protocol B */
205 P_WRITE_ACK = 0x16, /* Used in protocol C */
206 P_RS_WRITE_ACK = 0x17, /* Is a P_WRITE_ACK, additionally call set_in_sync(). */
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +0100207 P_DISCARD_WRITE = 0x18, /* Used in proto C, two-primaries conflict detection */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700208 P_NEG_ACK = 0x19, /* Sent if local disk is unusable */
209 P_NEG_DREPLY = 0x1a, /* Local disk is broken... */
210 P_NEG_RS_DREPLY = 0x1b, /* Local disk is broken... */
211 P_BARRIER_ACK = 0x1c,
212 P_STATE_CHG_REPLY = 0x1d,
213
214 /* "new" commands, no longer fitting into the ordering scheme above */
215
216 P_OV_REQUEST = 0x1e, /* data socket */
217 P_OV_REPLY = 0x1f,
218 P_OV_RESULT = 0x20, /* meta socket */
219 P_CSUM_RS_REQUEST = 0x21, /* data socket */
220 P_RS_IS_IN_SYNC = 0x22, /* meta socket */
221 P_SYNC_PARAM89 = 0x23, /* data socket, protocol version 89 replacement for P_SYNC_PARAM */
222 P_COMPRESSED_BITMAP = 0x24, /* compressed or otherwise encoded bitmap transfer */
Philipp Reisner0ced55a2010-04-30 15:26:20 +0200223 /* P_CKPT_FENCE_REQ = 0x25, * currently reserved for protocol D */
224 /* P_CKPT_DISABLE_REQ = 0x26, * currently reserved for protocol D */
225 P_DELAY_PROBE = 0x27, /* is used on BOTH sockets */
Philipp Reisner73a01a12010-10-27 14:33:00 +0200226 P_OUT_OF_SYNC = 0x28, /* Mark as out of sync (Outrunning), data socket */
Philipp Reisnerd612d302010-12-27 10:53:28 +0100227 P_RS_CANCEL = 0x29, /* meta: Used to cancel RS_DATA_REQUEST packet by SyncSource */
Philipp Reisnercf29c9d2011-02-11 15:11:24 +0100228 P_CONN_ST_CHG_REQ = 0x2a, /* data sock: Connection wide state request */
229 P_CONN_ST_CHG_REPLY = 0x2b, /* meta sock: Connection side state req reply */
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +0100230 P_RETRY_WRITE = 0x2c, /* Protocol C: retry conflicting write request */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700231
Philipp Reisnerb411b362009-09-25 16:07:19 -0700232 P_MAY_IGNORE = 0x100, /* Flag to test if (cmd > P_MAY_IGNORE) ... */
233 P_MAX_OPT_CMD = 0x101,
234
235 /* special command ids for handshake */
236
Andreas Gruenbachere5d6f332011-03-28 16:44:40 +0200237 P_INITIAL_META = 0xfff1, /* First Packet on the MetaSock */
238 P_INITIAL_DATA = 0xfff2, /* First Packet on the Socket */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700239
Andreas Gruenbacher60381782011-03-28 17:05:50 +0200240 P_CONNECTION_FEATURES = 0xfffe /* FIXED for the next century! */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700241};
242
Andreas Gruenbacherd8763022011-01-26 17:39:41 +0100243extern const char *cmdname(enum drbd_packet cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700244
245/* for sending/receiving the bitmap,
246 * possibly in some encoding scheme */
247struct bm_xfer_ctx {
248 /* "const"
249 * stores total bits and long words
250 * of the bitmap, so we don't need to
251 * call the accessor functions over and again. */
252 unsigned long bm_bits;
253 unsigned long bm_words;
254 /* during xfer, current position within the bitmap */
255 unsigned long bit_offset;
256 unsigned long word_offset;
257
258 /* statistics; index: (h->command == P_BITMAP) */
259 unsigned packets[2];
260 unsigned bytes[2];
261};
262
263extern void INFO_bm_xfer_stats(struct drbd_conf *mdev,
264 const char *direction, struct bm_xfer_ctx *c);
265
266static inline void bm_xfer_ctx_bit_to_word_offset(struct bm_xfer_ctx *c)
267{
268 /* word_offset counts "native long words" (32 or 64 bit),
269 * aligned at 64 bit.
270 * Encoded packet may end at an unaligned bit offset.
271 * In case a fallback clear text packet is transmitted in
272 * between, we adjust this offset back to the last 64bit
273 * aligned "native long word", which makes coding and decoding
274 * the plain text bitmap much more convenient. */
275#if BITS_PER_LONG == 64
276 c->word_offset = c->bit_offset >> 6;
277#elif BITS_PER_LONG == 32
278 c->word_offset = c->bit_offset >> 5;
279 c->word_offset &= ~(1UL);
280#else
281# error "unsupported BITS_PER_LONG"
282#endif
283}
284
285#ifndef __packed
286#define __packed __attribute__((packed))
287#endif
288
289/* This is the layout for a packet on the wire.
290 * The byteorder is the network byte order.
291 * (except block_id and barrier fields.
292 * these are pointers to local structs
293 * and have no relevance for the partner,
294 * which just echoes them as received.)
295 *
296 * NOTE that the payload starts at a long aligned offset,
297 * regardless of 32 or 64 bit arch!
298 */
Philipp Reisner0b70a132010-08-20 13:36:10 +0200299struct p_header80 {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700300 u32 magic;
301 u16 command;
302 u16 length; /* bytes of data after this header */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700303} __packed;
Philipp Reisner0b70a132010-08-20 13:36:10 +0200304
305/* Header for big packets, Used for data packets exceeding 64kB */
306struct p_header95 {
307 u16 magic; /* use DRBD_MAGIC_BIG here */
308 u16 command;
Andreas Gruenbacherb55d84b2011-03-22 13:17:47 +0100309 u32 length;
Philipp Reisner0b70a132010-08-20 13:36:10 +0200310} __packed;
311
Andreas Gruenbacher0c8e36d2011-03-30 16:00:17 +0200312struct p_header100 {
313 u32 magic;
314 u16 volume;
315 u16 command;
316 u32 length;
317 u32 pad;
318} __packed;
319
Andreas Gruenbacher52b061a2011-03-30 11:38:49 +0200320extern unsigned int drbd_header_size(struct drbd_tconn *tconn);
321
Philipp Reisnerb411b362009-09-25 16:07:19 -0700322/* these defines must not be changed without changing the protocol version */
Philipp Reisner76d2e7e2010-08-25 11:58:05 +0200323#define DP_HARDBARRIER 1 /* depricated */
324#define DP_RW_SYNC 2 /* equals REQ_SYNC */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700325#define DP_MAY_SET_IN_SYNC 4
Jens Axboe721a9602011-03-09 11:56:30 +0100326#define DP_UNPLUG 8 /* not used anymore */
Philipp Reisner76d2e7e2010-08-25 11:58:05 +0200327#define DP_FUA 16 /* equals REQ_FUA */
328#define DP_FLUSH 32 /* equals REQ_FLUSH */
329#define DP_DISCARD 64 /* equals REQ_DISCARD */
Philipp Reisner303d1442011-04-13 16:24:47 -0700330#define DP_SEND_RECEIVE_ACK 128 /* This is a proto B write request */
331#define DP_SEND_WRITE_ACK 256 /* This is a proto C write request */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700332
333struct p_data {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700334 u64 sector; /* 64 bits sector number */
335 u64 block_id; /* to identify the request in protocol B&C */
336 u32 seq_num;
337 u32 dp_flags;
338} __packed;
339
340/*
341 * commands which share a struct:
342 * p_block_ack:
343 * P_RECV_ACK (proto B), P_WRITE_ACK (proto C),
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +0100344 * P_DISCARD_WRITE (proto C, two-primaries conflict detection)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700345 * p_block_req:
346 * P_DATA_REQUEST, P_RS_DATA_REQUEST
347 */
348struct p_block_ack {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700349 u64 sector;
350 u64 block_id;
351 u32 blksize;
352 u32 seq_num;
353} __packed;
354
Philipp Reisnerb411b362009-09-25 16:07:19 -0700355struct p_block_req {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700356 u64 sector;
357 u64 block_id;
358 u32 blksize;
359 u32 pad; /* to multiple of 8 Byte */
360} __packed;
361
362/*
363 * commands with their own struct for additional fields:
Andreas Gruenbacher60381782011-03-28 17:05:50 +0200364 * P_CONNECTION_FEATURES
Philipp Reisnerb411b362009-09-25 16:07:19 -0700365 * P_BARRIER
366 * P_BARRIER_ACK
367 * P_SYNC_PARAM
368 * ReportParams
369 */
370
Andreas Gruenbacher60381782011-03-28 17:05:50 +0200371struct p_connection_features {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700372 u32 protocol_min;
373 u32 feature_flags;
374 u32 protocol_max;
375
376 /* should be more than enough for future enhancements
377 * for now, feature_flags and the reserverd array shall be zero.
378 */
379
380 u32 _pad;
381 u64 reserverd[7];
382} __packed;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700383
384struct p_barrier {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700385 u32 barrier; /* barrier number _handle_ only */
386 u32 pad; /* to multiple of 8 Byte */
387} __packed;
388
389struct p_barrier_ack {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700390 u32 barrier;
391 u32 set_size;
392} __packed;
393
394struct p_rs_param {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700395 u32 rate;
396
397 /* Since protocol version 88 and higher. */
398 char verify_alg[0];
399} __packed;
400
401struct p_rs_param_89 {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700402 u32 rate;
403 /* protocol version 89: */
404 char verify_alg[SHARED_SECRET_MAX];
405 char csums_alg[SHARED_SECRET_MAX];
406} __packed;
407
Philipp Reisner8e26f9c2010-07-06 17:25:54 +0200408struct p_rs_param_95 {
Philipp Reisner8e26f9c2010-07-06 17:25:54 +0200409 u32 rate;
410 char verify_alg[SHARED_SECRET_MAX];
411 char csums_alg[SHARED_SECRET_MAX];
412 u32 c_plan_ahead;
413 u32 c_delay_target;
414 u32 c_fill_target;
415 u32 c_max_rate;
416} __packed;
417
Philipp Reisnercf14c2e2010-02-02 21:03:50 +0100418enum drbd_conn_flags {
419 CF_WANT_LOSE = 1,
420 CF_DRY_RUN = 2,
421};
422
Philipp Reisnerb411b362009-09-25 16:07:19 -0700423struct p_protocol {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700424 u32 protocol;
425 u32 after_sb_0p;
426 u32 after_sb_1p;
427 u32 after_sb_2p;
Philipp Reisnercf14c2e2010-02-02 21:03:50 +0100428 u32 conn_flags;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700429 u32 two_primaries;
430
431 /* Since protocol version 87 and higher. */
432 char integrity_alg[0];
433
434} __packed;
435
436struct p_uuids {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700437 u64 uuid[UI_EXTENDED_SIZE];
438} __packed;
439
440struct p_rs_uuid {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700441 u64 uuid;
442} __packed;
443
444struct p_sizes {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700445 u64 d_size; /* size of disk */
446 u64 u_size; /* user requested size */
447 u64 c_size; /* current exported size */
Lars Ellenberg1816a2b2010-11-11 15:19:07 +0100448 u32 max_bio_size; /* Maximal size of a BIO */
Philipp Reisnere89b5912010-03-24 17:11:33 +0100449 u16 queue_order_type; /* not yet implemented in DRBD*/
450 u16 dds_flags; /* use enum dds_flags here. */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700451} __packed;
452
453struct p_state {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700454 u32 state;
455} __packed;
456
457struct p_req_state {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700458 u32 mask;
459 u32 val;
460} __packed;
461
462struct p_req_state_reply {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700463 u32 retcode;
464} __packed;
465
466struct p_drbd06_param {
467 u64 size;
468 u32 state;
469 u32 blksize;
470 u32 protocol;
471 u32 version;
472 u32 gen_cnt[5];
473 u32 bit_map_gen[5];
474} __packed;
475
476struct p_discard {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700477 u64 block_id;
478 u32 seq_num;
479 u32 pad;
480} __packed;
481
Philipp Reisner73a01a12010-10-27 14:33:00 +0200482struct p_block_desc {
Philipp Reisner73a01a12010-10-27 14:33:00 +0200483 u64 sector;
484 u32 blksize;
485 u32 pad; /* to multiple of 8 Byte */
486} __packed;
487
Philipp Reisnerb411b362009-09-25 16:07:19 -0700488/* Valid values for the encoding field.
489 * Bump proto version when changing this. */
490enum drbd_bitmap_code {
491 /* RLE_VLI_Bytes = 0,
492 * and other bit variants had been defined during
493 * algorithm evaluation. */
494 RLE_VLI_Bits = 2,
495};
496
497struct p_compressed_bm {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700498 /* (encoding & 0x0f): actual encoding, see enum drbd_bitmap_code
499 * (encoding & 0x80): polarity (set/unset) of first runlength
500 * ((encoding >> 4) & 0x07): pad_bits, number of trailing zero bits
501 * used to pad up to head.length bytes
502 */
503 u8 encoding;
504
505 u8 code[0];
506} __packed;
507
Philipp Reisner0b70a132010-08-20 13:36:10 +0200508struct p_delay_probe93 {
Philipp Reisner0b70a132010-08-20 13:36:10 +0200509 u32 seq_num; /* sequence number to match the two probe packets */
510 u32 offset; /* usecs the probe got sent after the reference time point */
Philipp Reisner0ced55a2010-04-30 15:26:20 +0200511} __packed;
512
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +0200513/*
514 * Bitmap packets need to fit within a single page on the sender and receiver,
515 * so we are limited to 4 KiB (and not to PAGE_SIZE, which can be bigger).
Philipp Reisnerb411b362009-09-25 16:07:19 -0700516 */
Andreas Gruenbachere6ef8a52011-03-24 18:07:54 +0100517#define DRBD_SOCKET_BUFFER_SIZE 4096
518
Philipp Reisnerb411b362009-09-25 16:07:19 -0700519/**********************************************************************/
520enum drbd_thread_state {
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100521 NONE,
522 RUNNING,
523 EXITING,
524 RESTARTING
Philipp Reisnerb411b362009-09-25 16:07:19 -0700525};
526
527struct drbd_thread {
528 spinlock_t t_lock;
529 struct task_struct *task;
530 struct completion stop;
531 enum drbd_thread_state t_state;
532 int (*function) (struct drbd_thread *);
Philipp Reisner392c8802011-02-09 10:33:31 +0100533 struct drbd_tconn *tconn;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700534 int reset_cpu_mask;
Philipp Reisnerbed879a2011-02-04 14:00:37 +0100535 char name[9];
Philipp Reisnerb411b362009-09-25 16:07:19 -0700536};
537
538static inline enum drbd_thread_state get_t_state(struct drbd_thread *thi)
539{
540 /* THINK testing the t_state seems to be uncritical in all cases
541 * (but thread_{start,stop}), so we can read it *without* the lock.
542 * --lge */
543
544 smp_rmb();
545 return thi->t_state;
546}
547
Philipp Reisnerb411b362009-09-25 16:07:19 -0700548struct drbd_work {
549 struct list_head list;
Andreas Gruenbacher309a8342010-12-21 12:38:39 +0100550 int (*cb)(struct drbd_work *, int cancel);
Philipp Reisner00d56942011-02-09 18:09:48 +0100551 union {
552 struct drbd_conf *mdev;
553 struct drbd_tconn *tconn;
554 };
Philipp Reisnerb411b362009-09-25 16:07:19 -0700555};
556
Andreas Gruenbacherace652a2011-01-03 17:09:58 +0100557#include "drbd_interval.h"
558
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +0100559extern int drbd_wait_misc(struct drbd_conf *, struct drbd_interval *);
560
Philipp Reisnerb411b362009-09-25 16:07:19 -0700561struct drbd_request {
562 struct drbd_work w;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700563
564 /* if local IO is not allowed, will be NULL.
565 * if local IO _is_ allowed, holds the locally submitted bio clone,
566 * or, after local IO completion, the ERR_PTR(error).
Andreas Gruenbacherfcefa622011-02-17 16:46:59 +0100567 * see drbd_request_endio(). */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700568 struct bio *private_bio;
569
Andreas Gruenbacherace652a2011-01-03 17:09:58 +0100570 struct drbd_interval i;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700571 unsigned int epoch; /* barrier_nr */
572
573 /* barrier_nr: used to check on "completion" whether this req was in
574 * the current epoch, and we therefore have to close it,
575 * starting a new epoch...
576 */
577
Philipp Reisnerb411b362009-09-25 16:07:19 -0700578 struct list_head tl_requests; /* ring list in the transfer log */
579 struct bio *master_bio; /* master bio pointer */
580 unsigned long rq_state; /* see comments above _req_mod() */
581 int seq_num;
582 unsigned long start_time;
583};
584
585struct drbd_tl_epoch {
586 struct drbd_work w;
587 struct list_head requests; /* requests before */
588 struct drbd_tl_epoch *next; /* pointer to the next barrier */
589 unsigned int br_number; /* the barriers identifier. */
Philipp Reisner7e602c02010-05-27 14:49:27 +0200590 int n_writes; /* number of requests attached before this barrier */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700591};
592
Philipp Reisnerb411b362009-09-25 16:07:19 -0700593struct drbd_epoch {
594 struct list_head list;
595 unsigned int barrier_nr;
596 atomic_t epoch_size; /* increased on every request added. */
597 atomic_t active; /* increased on every req. added, and dec on every finished. */
598 unsigned long flags;
599};
600
601/* drbd_epoch flag bits */
602enum {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700603 DE_HAVE_BARRIER_NUMBER,
Philipp Reisnerb411b362009-09-25 16:07:19 -0700604};
605
606enum epoch_event {
607 EV_PUT,
608 EV_GOT_BARRIER_NR,
Philipp Reisnerb411b362009-09-25 16:07:19 -0700609 EV_BECAME_LAST,
Philipp Reisnerb411b362009-09-25 16:07:19 -0700610 EV_CLEANUP = 32, /* used as flag */
611};
612
Philipp Reisnerb411b362009-09-25 16:07:19 -0700613struct drbd_wq_barrier {
614 struct drbd_work w;
615 struct completion done;
616};
617
618struct digest_info {
619 int digest_size;
620 void *digest;
621};
622
Andreas Gruenbacherf6ffca92011-02-04 15:30:34 +0100623struct drbd_peer_request {
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200624 struct drbd_work w;
Philipp Reisner85719572010-07-21 10:20:17 +0200625 struct drbd_epoch *epoch; /* for writes */
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200626 struct page *pages;
627 atomic_t pending_bios;
Andreas Gruenbacher010f6e62011-01-14 20:59:35 +0100628 struct drbd_interval i;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200629 /* see comments on ee flag bits below */
630 unsigned long flags;
Philipp Reisner85719572010-07-21 10:20:17 +0200631 union {
632 u64 block_id;
633 struct digest_info *digest;
634 };
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200635};
636
637/* ee flag bits.
638 * While corresponding bios are in flight, the only modification will be
639 * set_bit WAS_ERROR, which has to be atomic.
640 * If no bios are in flight yet, or all have been completed,
641 * non-atomic modification to ee->flags is ok.
642 */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700643enum {
644 __EE_CALL_AL_COMPLETE_IO,
Philipp Reisnerb411b362009-09-25 16:07:19 -0700645 __EE_MAY_SET_IN_SYNC,
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200646
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200647 /* In case a barrier failed,
648 * we need to resubmit without the barrier flag. */
649 __EE_RESUBMITTED,
650
Andreas Gruenbacher6c852be2011-02-04 15:38:52 +0100651 /* we may have several bios per peer request.
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200652 * if any of those fail, we set this flag atomically
653 * from the endio callback */
654 __EE_WAS_ERROR,
Lars Ellenbergc36c3ce2010-08-11 20:42:55 +0200655
656 /* This ee has a pointer to a digest instead of a block id */
657 __EE_HAS_DIGEST,
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +0100658
659 /* Conflicting local requests need to be restarted after this request */
660 __EE_RESTART_REQUESTS,
Philipp Reisner303d1442011-04-13 16:24:47 -0700661
662 /* The peer wants a write ACK for this (wire proto C) */
663 __EE_SEND_WRITE_ACK,
Philipp Reisner302bdea2011-04-21 11:36:49 +0200664
665 /* Is set when net_conf had two_primaries set while creating this peer_req */
666 __EE_IN_INTERVAL_TREE,
Philipp Reisnerb411b362009-09-25 16:07:19 -0700667};
668#define EE_CALL_AL_COMPLETE_IO (1<<__EE_CALL_AL_COMPLETE_IO)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700669#define EE_MAY_SET_IN_SYNC (1<<__EE_MAY_SET_IN_SYNC)
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200670#define EE_RESUBMITTED (1<<__EE_RESUBMITTED)
671#define EE_WAS_ERROR (1<<__EE_WAS_ERROR)
Lars Ellenbergc36c3ce2010-08-11 20:42:55 +0200672#define EE_HAS_DIGEST (1<<__EE_HAS_DIGEST)
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +0100673#define EE_RESTART_REQUESTS (1<<__EE_RESTART_REQUESTS)
Philipp Reisner303d1442011-04-13 16:24:47 -0700674#define EE_SEND_WRITE_ACK (1<<__EE_SEND_WRITE_ACK)
Philipp Reisner302bdea2011-04-21 11:36:49 +0200675#define EE_IN_INTERVAL_TREE (1<<__EE_IN_INTERVAL_TREE)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700676
Philipp Reisner01a311a2011-02-07 14:30:33 +0100677/* flag bits per mdev */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700678enum {
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300679 CREATE_BARRIER, /* next P_DATA is preceded by a P_BARRIER */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700680 UNPLUG_QUEUED, /* only relevant with kernel 2.4 */
681 UNPLUG_REMOTE, /* sending a "UnplugRemote" could help */
682 MD_DIRTY, /* current uuids and flags not yet on disk */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700683 USE_DEGR_WFC_T, /* degr-wfc-timeout instead of wfc-timeout. */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700684 CL_ST_CHG_SUCCESS,
685 CL_ST_CHG_FAIL,
686 CRASHED_PRIMARY, /* This node was a crashed primary.
687 * Gets cleared when the state.conn
688 * goes into C_CONNECTED state. */
Lars Ellenberg19f843a2010-12-15 08:59:11 +0100689 NO_BARRIER_SUPP, /* underlying block device doesn't implement barriers */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700690 CONSIDER_RESYNC,
691
Philipp Reisnera8a4e512010-08-25 10:21:04 +0200692 MD_NO_FUA, /* Users wants us to not use FUA/FLUSH on meta data dev */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700693 SUSPEND_IO, /* suspend application io */
694 BITMAP_IO, /* suspend application io;
695 once no more io in flight, start bitmap io */
696 BITMAP_IO_QUEUED, /* Started bitmap IO */
Lars Ellenberg82f59cc2010-10-16 12:13:47 +0200697 GO_DISKLESS, /* Disk is being detached, on io-error or admin request. */
698 WAS_IO_ERROR, /* Local disk failed returned IO error */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700699 RESYNC_AFTER_NEG, /* Resync after online grow after the attach&negotiate finished. */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700700 RESIZE_PENDING, /* Size change detected locally, waiting for the response from
701 * the peer, if it changed there as well. */
Philipp Reisner43a51822010-06-11 11:26:34 +0200702 NEW_CUR_UUID, /* Create new current UUID when thawing IO */
Philipp Reisner07782862010-08-31 12:00:50 +0200703 AL_SUSPENDED, /* Activity logging is currently suspended. */
Philipp Reisner370a43e2011-01-14 16:03:11 +0100704 AHEAD_TO_SYNC_SOURCE, /* Ahead -> SyncSource queued */
Philipp Reisnere64a3292011-02-05 17:34:11 +0100705 B_RS_H_DONE, /* Before resync handler done (already executed) */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700706};
707
708struct drbd_bitmap; /* opaque for drbd_conf */
709
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +0100710/* definition of bits in bm_flags to be used in drbd_bm_lock
711 * and drbd_bitmap_io and friends. */
712enum bm_flag {
713 /* do we need to kfree, or vfree bm_pages? */
714 BM_P_VMALLOCED = 0x10000, /* internal use only, will be masked out */
715
716 /* currently locked for bulk operation */
717 BM_LOCKED_MASK = 0x7,
718
719 /* in detail, that is: */
720 BM_DONT_CLEAR = 0x1,
721 BM_DONT_SET = 0x2,
722 BM_DONT_TEST = 0x4,
723
724 /* (test bit, count bit) allowed (common case) */
725 BM_LOCKED_TEST_ALLOWED = 0x3,
726
727 /* testing bits, as well as setting new bits allowed, but clearing bits
728 * would be unexpected. Used during bitmap receive. Setting new bits
729 * requires sending of "out-of-sync" information, though. */
730 BM_LOCKED_SET_ALLOWED = 0x1,
731
732 /* clear is not expected while bitmap is locked for bulk operation */
733};
734
735
Philipp Reisnerb411b362009-09-25 16:07:19 -0700736/* TODO sort members for performance
737 * MAYBE group them further */
738
739/* THINK maybe we actually want to use the default "event/%s" worker threads
740 * or similar in linux 2.6, which uses per cpu data and threads.
Philipp Reisnerb411b362009-09-25 16:07:19 -0700741 */
742struct drbd_work_queue {
743 struct list_head q;
744 struct semaphore s; /* producers up it, worker down()s it */
745 spinlock_t q_lock; /* to protect the list. */
746};
747
748struct drbd_socket {
749 struct drbd_work_queue work;
750 struct mutex mutex;
751 struct socket *socket;
752 /* this way we get our
753 * send/receive buffers off the stack */
Andreas Gruenbacher5a87d922011-03-24 21:17:52 +0100754 void *sbuf;
Andreas Gruenbachere6ef8a52011-03-24 18:07:54 +0100755 void *rbuf;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700756};
757
758struct drbd_md {
759 u64 md_offset; /* sector offset to 'super' block */
760
761 u64 la_size_sect; /* last agreed size, unit sectors */
762 u64 uuid[UI_SIZE];
763 u64 device_uuid;
764 u32 flags;
765 u32 md_size_sect;
766
767 s32 al_offset; /* signed relative sector offset to al area */
768 s32 bm_offset; /* signed relative sector offset to bitmap */
769
770 /* u32 al_nr_extents; important for restoring the AL
Lars Ellenbergf3990022011-03-23 14:31:09 +0100771 * is stored into ldev->dc.al_extents, which in turn
Philipp Reisnerb411b362009-09-25 16:07:19 -0700772 * gets applied to act_log->nr_elements
773 */
774};
775
Philipp Reisnerb411b362009-09-25 16:07:19 -0700776struct drbd_backing_dev {
777 struct block_device *backing_bdev;
778 struct block_device *md_bdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700779 struct drbd_md md;
780 struct disk_conf dc; /* The user provided config... */
781 sector_t known_size; /* last known size of that backing device */
782};
783
784struct drbd_md_io {
785 struct drbd_conf *mdev;
786 struct completion event;
787 int error;
788};
789
790struct bm_io_work {
791 struct drbd_work w;
792 char *why;
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +0100793 enum bm_flag flags;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700794 int (*io_fn)(struct drbd_conf *mdev);
795 void (*done)(struct drbd_conf *mdev, int rv);
796};
797
798enum write_ordering_e {
799 WO_none,
800 WO_drain_io,
801 WO_bdev_flush,
Philipp Reisnerb411b362009-09-25 16:07:19 -0700802};
803
Philipp Reisner778f2712010-07-06 11:14:00 +0200804struct fifo_buffer {
805 int *values;
806 unsigned int head_index;
807 unsigned int size;
808};
809
Philipp Reisner01a311a2011-02-07 14:30:33 +0100810/* flag bits per tconn */
811enum {
812 NET_CONGESTED, /* The data socket is congested */
Philipp Reisner25703f82011-02-07 14:35:25 +0100813 DISCARD_CONCURRENT, /* Set on one node, cleared on the peer! */
Philipp Reisnere43ef192011-02-07 14:40:40 +0100814 SEND_PING, /* whether asender should send a ping asap */
Philipp Reisner808e37b2011-02-07 14:44:14 +0100815 SIGNAL_ASENDER, /* whether asender wants to be interrupted */
Philipp Reisner2a67d8b2011-02-09 14:10:32 +0100816 GOT_PING_ACK, /* set when we receive a ping_ack packet, ping_wait gets woken */
Philipp Reisnerfc3b10a2011-02-15 11:07:59 +0100817 CONN_WD_ST_CHG_OKAY,
818 CONN_WD_ST_CHG_FAIL,
Philipp Reisner0e29d162011-02-18 14:23:11 +0100819 CONFIG_PENDING, /* serialization of (re)configuration requests.
820 * if set, also prevents the device from dying */
821 OBJECT_DYING, /* device became unconfigured,
822 * but worker thread is still handling the cleanup.
823 * reconfiguring (nl_disk_conf, nl_net_conf) is dissalowed,
824 * while this is set. */
Philipp Reisner8169e412011-03-15 18:40:27 +0100825 CONN_DRY_RUN, /* Expect disconnect after resync handshake. */
Philipp Reisner01a311a2011-02-07 14:30:33 +0100826};
827
Philipp Reisner21114382011-01-19 12:26:59 +0100828struct drbd_tconn { /* is a resource from the config file */
829 char *name; /* Resource name */
Lars Ellenberg543cc102011-03-10 22:18:18 +0100830 struct list_head all_tconn; /* linked on global drbd_tconns */
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +0200831 struct kref kref;
Philipp Reisner8410da8f02011-02-11 20:11:10 +0100832 struct idr volumes; /* <tconn, vnr> to mdev mapping */
833 enum drbd_conns cstate; /* Only C_STANDALONE to C_WF_REPORT_PARAMS */
Philipp Reisner8e0af252011-03-28 16:18:39 +0200834 unsigned susp:1; /* IO suspended by user */
835 unsigned susp_nod:1; /* IO suspended because no data */
836 unsigned susp_fen:1; /* IO suspended because fence peer handler runs */
Philipp Reisner8410da8f02011-02-11 20:11:10 +0100837 struct mutex cstate_mutex; /* Protects graceful disconnects */
Philipp Reisner21114382011-01-19 12:26:59 +0100838
Philipp Reisner062e8792011-02-08 11:09:18 +0100839 unsigned long flags;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200840 struct net_conf *net_conf; /* content protected by rcu */
Philipp Reisner91fd4da2011-04-20 17:47:29 +0200841 struct mutex net_conf_update; /* mutex for ready-copy-update of net_conf */
842 wait_queue_head_t ping_wait; /* Woken upon reception of a ping, and a state change */
Lars Ellenbergf3990022011-03-23 14:31:09 +0100843 struct res_opts res_opts;
Philipp Reisnere42325a2011-01-19 13:55:45 +0100844
845 struct drbd_socket data; /* data/barrier/cstate/parameter packets */
846 struct drbd_socket meta; /* ping/ack (metadata) packets */
Philipp Reisner31890f42011-01-19 14:12:51 +0100847 int agreed_pro_version; /* actually used protocol version */
848 unsigned long last_received; /* in jiffies, either socket */
849 unsigned int ko_count;
Philipp Reisnere6b3ea82011-01-19 14:02:01 +0100850
Philipp Reisner87eeee42011-01-19 14:16:30 +0100851 spinlock_t req_lock;
852 struct drbd_tl_epoch *unused_spare_tle; /* for pre-allocation */
853 struct drbd_tl_epoch *newest_tle;
854 struct drbd_tl_epoch *oldest_tle;
855 struct list_head out_of_sequence_requests;
856
Philipp Reisnera0638452011-01-19 14:31:32 +0100857 struct crypto_hash *cram_hmac_tfm;
858 struct crypto_hash *integrity_w_tfm; /* to be used by the worker thread */
859 struct crypto_hash *integrity_r_tfm; /* to be used by the receiver thread */
Lars Ellenbergf3990022011-03-23 14:31:09 +0100860 struct crypto_hash *csums_tfm;
861 struct crypto_hash *verify_tfm;
Philipp Reisnera0638452011-01-19 14:31:32 +0100862 void *int_dig_in;
863 void *int_dig_vv;
864
Philipp Reisnere6b3ea82011-01-19 14:02:01 +0100865 struct drbd_thread receiver;
866 struct drbd_thread worker;
867 struct drbd_thread asender;
Philipp Reisner80822282011-02-08 12:46:30 +0100868 cpumask_var_t cpu_mask;
Philipp Reisner21114382011-01-19 12:26:59 +0100869};
870
Philipp Reisnerb411b362009-09-25 16:07:19 -0700871struct drbd_conf {
Philipp Reisner21114382011-01-19 12:26:59 +0100872 struct drbd_tconn *tconn;
873 int vnr; /* volume number within the connection */
874
Philipp Reisnerb411b362009-09-25 16:07:19 -0700875 /* things that are stored as / read from meta data on disk */
876 unsigned long flags;
877
878 /* configured by drbdsetup */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700879 struct drbd_backing_dev *ldev __protected_by(local);
880
881 sector_t p_size; /* partner's disk size */
882 struct request_queue *rq_queue;
883 struct block_device *this_bdev;
884 struct gendisk *vdisk;
885
Philipp Reisnerb411b362009-09-25 16:07:19 -0700886 struct drbd_work resync_work,
887 unplug_work,
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +0200888 go_diskless,
Philipp Reisnerc4752ef2010-10-27 17:32:36 +0200889 md_sync_work,
890 start_resync_work;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700891 struct timer_list resync_timer;
892 struct timer_list md_sync_timer;
Philipp Reisner370a43e2011-01-14 16:03:11 +0100893 struct timer_list start_resync_timer;
Philipp Reisner7fde2be2011-03-01 11:08:28 +0100894 struct timer_list request_timer;
Lars Ellenbergee15b032010-09-03 10:00:09 +0200895#ifdef DRBD_DEBUG_MD_SYNC
896 struct {
897 unsigned int line;
898 const char* func;
899 } last_md_mark_dirty;
900#endif
Philipp Reisnerb411b362009-09-25 16:07:19 -0700901
902 /* Used after attach while negotiating new disk state. */
903 union drbd_state new_state_tmp;
904
Philipp Reisnerda9fbc22011-03-29 10:52:01 +0200905 union drbd_dev_state state;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700906 wait_queue_head_t misc_wait;
907 wait_queue_head_t state_wait; /* upon each state change. */
908 unsigned int send_cnt;
909 unsigned int recv_cnt;
910 unsigned int read_cnt;
911 unsigned int writ_cnt;
912 unsigned int al_writ_cnt;
913 unsigned int bm_writ_cnt;
914 atomic_t ap_bio_cnt; /* Requests we need to complete */
915 atomic_t ap_pending_cnt; /* AP data packets on the wire, ack expected */
916 atomic_t rs_pending_cnt; /* RS request/data packets on the wire */
917 atomic_t unacked_cnt; /* Need to send replys for */
918 atomic_t local_cnt; /* Waiting for local completion */
Philipp Reisnerb2fb6dbe2011-01-19 13:48:44 +0100919
Andreas Gruenbacherdac13892011-01-21 17:18:39 +0100920 /* Interval tree of pending local requests */
921 struct rb_root read_requests;
Andreas Gruenbacherde696712011-01-20 15:00:24 +0100922 struct rb_root write_requests;
923
Lars Ellenberg4b0715f2010-12-14 15:13:04 +0100924 /* blocks to resync in this run [unit BM_BLOCK_SIZE] */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700925 unsigned long rs_total;
Lars Ellenberg4b0715f2010-12-14 15:13:04 +0100926 /* number of resync blocks that failed in this run */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700927 unsigned long rs_failed;
928 /* Syncer's start time [unit jiffies] */
929 unsigned long rs_start;
930 /* cumulated time in PausedSyncX state [unit jiffies] */
931 unsigned long rs_paused;
Lars Ellenberg1d7734a2010-08-11 21:21:50 +0200932 /* skipped because csum was equal [unit BM_BLOCK_SIZE] */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700933 unsigned long rs_same_csum;
Lars Ellenberg1d7734a2010-08-11 21:21:50 +0200934#define DRBD_SYNC_MARKS 8
935#define DRBD_SYNC_MARK_STEP (3*HZ)
936 /* block not up-to-date at mark [unit BM_BLOCK_SIZE] */
937 unsigned long rs_mark_left[DRBD_SYNC_MARKS];
938 /* marks's time [unit jiffies] */
939 unsigned long rs_mark_time[DRBD_SYNC_MARKS];
940 /* current index into rs_mark_{left,time} */
941 int rs_last_mark;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700942
943 /* where does the admin want us to start? (sector) */
944 sector_t ov_start_sector;
945 /* where are we now? (sector) */
946 sector_t ov_position;
947 /* Start sector of out of sync range (to merge printk reporting). */
948 sector_t ov_last_oos_start;
949 /* size of out-of-sync range in sectors. */
950 sector_t ov_last_oos_size;
951 unsigned long ov_left; /* in bits */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700952
Philipp Reisnerb411b362009-09-25 16:07:19 -0700953 struct drbd_bitmap *bitmap;
954 unsigned long bm_resync_fo; /* bit offset for drbd_bm_find_next */
955
956 /* Used to track operations of resync... */
957 struct lru_cache *resync;
958 /* Number of locked elements in resync LRU */
959 unsigned int resync_locked;
960 /* resync extent number waiting for application requests */
961 unsigned int resync_wenr;
962
963 int open_cnt;
964 u64 *p_uuid;
965 struct drbd_epoch *current_epoch;
966 spinlock_t epoch_lock;
967 unsigned int epochs;
968 enum write_ordering_e write_ordering;
Philipp Reisner85719572010-07-21 10:20:17 +0200969 struct list_head active_ee; /* IO in progress (P_DATA gets written to disk) */
970 struct list_head sync_ee; /* IO in progress (P_RS_DATA_REPLY gets written to disk) */
Andreas Gruenbacher18b75d72011-02-04 15:36:22 +0100971 struct list_head done_ee; /* need to send P_WRITE_ACK */
972 struct list_head read_ee; /* [RS]P_DATA_REQUEST being read */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700973 struct list_head net_ee; /* zero-copy network send in progress */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700974
Philipp Reisnerb411b362009-09-25 16:07:19 -0700975 int next_barrier_nr;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700976 struct list_head resync_reads;
Lars Ellenberg435f0742010-09-06 12:30:25 +0200977 atomic_t pp_in_use; /* allocated from page pool */
978 atomic_t pp_in_use_by_net; /* sendpage()d, still referenced by tcp */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700979 wait_queue_head_t ee_wait;
980 struct page *md_io_page; /* one page buffer for md_io */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700981 struct mutex md_io_mutex; /* protects the md_io_buffer */
982 spinlock_t al_lock;
983 wait_queue_head_t al_wait;
984 struct lru_cache *act_log; /* activity log */
985 unsigned int al_tr_number;
986 int al_tr_cycle;
987 int al_tr_pos; /* position of the next transaction in the journal */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700988 wait_queue_head_t seq_wait;
989 atomic_t packet_seq;
990 unsigned int peer_seq;
991 spinlock_t peer_seq_lock;
992 unsigned int minor;
993 unsigned long comm_bm_set; /* communicated number of set bits. */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700994 struct bm_io_work bm_io_work;
995 u64 ed_uuid; /* UUID of the exposed data */
Philipp Reisner8410da8f02011-02-11 20:11:10 +0100996 struct mutex own_state_mutex;
997 struct mutex *state_mutex; /* either own_state_mutex or mdev->tconn->cstate_mutex */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700998 char congestion_reason; /* Why we where congested... */
Lars Ellenberg1d7734a2010-08-11 21:21:50 +0200999 atomic_t rs_sect_in; /* for incoming resync data rate, SyncTarget */
1000 atomic_t rs_sect_ev; /* for submitted resync data rate, both */
1001 int rs_last_sect_ev; /* counter to compare with */
1002 int rs_last_events; /* counter of read or write "events" (unit sectors)
1003 * on the lower level device when we last looked. */
1004 int c_sync_rate; /* current resync rate after syncer throttle magic */
Philipp Reisner778f2712010-07-06 11:14:00 +02001005 struct fifo_buffer rs_plan_s; /* correction values of resync planer */
1006 int rs_in_flight; /* resync sectors in flight (to proxy, in proxy and from proxy) */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001007 int rs_planed; /* resync sectors already planned */
Philipp Reisner759fbdf2010-10-26 16:02:27 +02001008 atomic_t ap_in_flight; /* App sectors in flight (waiting for ack) */
Philipp Reisner99432fc2011-05-20 16:39:13 +02001009 int peer_max_bio_size;
1010 int local_max_bio_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001011};
1012
1013static inline struct drbd_conf *minor_to_mdev(unsigned int minor)
1014{
Philipp Reisner81a5d602011-02-22 19:53:16 -05001015 return (struct drbd_conf *)idr_find(&minors, minor);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001016}
1017
1018static inline unsigned int mdev_to_minor(struct drbd_conf *mdev)
1019{
1020 return mdev->minor;
1021}
1022
Philipp Reisnereefc2f72011-02-08 12:55:24 +01001023static inline struct drbd_conf *vnr_to_mdev(struct drbd_tconn *tconn, int vnr)
1024{
1025 return (struct drbd_conf *)idr_find(&tconn->volumes, vnr);
1026}
1027
Philipp Reisnerb411b362009-09-25 16:07:19 -07001028/*
1029 * function declarations
1030 *************************/
1031
1032/* drbd_main.c */
1033
Philipp Reisnere89b5912010-03-24 17:11:33 +01001034enum dds_flags {
1035 DDSF_FORCED = 1,
1036 DDSF_NO_RESYNC = 2, /* Do not run a resync for the new space */
1037};
1038
Philipp Reisnerb411b362009-09-25 16:07:19 -07001039extern void drbd_init_set_defaults(struct drbd_conf *mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001040extern int drbd_thread_start(struct drbd_thread *thi);
1041extern void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait);
Philipp Reisner392c8802011-02-09 10:33:31 +01001042extern char *drbd_task_to_thread_name(struct drbd_tconn *tconn, struct task_struct *task);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001043#ifdef CONFIG_SMP
Philipp Reisner80822282011-02-08 12:46:30 +01001044extern void drbd_thread_current_set_cpu(struct drbd_thread *thi);
1045extern void drbd_calc_cpu_mask(struct drbd_tconn *tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001046#else
Philipp Reisner80822282011-02-08 12:46:30 +01001047#define drbd_thread_current_set_cpu(A) ({})
Philipp Reisnerb411b362009-09-25 16:07:19 -07001048#define drbd_calc_cpu_mask(A) ({})
1049#endif
Philipp Reisner2f5cdd02011-02-21 14:29:27 +01001050extern void tl_release(struct drbd_tconn *, unsigned int barrier_nr,
Philipp Reisnerb411b362009-09-25 16:07:19 -07001051 unsigned int set_size);
Philipp Reisner2f5cdd02011-02-21 14:29:27 +01001052extern void tl_clear(struct drbd_tconn *);
1053extern void _tl_add_barrier(struct drbd_tconn *, struct drbd_tl_epoch *);
Philipp Reisner360cc742011-02-08 14:29:53 +01001054extern void drbd_free_sock(struct drbd_tconn *tconn);
Philipp Reisnerbedbd2a2011-02-07 15:08:48 +01001055extern int drbd_send(struct drbd_tconn *tconn, struct socket *sock,
1056 void *buf, size_t size, unsigned msg_flags);
Andreas Gruenbacherfb708e42010-12-15 17:04:36 +01001057extern int drbd_send_all(struct drbd_tconn *, struct socket *, void *, size_t,
1058 unsigned);
1059
Philipp Reisnerdc8228d2011-02-08 10:13:15 +01001060extern int drbd_send_protocol(struct drbd_tconn *tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001061extern int drbd_send_uuids(struct drbd_conf *mdev);
1062extern int drbd_send_uuids_skip_initial_sync(struct drbd_conf *mdev);
Andreas Gruenbacher9c1b7f72011-03-16 01:09:01 +01001063extern void drbd_gen_and_send_sync_uuid(struct drbd_conf *mdev);
Philipp Reisnere89b5912010-03-24 17:11:33 +01001064extern int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags flags);
Philipp Reisnercf29c9d2011-02-11 15:11:24 +01001065extern int _conn_send_state_req(struct drbd_tconn *, int vnr, enum drbd_packet cmd,
1066 union drbd_state, union drbd_state);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001067extern int _drbd_send_state(struct drbd_conf *mdev);
1068extern int drbd_send_state(struct drbd_conf *mdev);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001069extern int drbd_send_sync_param(struct drbd_conf *mdev);
Andreas Gruenbacherd4e67d72011-03-16 01:25:28 +01001070extern void drbd_send_b_ack(struct drbd_conf *mdev, u32 barrier_nr,
1071 u32 set_size);
Andreas Gruenbacherf6ffca92011-02-04 15:30:34 +01001072extern int drbd_send_ack(struct drbd_conf *, enum drbd_packet,
1073 struct drbd_peer_request *);
Andreas Gruenbachera9a99942011-03-16 01:30:14 +01001074extern void drbd_send_ack_rp(struct drbd_conf *mdev, enum drbd_packet cmd,
1075 struct p_block_req *rp);
1076extern void drbd_send_ack_dp(struct drbd_conf *mdev, enum drbd_packet cmd,
1077 struct p_data *dp, int data_size);
Andreas Gruenbacherd8763022011-01-26 17:39:41 +01001078extern int drbd_send_ack_ex(struct drbd_conf *mdev, enum drbd_packet cmd,
Philipp Reisnerb411b362009-09-25 16:07:19 -07001079 sector_t sector, int blksize, u64 block_id);
Andreas Gruenbacher8f7bed72010-12-19 23:53:14 +01001080extern int drbd_send_out_of_sync(struct drbd_conf *, struct drbd_request *);
Andreas Gruenbacherf6ffca92011-02-04 15:30:34 +01001081extern int drbd_send_block(struct drbd_conf *, enum drbd_packet,
1082 struct drbd_peer_request *);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001083extern int drbd_send_dblock(struct drbd_conf *mdev, struct drbd_request *req);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001084extern int drbd_send_drequest(struct drbd_conf *mdev, int cmd,
1085 sector_t sector, int size, u64 block_id);
Andreas Gruenbacherd8763022011-01-26 17:39:41 +01001086extern int drbd_send_drequest_csum(struct drbd_conf *mdev, sector_t sector,
1087 int size, void *digest, int digest_size,
1088 enum drbd_packet cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001089extern int drbd_send_ov_request(struct drbd_conf *mdev,sector_t sector,int size);
1090
1091extern int drbd_send_bitmap(struct drbd_conf *mdev);
Andreas Gruenbacher2f4e7ab2011-03-16 01:20:38 +01001092extern void drbd_send_sr_reply(struct drbd_conf *mdev, enum drbd_state_rv retcode);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001093extern void conn_send_sr_reply(struct drbd_tconn *tconn, enum drbd_state_rv retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001094extern void drbd_free_bc(struct drbd_backing_dev *ldev);
1095extern void drbd_mdev_cleanup(struct drbd_conf *mdev);
Lars Ellenberg62b0da32011-01-20 13:25:21 +01001096void drbd_print_uuids(struct drbd_conf *mdev, const char *text);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001097
Philipp Reisnerb411b362009-09-25 16:07:19 -07001098extern void drbd_md_sync(struct drbd_conf *mdev);
1099extern int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001100extern void drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local);
1101extern void _drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local);
1102extern void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local);
1103extern void _drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local);
1104extern void drbd_uuid_set_bm(struct drbd_conf *mdev, u64 val) __must_hold(local);
1105extern void drbd_md_set_flag(struct drbd_conf *mdev, int flags) __must_hold(local);
1106extern void drbd_md_clear_flag(struct drbd_conf *mdev, int flags)__must_hold(local);
1107extern int drbd_md_test_flag(struct drbd_backing_dev *, int);
Lars Ellenbergee15b032010-09-03 10:00:09 +02001108#ifndef DRBD_DEBUG_MD_SYNC
Philipp Reisnerb411b362009-09-25 16:07:19 -07001109extern void drbd_md_mark_dirty(struct drbd_conf *mdev);
Lars Ellenbergee15b032010-09-03 10:00:09 +02001110#else
1111#define drbd_md_mark_dirty(m) drbd_md_mark_dirty_(m, __LINE__ , __func__ )
1112extern void drbd_md_mark_dirty_(struct drbd_conf *mdev,
1113 unsigned int line, const char *func);
1114#endif
Philipp Reisnerb411b362009-09-25 16:07:19 -07001115extern void drbd_queue_bitmap_io(struct drbd_conf *mdev,
1116 int (*io_fn)(struct drbd_conf *),
1117 void (*done)(struct drbd_conf *, int),
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01001118 char *why, enum bm_flag flags);
1119extern int drbd_bitmap_io(struct drbd_conf *mdev,
1120 int (*io_fn)(struct drbd_conf *),
1121 char *why, enum bm_flag flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001122extern int drbd_bmio_set_n_write(struct drbd_conf *mdev);
1123extern int drbd_bmio_clear_n_write(struct drbd_conf *mdev);
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +02001124extern void drbd_go_diskless(struct drbd_conf *mdev);
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001125extern void drbd_ldev_destroy(struct drbd_conf *mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001126
Philipp Reisnerb411b362009-09-25 16:07:19 -07001127/* Meta data layout
1128 We reserve a 128MB Block (4k aligned)
1129 * either at the end of the backing device
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08001130 * or on a separate meta data device. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001131
Philipp Reisnerb411b362009-09-25 16:07:19 -07001132/* The following numbers are sectors */
Lars Ellenberg7ad651b2011-02-21 13:21:03 +01001133/* Allows up to about 3.8TB, so if you want more,
1134 * you need to use the "flexible" meta data format. */
1135#define MD_RESERVED_SECT (128LU << 11) /* 128 MB, unit sectors */
1136#define MD_AL_OFFSET 8 /* 8 Sectors after start of meta area */
1137#define MD_AL_SECTORS 64 /* = 32 kB on disk activity log ring buffer */
1138#define MD_BM_OFFSET (MD_AL_OFFSET + MD_AL_SECTORS)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001139
Lars Ellenberg7ad651b2011-02-21 13:21:03 +01001140/* we do all meta data IO in 4k blocks */
1141#define MD_BLOCK_SHIFT 12
1142#define MD_BLOCK_SIZE (1<<MD_BLOCK_SHIFT)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001143
Lars Ellenberg7ad651b2011-02-21 13:21:03 +01001144/* One activity log extent represents 4M of storage */
1145#define AL_EXTENT_SHIFT 22
Philipp Reisnerb411b362009-09-25 16:07:19 -07001146#define AL_EXTENT_SIZE (1<<AL_EXTENT_SHIFT)
1147
Lars Ellenberg7ad651b2011-02-21 13:21:03 +01001148/* We could make these currently hardcoded constants configurable
1149 * variables at create-md time (or even re-configurable at runtime?).
1150 * Which will require some more changes to the DRBD "super block"
1151 * and attach code.
1152 *
1153 * updates per transaction:
1154 * This many changes to the active set can be logged with one transaction.
1155 * This number is arbitrary.
1156 * context per transaction:
1157 * This many context extent numbers are logged with each transaction.
1158 * This number is resulting from the transaction block size (4k), the layout
1159 * of the transaction header, and the number of updates per transaction.
1160 * See drbd_actlog.c:struct al_transaction_on_disk
1161 * */
1162#define AL_UPDATES_PER_TRANSACTION 64 // arbitrary
1163#define AL_CONTEXT_PER_TRANSACTION 919 // (4096 - 36 - 6*64)/4
1164
Philipp Reisnerb411b362009-09-25 16:07:19 -07001165#if BITS_PER_LONG == 32
1166#define LN2_BPL 5
1167#define cpu_to_lel(A) cpu_to_le32(A)
1168#define lel_to_cpu(A) le32_to_cpu(A)
1169#elif BITS_PER_LONG == 64
1170#define LN2_BPL 6
1171#define cpu_to_lel(A) cpu_to_le64(A)
1172#define lel_to_cpu(A) le64_to_cpu(A)
1173#else
1174#error "LN2 of BITS_PER_LONG unknown!"
1175#endif
1176
1177/* resync bitmap */
1178/* 16MB sized 'bitmap extent' to track syncer usage */
1179struct bm_extent {
1180 int rs_left; /* number of bits set (out of sync) in this extent. */
1181 int rs_failed; /* number of failed resync requests in this extent. */
1182 unsigned long flags;
1183 struct lc_element lce;
1184};
1185
1186#define BME_NO_WRITES 0 /* bm_extent.flags: no more requests on this one! */
1187#define BME_LOCKED 1 /* bm_extent.flags: syncer active on this one. */
Philipp Reisnere3555d82010-11-07 15:56:29 +01001188#define BME_PRIORITY 2 /* finish resync IO on this extent ASAP! App IO waiting! */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001189
1190/* drbd_bitmap.c */
1191/*
1192 * We need to store one bit for a block.
1193 * Example: 1GB disk @ 4096 byte blocks ==> we need 32 KB bitmap.
1194 * Bit 0 ==> local node thinks this block is binary identical on both nodes
1195 * Bit 1 ==> local node thinks this block needs to be synced.
1196 */
1197
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02001198#define SLEEP_TIME (HZ/10)
1199
Lars Ellenberg45dfffe2011-02-21 13:21:00 +01001200/* We do bitmap IO in units of 4k blocks.
1201 * We also still have a hardcoded 4k per bit relation. */
1202#define BM_BLOCK_SHIFT 12 /* 4k per bit */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001203#define BM_BLOCK_SIZE (1<<BM_BLOCK_SHIFT)
Lars Ellenberg45dfffe2011-02-21 13:21:00 +01001204/* mostly arbitrarily set the represented size of one bitmap extent,
1205 * aka resync extent, to 16 MiB (which is also 512 Byte worth of bitmap
1206 * at 4k per bit resolution) */
1207#define BM_EXT_SHIFT 24 /* 16 MiB per resync extent */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001208#define BM_EXT_SIZE (1<<BM_EXT_SHIFT)
1209
1210#if (BM_EXT_SHIFT != 24) || (BM_BLOCK_SHIFT != 12)
1211#error "HAVE YOU FIXED drbdmeta AS WELL??"
1212#endif
1213
1214/* thus many _storage_ sectors are described by one bit */
1215#define BM_SECT_TO_BIT(x) ((x)>>(BM_BLOCK_SHIFT-9))
1216#define BM_BIT_TO_SECT(x) ((sector_t)(x)<<(BM_BLOCK_SHIFT-9))
1217#define BM_SECT_PER_BIT BM_BIT_TO_SECT(1)
1218
1219/* bit to represented kilo byte conversion */
1220#define Bit2KB(bits) ((bits)<<(BM_BLOCK_SHIFT-10))
1221
1222/* in which _bitmap_ extent (resp. sector) the bit for a certain
1223 * _storage_ sector is located in */
1224#define BM_SECT_TO_EXT(x) ((x)>>(BM_EXT_SHIFT-9))
1225
1226/* how much _storage_ sectors we have per bitmap sector */
1227#define BM_EXT_TO_SECT(x) ((sector_t)(x) << (BM_EXT_SHIFT-9))
1228#define BM_SECT_PER_EXT BM_EXT_TO_SECT(1)
1229
1230/* in one sector of the bitmap, we have this many activity_log extents. */
1231#define AL_EXT_PER_BM_SECT (1 << (BM_EXT_SHIFT - AL_EXTENT_SHIFT))
1232#define BM_WORDS_PER_AL_EXT (1 << (AL_EXTENT_SHIFT-BM_BLOCK_SHIFT-LN2_BPL))
1233
1234#define BM_BLOCKS_PER_BM_EXT_B (BM_EXT_SHIFT - BM_BLOCK_SHIFT)
1235#define BM_BLOCKS_PER_BM_EXT_MASK ((1<<BM_BLOCKS_PER_BM_EXT_B) - 1)
1236
1237/* the extent in "PER_EXTENT" below is an activity log extent
1238 * we need that many (long words/bytes) to store the bitmap
1239 * of one AL_EXTENT_SIZE chunk of storage.
1240 * we can store the bitmap for that many AL_EXTENTS within
1241 * one sector of the _on_disk_ bitmap:
1242 * bit 0 bit 37 bit 38 bit (512*8)-1
1243 * ...|........|........|.. // ..|........|
1244 * sect. 0 `296 `304 ^(512*8*8)-1
1245 *
1246#define BM_WORDS_PER_EXT ( (AL_EXT_SIZE/BM_BLOCK_SIZE) / BITS_PER_LONG )
1247#define BM_BYTES_PER_EXT ( (AL_EXT_SIZE/BM_BLOCK_SIZE) / 8 ) // 128
1248#define BM_EXT_PER_SECT ( 512 / BM_BYTES_PER_EXTENT ) // 4
1249 */
1250
1251#define DRBD_MAX_SECTORS_32 (0xffffffffLU)
1252#define DRBD_MAX_SECTORS_BM \
1253 ((MD_RESERVED_SECT - MD_BM_OFFSET) * (1LL<<(BM_EXT_SHIFT-9)))
1254#if DRBD_MAX_SECTORS_BM < DRBD_MAX_SECTORS_32
1255#define DRBD_MAX_SECTORS DRBD_MAX_SECTORS_BM
1256#define DRBD_MAX_SECTORS_FLEX DRBD_MAX_SECTORS_BM
Lars Ellenberg36bfc7e2010-01-05 19:33:54 +01001257#elif !defined(CONFIG_LBDAF) && BITS_PER_LONG == 32
Philipp Reisnerb411b362009-09-25 16:07:19 -07001258#define DRBD_MAX_SECTORS DRBD_MAX_SECTORS_32
1259#define DRBD_MAX_SECTORS_FLEX DRBD_MAX_SECTORS_32
1260#else
1261#define DRBD_MAX_SECTORS DRBD_MAX_SECTORS_BM
1262/* 16 TB in units of sectors */
1263#if BITS_PER_LONG == 32
1264/* adjust by one page worth of bitmap,
1265 * so we won't wrap around in drbd_bm_find_next_bit.
1266 * you should use 64bit OS for that much storage, anyways. */
1267#define DRBD_MAX_SECTORS_FLEX BM_BIT_TO_SECT(0xffff7fff)
1268#else
Lars Ellenberg4b0715f2010-12-14 15:13:04 +01001269/* we allow up to 1 PiB now on 64bit architecture with "flexible" meta data */
1270#define DRBD_MAX_SECTORS_FLEX (1UL << 51)
1271/* corresponds to (1UL << 38) bits right now. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001272#endif
1273#endif
1274
Lars Ellenberg23361cf2011-03-31 16:36:43 +02001275/* BIO_MAX_SIZE is 256 * PAGE_CACHE_SIZE,
1276 * so for typical PAGE_CACHE_SIZE of 4k, that is (1<<20) Byte.
1277 * Since we may live in a mixed-platform cluster,
1278 * we limit us to a platform agnostic constant here for now.
1279 * A followup commit may allow even bigger BIO sizes,
1280 * once we thought that through. */
1281#define DRBD_MAX_BIO_SIZE (1 << 20)
1282#if DRBD_MAX_BIO_SIZE > BIO_MAX_SIZE
1283#error Architecture not supported: DRBD_MAX_BIO_SIZE > BIO_MAX_SIZE
1284#endif
Philipp Reisner99432fc2011-05-20 16:39:13 +02001285#define DRBD_MAX_BIO_SIZE_SAFE (1 << 12) /* Works always = 4k */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001286
Philipp Reisnerd5373382010-08-23 15:18:33 +02001287#define DRBD_MAX_SIZE_H80_PACKET (1 << 15) /* The old header only allows packets up to 32Kib data */
1288
Philipp Reisnerb411b362009-09-25 16:07:19 -07001289extern int drbd_bm_init(struct drbd_conf *mdev);
Philipp Reisner02d9a942010-03-24 16:23:03 +01001290extern int drbd_bm_resize(struct drbd_conf *mdev, sector_t sectors, int set_new_bits);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001291extern void drbd_bm_cleanup(struct drbd_conf *mdev);
1292extern void drbd_bm_set_all(struct drbd_conf *mdev);
1293extern void drbd_bm_clear_all(struct drbd_conf *mdev);
Lars Ellenberg4b0715f2010-12-14 15:13:04 +01001294/* set/clear/test only a few bits at a time */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001295extern int drbd_bm_set_bits(
1296 struct drbd_conf *mdev, unsigned long s, unsigned long e);
1297extern int drbd_bm_clear_bits(
1298 struct drbd_conf *mdev, unsigned long s, unsigned long e);
Lars Ellenberg4b0715f2010-12-14 15:13:04 +01001299extern int drbd_bm_count_bits(
1300 struct drbd_conf *mdev, const unsigned long s, const unsigned long e);
1301/* bm_set_bits variant for use while holding drbd_bm_lock,
1302 * may process the whole bitmap in one go */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001303extern void _drbd_bm_set_bits(struct drbd_conf *mdev,
1304 const unsigned long s, const unsigned long e);
1305extern int drbd_bm_test_bit(struct drbd_conf *mdev, unsigned long bitnr);
1306extern int drbd_bm_e_weight(struct drbd_conf *mdev, unsigned long enr);
Lars Ellenberg19f843a2010-12-15 08:59:11 +01001307extern int drbd_bm_write_page(struct drbd_conf *mdev, unsigned int idx) __must_hold(local);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001308extern int drbd_bm_read(struct drbd_conf *mdev) __must_hold(local);
Lars Ellenberg45dfffe2011-02-21 13:21:00 +01001309extern void drbd_bm_mark_for_writeout(struct drbd_conf *mdev, int page_nr);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001310extern int drbd_bm_write(struct drbd_conf *mdev) __must_hold(local);
Lars Ellenberg45dfffe2011-02-21 13:21:00 +01001311extern int drbd_bm_write_hinted(struct drbd_conf *mdev) __must_hold(local);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001312extern unsigned long drbd_bm_ALe_set_all(struct drbd_conf *mdev,
1313 unsigned long al_enr);
1314extern size_t drbd_bm_words(struct drbd_conf *mdev);
1315extern unsigned long drbd_bm_bits(struct drbd_conf *mdev);
1316extern sector_t drbd_bm_capacity(struct drbd_conf *mdev);
Lars Ellenberg4b0715f2010-12-14 15:13:04 +01001317
1318#define DRBD_END_OF_BITMAP (~(unsigned long)0)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001319extern unsigned long drbd_bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo);
1320/* bm_find_next variants for use while you hold drbd_bm_lock() */
1321extern unsigned long _drbd_bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo);
1322extern unsigned long _drbd_bm_find_next_zero(struct drbd_conf *mdev, unsigned long bm_fo);
Philipp Reisner07782862010-08-31 12:00:50 +02001323extern unsigned long _drbd_bm_total_weight(struct drbd_conf *mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001324extern unsigned long drbd_bm_total_weight(struct drbd_conf *mdev);
1325extern int drbd_bm_rs_done(struct drbd_conf *mdev);
1326/* for receive_bitmap */
1327extern void drbd_bm_merge_lel(struct drbd_conf *mdev, size_t offset,
1328 size_t number, unsigned long *buffer);
Lars Ellenberg19f843a2010-12-15 08:59:11 +01001329/* for _drbd_send_bitmap */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001330extern void drbd_bm_get_lel(struct drbd_conf *mdev, size_t offset,
1331 size_t number, unsigned long *buffer);
1332
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01001333extern void drbd_bm_lock(struct drbd_conf *mdev, char *why, enum bm_flag flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001334extern void drbd_bm_unlock(struct drbd_conf *mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001335/* drbd_main.c */
1336
1337extern struct kmem_cache *drbd_request_cache;
Andreas Gruenbacher6c852be2011-02-04 15:38:52 +01001338extern struct kmem_cache *drbd_ee_cache; /* peer requests */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001339extern struct kmem_cache *drbd_bm_ext_cache; /* bitmap extents */
1340extern struct kmem_cache *drbd_al_ext_cache; /* activity log extents */
1341extern mempool_t *drbd_request_mempool;
1342extern mempool_t *drbd_ee_mempool;
1343
Lars Ellenberg35abf592011-02-23 12:39:46 +01001344/* drbd's page pool, used to buffer data received from the peer,
1345 * or data requested by the peer.
1346 *
1347 * This does not have an emergency reserve.
1348 *
1349 * When allocating from this pool, it first takes pages from the pool.
1350 * Only if the pool is depleted will try to allocate from the system.
1351 *
1352 * The assumption is that pages taken from this pool will be processed,
1353 * and given back, "quickly", and then can be recycled, so we can avoid
1354 * frequent calls to alloc_page(), and still will be able to make progress even
1355 * under memory pressure.
1356 */
1357extern struct page *drbd_pp_pool;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001358extern spinlock_t drbd_pp_lock;
1359extern int drbd_pp_vacant;
1360extern wait_queue_head_t drbd_pp_wait;
1361
Lars Ellenberg35abf592011-02-23 12:39:46 +01001362/* We also need a standard (emergency-reserve backed) page pool
1363 * for meta data IO (activity log, bitmap).
1364 * We can keep it global, as long as it is used as "N pages at a time".
1365 * 128 should be plenty, currently we probably can get away with as few as 1.
1366 */
1367#define DRBD_MIN_POOL_PAGES 128
1368extern mempool_t *drbd_md_io_page_pool;
1369
Lars Ellenbergda4a75d2011-02-23 17:02:01 +01001370/* We also need to make sure we get a bio
1371 * when we need it for housekeeping purposes */
1372extern struct bio_set *drbd_md_io_bio_set;
1373/* to allocate from that set */
1374extern struct bio *bio_alloc_drbd(gfp_t gfp_mask);
1375
Philipp Reisnerb411b362009-09-25 16:07:19 -07001376extern rwlock_t global_state_lock;
1377
Philipp Reisner80883192011-02-18 14:56:45 +01001378extern int conn_lowest_minor(struct drbd_tconn *tconn);
Philipp Reisner774b3052011-02-22 02:07:03 -05001379enum drbd_ret_code conn_new_minor(struct drbd_tconn *tconn, unsigned int minor, int vnr);
Philipp Reisnerff370e52011-04-11 21:10:11 -07001380extern void drbd_delete_device(struct drbd_conf *mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001381
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02001382struct drbd_tconn *conn_create(const char *name);
1383extern void conn_destroy(struct kref *kref);
Philipp Reisner1aba4d72011-02-21 15:38:08 +01001384struct drbd_tconn *conn_by_name(const char *name);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02001385extern void conn_free_crypto(struct drbd_tconn *tconn);
Philipp Reisner21114382011-01-19 12:26:59 +01001386
Philipp Reisnerb411b362009-09-25 16:07:19 -07001387extern int proc_details;
1388
1389/* drbd_req */
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001390extern int __drbd_make_request(struct drbd_conf *, struct bio *, unsigned long);
Andreas Gruenbacher2f58dcf2010-12-13 17:48:19 +01001391extern int drbd_make_request(struct request_queue *q, struct bio *bio);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001392extern int drbd_read_remote(struct drbd_conf *mdev, struct drbd_request *req);
1393extern int drbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bvm, struct bio_vec *bvec);
1394extern int is_valid_ar_handle(struct drbd_request *, sector_t);
1395
1396
1397/* drbd_nl.c */
Lars Ellenberg8432b312011-03-08 16:11:16 +01001398extern int drbd_msg_put_info(const char *info);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001399extern void drbd_suspend_io(struct drbd_conf *mdev);
1400extern void drbd_resume_io(struct drbd_conf *mdev);
1401extern char *ppsize(char *buf, unsigned long long size);
Philipp Reisnera393db62009-12-22 13:35:52 +01001402extern sector_t drbd_new_dev_size(struct drbd_conf *, struct drbd_backing_dev *, int);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001403enum determine_dev_size { dev_size_error = -1, unchanged = 0, shrunk = 1, grew = 2 };
Bart Van Assche24c48302011-05-21 18:32:29 +02001404extern enum determine_dev_size drbd_determine_dev_size(struct drbd_conf *, enum dds_flags) __must_hold(local);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001405extern void resync_after_online_grow(struct drbd_conf *);
Philipp Reisner99432fc2011-05-20 16:39:13 +02001406extern void drbd_reconsider_max_bio_size(struct drbd_conf *mdev);
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +01001407extern enum drbd_state_rv drbd_set_role(struct drbd_conf *mdev,
1408 enum drbd_role new_role,
1409 int force);
Philipp Reisnercb703452011-03-24 11:03:07 +01001410extern bool conn_try_outdate_peer(struct drbd_tconn *tconn);
1411extern void conn_try_outdate_peer_async(struct drbd_tconn *tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001412extern int drbd_khelper(struct drbd_conf *mdev, char *cmd);
1413
1414/* drbd_worker.c */
1415extern int drbd_worker(struct drbd_thread *thi);
1416extern int drbd_alter_sa(struct drbd_conf *mdev, int na);
1417extern void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side);
1418extern void resume_next_sg(struct drbd_conf *mdev);
1419extern void suspend_other_sg(struct drbd_conf *mdev);
1420extern int drbd_resync_finished(struct drbd_conf *mdev);
1421/* maybe rather drbd_main.c ? */
1422extern int drbd_md_sync_page_io(struct drbd_conf *mdev,
1423 struct drbd_backing_dev *bdev, sector_t sector, int rw);
Andreas Gruenbacher8f7bed72010-12-19 23:53:14 +01001424extern void drbd_ov_out_of_sync_found(struct drbd_conf *, sector_t, int);
Lars Ellenberg9bd28d32010-11-05 09:55:18 +01001425extern void drbd_rs_controller_reset(struct drbd_conf *mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001426
Andreas Gruenbacher8f7bed72010-12-19 23:53:14 +01001427static inline void ov_out_of_sync_print(struct drbd_conf *mdev)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001428{
1429 if (mdev->ov_last_oos_size) {
1430 dev_err(DEV, "Out of sync: start=%llu, size=%lu (sectors)\n",
1431 (unsigned long long)mdev->ov_last_oos_start,
1432 (unsigned long)mdev->ov_last_oos_size);
1433 }
1434 mdev->ov_last_oos_size=0;
1435}
1436
1437
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001438extern void drbd_csum_bio(struct drbd_conf *, struct crypto_hash *, struct bio *, void *);
Andreas Gruenbacherf6ffca92011-02-04 15:30:34 +01001439extern void drbd_csum_ee(struct drbd_conf *, struct crypto_hash *,
1440 struct drbd_peer_request *, void *);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001441/* worker callbacks */
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001442extern int w_read_retry_remote(struct drbd_work *, int);
1443extern int w_e_end_data_req(struct drbd_work *, int);
1444extern int w_e_end_rsdata_req(struct drbd_work *, int);
1445extern int w_e_end_csum_rs_req(struct drbd_work *, int);
1446extern int w_e_end_ov_reply(struct drbd_work *, int);
1447extern int w_e_end_ov_req(struct drbd_work *, int);
1448extern int w_ov_finished(struct drbd_work *, int);
1449extern int w_resync_timer(struct drbd_work *, int);
1450extern int w_send_write_hint(struct drbd_work *, int);
1451extern int w_make_resync_request(struct drbd_work *, int);
1452extern int w_send_dblock(struct drbd_work *, int);
1453extern int w_send_barrier(struct drbd_work *, int);
1454extern int w_send_read_req(struct drbd_work *, int);
1455extern int w_prev_work_done(struct drbd_work *, int);
1456extern int w_e_reissue(struct drbd_work *, int);
1457extern int w_restart_disk_io(struct drbd_work *, int);
Andreas Gruenbacher8f7bed72010-12-19 23:53:14 +01001458extern int w_send_out_of_sync(struct drbd_work *, int);
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001459extern int w_start_resync(struct drbd_work *, int);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001460
1461extern void resync_timer_fn(unsigned long data);
Philipp Reisner370a43e2011-01-14 16:03:11 +01001462extern void start_resync_timer_fn(unsigned long data);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001463
1464/* drbd_receiver.c */
Philipp Reisnere3555d82010-11-07 15:56:29 +01001465extern int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector);
Andreas Gruenbacherfbe29de2011-02-17 16:38:35 +01001466extern int drbd_submit_peer_request(struct drbd_conf *,
1467 struct drbd_peer_request *, const unsigned,
1468 const int);
Andreas Gruenbacher7721f562011-04-06 17:14:02 +02001469extern int drbd_free_peer_reqs(struct drbd_conf *, struct list_head *);
Andreas Gruenbacher0db55362011-04-06 16:09:15 +02001470extern struct drbd_peer_request *drbd_alloc_peer_req(struct drbd_conf *, u64,
1471 sector_t, unsigned int,
1472 gfp_t) __must_hold(local);
Andreas Gruenbacher3967deb2011-04-06 16:16:56 +02001473extern void __drbd_free_peer_req(struct drbd_conf *, struct drbd_peer_request *,
1474 int);
1475#define drbd_free_peer_req(m,e) __drbd_free_peer_req(m, e, 0)
1476#define drbd_free_net_peer_req(m,e) __drbd_free_peer_req(m, e, 1)
Andreas Gruenbacherc37c8ec2011-04-07 21:02:09 +02001477extern struct page *drbd_alloc_pages(struct drbd_conf *, unsigned int, bool);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001478extern void drbd_set_recv_tcq(struct drbd_conf *mdev, int tcq_enabled);
1479extern void _drbd_clear_done_ee(struct drbd_conf *mdev, struct list_head *to_be_freed);
Philipp Reisner0e29d162011-02-18 14:23:11 +01001480extern void conn_flush_workqueue(struct drbd_tconn *tconn);
Philipp Reisner2325eb62011-03-15 16:56:18 +01001481extern int drbd_connected(int vnr, void *p, void *data);
Philipp Reisner0e29d162011-02-18 14:23:11 +01001482static inline void drbd_flush_workqueue(struct drbd_conf *mdev)
1483{
1484 conn_flush_workqueue(mdev->tconn);
1485}
Philipp Reisnerb411b362009-09-25 16:07:19 -07001486
Lars Ellenberged439842011-04-23 14:45:14 +02001487/* Yes, there is kernel_setsockopt, but only since 2.6.18.
1488 * So we have our own copy of it here. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001489static inline int drbd_setsockopt(struct socket *sock, int level, int optname,
Lars Ellenberged439842011-04-23 14:45:14 +02001490 char *optval, int optlen)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001491{
Lars Ellenberged439842011-04-23 14:45:14 +02001492 mm_segment_t oldfs = get_fs();
1493 char __user *uoptval;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001494 int err;
Lars Ellenberged439842011-04-23 14:45:14 +02001495
1496 uoptval = (char __user __force *)optval;
1497
1498 set_fs(KERNEL_DS);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001499 if (level == SOL_SOCKET)
Lars Ellenberged439842011-04-23 14:45:14 +02001500 err = sock_setsockopt(sock, level, optname, uoptval, optlen);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001501 else
Lars Ellenberged439842011-04-23 14:45:14 +02001502 err = sock->ops->setsockopt(sock, level, optname, uoptval,
Philipp Reisnerb411b362009-09-25 16:07:19 -07001503 optlen);
Lars Ellenberged439842011-04-23 14:45:14 +02001504 set_fs(oldfs);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001505 return err;
1506}
1507
1508static inline void drbd_tcp_cork(struct socket *sock)
1509{
Lars Ellenberged439842011-04-23 14:45:14 +02001510 int val = 1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001511 (void) drbd_setsockopt(sock, SOL_TCP, TCP_CORK,
Lars Ellenberged439842011-04-23 14:45:14 +02001512 (char*)&val, sizeof(val));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001513}
1514
1515static inline void drbd_tcp_uncork(struct socket *sock)
1516{
Lars Ellenberged439842011-04-23 14:45:14 +02001517 int val = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001518 (void) drbd_setsockopt(sock, SOL_TCP, TCP_CORK,
Lars Ellenberged439842011-04-23 14:45:14 +02001519 (char*)&val, sizeof(val));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001520}
1521
1522static inline void drbd_tcp_nodelay(struct socket *sock)
1523{
Lars Ellenberged439842011-04-23 14:45:14 +02001524 int val = 1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001525 (void) drbd_setsockopt(sock, SOL_TCP, TCP_NODELAY,
Lars Ellenberged439842011-04-23 14:45:14 +02001526 (char*)&val, sizeof(val));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001527}
1528
1529static inline void drbd_tcp_quickack(struct socket *sock)
1530{
Lars Ellenberged439842011-04-23 14:45:14 +02001531 int val = 2;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001532 (void) drbd_setsockopt(sock, SOL_TCP, TCP_QUICKACK,
Lars Ellenberged439842011-04-23 14:45:14 +02001533 (char*)&val, sizeof(val));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001534}
1535
1536void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo);
1537
1538/* drbd_proc.c */
1539extern struct proc_dir_entry *drbd_proc;
Emese Revfy7d4e9d02009-12-14 00:59:30 +01001540extern const struct file_operations drbd_proc_fops;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001541extern const char *drbd_conn_str(enum drbd_conns s);
1542extern const char *drbd_role_str(enum drbd_role s);
1543
1544/* drbd_actlog.c */
Lars Ellenberg181286a2011-03-31 15:18:56 +02001545extern void drbd_al_begin_io(struct drbd_conf *mdev, struct drbd_interval *i);
1546extern void drbd_al_complete_io(struct drbd_conf *mdev, struct drbd_interval *i);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001547extern void drbd_rs_complete_io(struct drbd_conf *mdev, sector_t sector);
1548extern int drbd_rs_begin_io(struct drbd_conf *mdev, sector_t sector);
1549extern int drbd_try_rs_begin_io(struct drbd_conf *mdev, sector_t sector);
1550extern void drbd_rs_cancel_all(struct drbd_conf *mdev);
1551extern int drbd_rs_del_all(struct drbd_conf *mdev);
1552extern void drbd_rs_failed_io(struct drbd_conf *mdev,
1553 sector_t sector, int size);
1554extern int drbd_al_read_log(struct drbd_conf *mdev, struct drbd_backing_dev *);
Lars Ellenbergea5442a2010-11-05 09:48:01 +01001555extern void drbd_advance_rs_marks(struct drbd_conf *mdev, unsigned long still_to_go);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001556extern void __drbd_set_in_sync(struct drbd_conf *mdev, sector_t sector,
1557 int size, const char *file, const unsigned int line);
1558#define drbd_set_in_sync(mdev, sector, size) \
1559 __drbd_set_in_sync(mdev, sector, size, __FILE__, __LINE__)
Philipp Reisner73a01a12010-10-27 14:33:00 +02001560extern int __drbd_set_out_of_sync(struct drbd_conf *mdev, sector_t sector,
Philipp Reisnerb411b362009-09-25 16:07:19 -07001561 int size, const char *file, const unsigned int line);
1562#define drbd_set_out_of_sync(mdev, sector, size) \
1563 __drbd_set_out_of_sync(mdev, sector, size, __FILE__, __LINE__)
1564extern void drbd_al_apply_to_bm(struct drbd_conf *mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001565extern void drbd_al_shrink(struct drbd_conf *mdev);
1566
Philipp Reisnerb411b362009-09-25 16:07:19 -07001567/* drbd_nl.c */
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001568/* state info broadcast */
1569struct sib_info {
1570 enum drbd_state_info_bcast_reason sib_reason;
1571 union {
1572 struct {
1573 char *helper_name;
1574 unsigned helper_exit_code;
1575 };
1576 struct {
1577 union drbd_state os;
1578 union drbd_state ns;
1579 };
1580 };
1581};
1582void drbd_bcast_event(struct drbd_conf *mdev, const struct sib_info *sib);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001583
Philipp Reisnerb411b362009-09-25 16:07:19 -07001584/*
1585 * inline helper functions
1586 *************************/
1587
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001588/* see also page_chain_add and friends in drbd_receiver.c */
1589static inline struct page *page_chain_next(struct page *page)
1590{
1591 return (struct page *)page_private(page);
1592}
1593#define page_chain_for_each(page) \
1594 for (; page && ({ prefetch(page_chain_next(page)); 1; }); \
1595 page = page_chain_next(page))
1596#define page_chain_for_each_safe(page, n) \
1597 for (; page && ({ n = page_chain_next(page); 1; }); page = n)
1598
1599static inline int drbd_bio_has_active_page(struct bio *bio)
1600{
1601 struct bio_vec *bvec;
1602 int i;
1603
1604 __bio_for_each_segment(bvec, bio, i, 0) {
1605 if (page_count(bvec->bv_page) > 1)
1606 return 1;
1607 }
1608
1609 return 0;
1610}
1611
Andreas Gruenbacher045417f2011-04-07 21:34:24 +02001612static inline int drbd_peer_req_has_active_page(struct drbd_peer_request *peer_req)
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001613{
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001614 struct page *page = peer_req->pages;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001615 page_chain_for_each(page) {
1616 if (page_count(page) > 1)
1617 return 1;
1618 }
1619 return 0;
1620}
1621
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +01001622static inline enum drbd_state_rv
1623_drbd_set_state(struct drbd_conf *mdev, union drbd_state ns,
1624 enum chg_state_flags flags, struct completion *done)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001625{
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +01001626 enum drbd_state_rv rv;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001627
1628 read_lock(&global_state_lock);
1629 rv = __drbd_set_state(mdev, ns, flags, done);
1630 read_unlock(&global_state_lock);
1631
1632 return rv;
1633}
1634
Philipp Reisner78bae592011-03-28 15:40:12 +02001635static inline union drbd_state drbd_read_state(struct drbd_conf *mdev)
1636{
1637 union drbd_state rv;
1638
Philipp Reisnerda9fbc22011-03-29 10:52:01 +02001639 rv.i = mdev->state.i;
Philipp Reisner8e0af252011-03-28 16:18:39 +02001640 rv.susp = mdev->tconn->susp;
1641 rv.susp_nod = mdev->tconn->susp_nod;
1642 rv.susp_fen = mdev->tconn->susp_fen;
Philipp Reisner78bae592011-03-28 15:40:12 +02001643
1644 return rv;
1645}
1646
Philipp Reisnerb411b362009-09-25 16:07:19 -07001647#define __drbd_chk_io_error(m,f) __drbd_chk_io_error_(m,f, __func__)
1648static inline void __drbd_chk_io_error_(struct drbd_conf *mdev, int forcedetach, const char *where)
1649{
1650 switch (mdev->ldev->dc.on_io_error) {
1651 case EP_PASS_ON:
1652 if (!forcedetach) {
Lars Ellenberg73835062010-05-27 11:51:56 +02001653 if (__ratelimit(&drbd_ratelimit_state))
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001654 dev_err(DEV, "Local IO failed in %s.\n", where);
Philipp Reisnerd2e17802011-03-14 11:54:47 +01001655 if (mdev->state.disk > D_INCONSISTENT)
1656 _drbd_set_state(_NS(mdev, disk, D_INCONSISTENT), CS_HARD, NULL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001657 break;
1658 }
1659 /* NOTE fall through to detach case if forcedetach set */
1660 case EP_DETACH:
1661 case EP_CALL_HELPER:
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001662 set_bit(WAS_IO_ERROR, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001663 if (mdev->state.disk > D_FAILED) {
1664 _drbd_set_state(_NS(mdev, disk, D_FAILED), CS_HARD, NULL);
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001665 dev_err(DEV,
1666 "Local IO failed in %s. Detaching...\n", where);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001667 }
1668 break;
1669 }
1670}
1671
1672/**
1673 * drbd_chk_io_error: Handle the on_io_error setting, should be called from all io completion handlers
1674 * @mdev: DRBD device.
1675 * @error: Error code passed to the IO completion callback
1676 * @forcedetach: Force detach. I.e. the error happened while accessing the meta data
1677 *
1678 * See also drbd_main.c:after_state_ch() if (os.disk > D_FAILED && ns.disk == D_FAILED)
1679 */
1680#define drbd_chk_io_error(m,e,f) drbd_chk_io_error_(m,e,f, __func__)
1681static inline void drbd_chk_io_error_(struct drbd_conf *mdev,
1682 int error, int forcedetach, const char *where)
1683{
1684 if (error) {
1685 unsigned long flags;
Philipp Reisner87eeee42011-01-19 14:16:30 +01001686 spin_lock_irqsave(&mdev->tconn->req_lock, flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001687 __drbd_chk_io_error_(mdev, forcedetach, where);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001688 spin_unlock_irqrestore(&mdev->tconn->req_lock, flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001689 }
1690}
1691
1692
1693/**
1694 * drbd_md_first_sector() - Returns the first sector number of the meta data area
1695 * @bdev: Meta data block device.
1696 *
1697 * BTW, for internal meta data, this happens to be the maximum capacity
1698 * we could agree upon with our peer node.
1699 */
1700static inline sector_t drbd_md_first_sector(struct drbd_backing_dev *bdev)
1701{
1702 switch (bdev->dc.meta_dev_idx) {
1703 case DRBD_MD_INDEX_INTERNAL:
1704 case DRBD_MD_INDEX_FLEX_INT:
1705 return bdev->md.md_offset + bdev->md.bm_offset;
1706 case DRBD_MD_INDEX_FLEX_EXT:
1707 default:
1708 return bdev->md.md_offset;
1709 }
1710}
1711
1712/**
1713 * drbd_md_last_sector() - Return the last sector number of the meta data area
1714 * @bdev: Meta data block device.
1715 */
1716static inline sector_t drbd_md_last_sector(struct drbd_backing_dev *bdev)
1717{
1718 switch (bdev->dc.meta_dev_idx) {
1719 case DRBD_MD_INDEX_INTERNAL:
1720 case DRBD_MD_INDEX_FLEX_INT:
1721 return bdev->md.md_offset + MD_AL_OFFSET - 1;
1722 case DRBD_MD_INDEX_FLEX_EXT:
1723 default:
1724 return bdev->md.md_offset + bdev->md.md_size_sect;
1725 }
1726}
1727
1728/* Returns the number of 512 byte sectors of the device */
1729static inline sector_t drbd_get_capacity(struct block_device *bdev)
1730{
1731 /* return bdev ? get_capacity(bdev->bd_disk) : 0; */
Mike Snitzer77304d22010-11-08 14:39:12 +01001732 return bdev ? i_size_read(bdev->bd_inode) >> 9 : 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001733}
1734
1735/**
1736 * drbd_get_max_capacity() - Returns the capacity we announce to out peer
1737 * @bdev: Meta data block device.
1738 *
1739 * returns the capacity we announce to out peer. we clip ourselves at the
1740 * various MAX_SECTORS, because if we don't, current implementation will
1741 * oops sooner or later
1742 */
1743static inline sector_t drbd_get_max_capacity(struct drbd_backing_dev *bdev)
1744{
1745 sector_t s;
1746 switch (bdev->dc.meta_dev_idx) {
1747 case DRBD_MD_INDEX_INTERNAL:
1748 case DRBD_MD_INDEX_FLEX_INT:
1749 s = drbd_get_capacity(bdev->backing_bdev)
1750 ? min_t(sector_t, DRBD_MAX_SECTORS_FLEX,
1751 drbd_md_first_sector(bdev))
1752 : 0;
1753 break;
1754 case DRBD_MD_INDEX_FLEX_EXT:
1755 s = min_t(sector_t, DRBD_MAX_SECTORS_FLEX,
1756 drbd_get_capacity(bdev->backing_bdev));
1757 /* clip at maximum size the meta device can support */
1758 s = min_t(sector_t, s,
1759 BM_EXT_TO_SECT(bdev->md.md_size_sect
1760 - bdev->md.bm_offset));
1761 break;
1762 default:
1763 s = min_t(sector_t, DRBD_MAX_SECTORS,
1764 drbd_get_capacity(bdev->backing_bdev));
1765 }
1766 return s;
1767}
1768
1769/**
1770 * drbd_md_ss__() - Return the sector number of our meta data super block
1771 * @mdev: DRBD device.
1772 * @bdev: Meta data block device.
1773 */
1774static inline sector_t drbd_md_ss__(struct drbd_conf *mdev,
1775 struct drbd_backing_dev *bdev)
1776{
1777 switch (bdev->dc.meta_dev_idx) {
1778 default: /* external, some index */
1779 return MD_RESERVED_SECT * bdev->dc.meta_dev_idx;
1780 case DRBD_MD_INDEX_INTERNAL:
1781 /* with drbd08, internal meta data is always "flexible" */
1782 case DRBD_MD_INDEX_FLEX_INT:
1783 /* sizeof(struct md_on_disk_07) == 4k
1784 * position: last 4k aligned block of 4k size */
1785 if (!bdev->backing_bdev) {
1786 if (__ratelimit(&drbd_ratelimit_state)) {
1787 dev_err(DEV, "bdev->backing_bdev==NULL\n");
1788 dump_stack();
1789 }
1790 return 0;
1791 }
1792 return (drbd_get_capacity(bdev->backing_bdev) & ~7ULL)
1793 - MD_AL_OFFSET;
1794 case DRBD_MD_INDEX_FLEX_EXT:
1795 return 0;
1796 }
1797}
1798
1799static inline void
Philipp Reisnerb411b362009-09-25 16:07:19 -07001800drbd_queue_work_front(struct drbd_work_queue *q, struct drbd_work *w)
1801{
1802 unsigned long flags;
1803 spin_lock_irqsave(&q->q_lock, flags);
1804 list_add(&w->list, &q->q);
1805 up(&q->s); /* within the spinlock,
1806 see comment near end of drbd_worker() */
1807 spin_unlock_irqrestore(&q->q_lock, flags);
1808}
1809
1810static inline void
1811drbd_queue_work(struct drbd_work_queue *q, struct drbd_work *w)
1812{
1813 unsigned long flags;
1814 spin_lock_irqsave(&q->q_lock, flags);
1815 list_add_tail(&w->list, &q->q);
1816 up(&q->s); /* within the spinlock,
1817 see comment near end of drbd_worker() */
1818 spin_unlock_irqrestore(&q->q_lock, flags);
1819}
1820
Philipp Reisner0625ac12011-02-07 14:49:19 +01001821static inline void wake_asender(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001822{
Philipp Reisner0625ac12011-02-07 14:49:19 +01001823 if (test_bit(SIGNAL_ASENDER, &tconn->flags))
1824 force_sig(DRBD_SIG, tconn->asender.task);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001825}
1826
Philipp Reisner0625ac12011-02-07 14:49:19 +01001827static inline void request_ping(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001828{
Philipp Reisner0625ac12011-02-07 14:49:19 +01001829 set_bit(SEND_PING, &tconn->flags);
1830 wake_asender(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001831}
1832
Andreas Gruenbacherdba58582011-03-29 16:55:40 +02001833extern void *conn_prepare_command(struct drbd_tconn *, struct drbd_socket *);
1834extern void *drbd_prepare_command(struct drbd_conf *, struct drbd_socket *);
1835extern int conn_send_command(struct drbd_tconn *, struct drbd_socket *,
1836 enum drbd_packet, unsigned int, void *,
1837 unsigned int);
1838extern int drbd_send_command(struct drbd_conf *, struct drbd_socket *,
1839 enum drbd_packet, unsigned int, void *,
1840 unsigned int);
1841
Andreas Gruenbachere307f352011-03-22 10:55:48 +01001842extern int drbd_send_ping(struct drbd_tconn *tconn);
1843extern int drbd_send_ping_ack(struct drbd_tconn *tconn);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001844extern int drbd_send_state_req(struct drbd_conf *, union drbd_state, union drbd_state);
1845extern int conn_send_state_req(struct drbd_tconn *, union drbd_state, union drbd_state);
Philipp Reisnercf29c9d2011-02-11 15:11:24 +01001846
Philipp Reisnerb411b362009-09-25 16:07:19 -07001847static inline void drbd_thread_stop(struct drbd_thread *thi)
1848{
Andreas Gruenbacher81e84652010-12-09 15:03:57 +01001849 _drbd_thread_stop(thi, false, true);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001850}
1851
1852static inline void drbd_thread_stop_nowait(struct drbd_thread *thi)
1853{
Andreas Gruenbacher81e84652010-12-09 15:03:57 +01001854 _drbd_thread_stop(thi, false, false);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001855}
1856
1857static inline void drbd_thread_restart_nowait(struct drbd_thread *thi)
1858{
Andreas Gruenbacher81e84652010-12-09 15:03:57 +01001859 _drbd_thread_stop(thi, true, false);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001860}
1861
1862/* counts how many answer packets packets we expect from our peer,
1863 * for either explicit application requests,
1864 * or implicit barrier packets as necessary.
1865 * increased:
1866 * w_send_barrier
Andreas Gruenbacher8554df12011-01-25 15:37:43 +01001867 * _req_mod(req, QUEUE_FOR_NET_WRITE or QUEUE_FOR_NET_READ);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001868 * it is much easier and equally valid to count what we queue for the
1869 * worker, even before it actually was queued or send.
1870 * (drbd_make_request_common; recovery path on read io-error)
1871 * decreased:
1872 * got_BarrierAck (respective tl_clear, tl_clear_barrier)
Andreas Gruenbacher8554df12011-01-25 15:37:43 +01001873 * _req_mod(req, DATA_RECEIVED)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001874 * [from receive_DataReply]
Andreas Gruenbacher8554df12011-01-25 15:37:43 +01001875 * _req_mod(req, WRITE_ACKED_BY_PEER or RECV_ACKED_BY_PEER or NEG_ACKED)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001876 * [from got_BlockAck (P_WRITE_ACK, P_RECV_ACK)]
1877 * for some reason it is NOT decreased in got_NegAck,
1878 * but in the resulting cleanup code from report_params.
1879 * we should try to remember the reason for that...
Andreas Gruenbacher8554df12011-01-25 15:37:43 +01001880 * _req_mod(req, SEND_FAILED or SEND_CANCELED)
1881 * _req_mod(req, CONNECTION_LOST_WHILE_PENDING)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001882 * [from tl_clear_barrier]
1883 */
1884static inline void inc_ap_pending(struct drbd_conf *mdev)
1885{
1886 atomic_inc(&mdev->ap_pending_cnt);
1887}
1888
Philipp Reisner49559d82011-02-21 14:19:44 +01001889#define ERR_IF_CNT_IS_NEGATIVE(which, func, line) \
1890 if (atomic_read(&mdev->which) < 0) \
Philipp Reisnerb411b362009-09-25 16:07:19 -07001891 dev_err(DEV, "in %s:%d: " #which " = %d < 0 !\n", \
Philipp Reisner49559d82011-02-21 14:19:44 +01001892 func, line, \
1893 atomic_read(&mdev->which))
Philipp Reisnerb411b362009-09-25 16:07:19 -07001894
Philipp Reisner49559d82011-02-21 14:19:44 +01001895#define dec_ap_pending(mdev) _dec_ap_pending(mdev, __FUNCTION__, __LINE__)
1896static inline void _dec_ap_pending(struct drbd_conf *mdev, const char *func, int line)
1897{
1898 if (atomic_dec_and_test(&mdev->ap_pending_cnt))
1899 wake_up(&mdev->misc_wait);
1900 ERR_IF_CNT_IS_NEGATIVE(ap_pending_cnt, func, line);
1901}
Philipp Reisnerb411b362009-09-25 16:07:19 -07001902
1903/* counts how many resync-related answers we still expect from the peer
1904 * increase decrease
1905 * C_SYNC_TARGET sends P_RS_DATA_REQUEST (and expects P_RS_DATA_REPLY)
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001906 * C_SYNC_SOURCE sends P_RS_DATA_REPLY (and expects P_WRITE_ACK with ID_SYNCER)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001907 * (or P_NEG_ACK with ID_SYNCER)
1908 */
1909static inline void inc_rs_pending(struct drbd_conf *mdev)
1910{
1911 atomic_inc(&mdev->rs_pending_cnt);
1912}
1913
Philipp Reisner49559d82011-02-21 14:19:44 +01001914#define dec_rs_pending(mdev) _dec_rs_pending(mdev, __FUNCTION__, __LINE__)
1915static inline void _dec_rs_pending(struct drbd_conf *mdev, const char *func, int line)
1916{
1917 atomic_dec(&mdev->rs_pending_cnt);
1918 ERR_IF_CNT_IS_NEGATIVE(rs_pending_cnt, func, line);
1919}
Philipp Reisnerb411b362009-09-25 16:07:19 -07001920
1921/* counts how many answers we still need to send to the peer.
1922 * increased on
1923 * receive_Data unless protocol A;
1924 * we need to send a P_RECV_ACK (proto B)
1925 * or P_WRITE_ACK (proto C)
1926 * receive_RSDataReply (recv_resync_read) we need to send a P_WRITE_ACK
1927 * receive_DataRequest (receive_RSDataRequest) we need to send back P_DATA
1928 * receive_Barrier_* we need to send a P_BARRIER_ACK
1929 */
1930static inline void inc_unacked(struct drbd_conf *mdev)
1931{
1932 atomic_inc(&mdev->unacked_cnt);
1933}
1934
Philipp Reisner49559d82011-02-21 14:19:44 +01001935#define dec_unacked(mdev) _dec_unacked(mdev, __FUNCTION__, __LINE__)
1936static inline void _dec_unacked(struct drbd_conf *mdev, const char *func, int line)
1937{
1938 atomic_dec(&mdev->unacked_cnt);
1939 ERR_IF_CNT_IS_NEGATIVE(unacked_cnt, func, line);
1940}
Philipp Reisnerb411b362009-09-25 16:07:19 -07001941
Philipp Reisner49559d82011-02-21 14:19:44 +01001942#define sub_unacked(mdev, n) _sub_unacked(mdev, n, __FUNCTION__, __LINE__)
1943static inline void _sub_unacked(struct drbd_conf *mdev, int n, const char *func, int line)
1944{
1945 atomic_sub(n, &mdev->unacked_cnt);
1946 ERR_IF_CNT_IS_NEGATIVE(unacked_cnt, func, line);
1947}
Philipp Reisnerb411b362009-09-25 16:07:19 -07001948
Philipp Reisnerb411b362009-09-25 16:07:19 -07001949/**
1950 * get_ldev() - Increase the ref count on mdev->ldev. Returns 0 if there is no ldev
1951 * @M: DRBD device.
1952 *
1953 * You have to call put_ldev() when finished working with mdev->ldev.
1954 */
1955#define get_ldev(M) __cond_lock(local, _get_ldev_if_state(M,D_INCONSISTENT))
1956#define get_ldev_if_state(M,MINS) __cond_lock(local, _get_ldev_if_state(M,MINS))
1957
1958static inline void put_ldev(struct drbd_conf *mdev)
1959{
Lars Ellenberg1d7734a2010-08-11 21:21:50 +02001960 int i = atomic_dec_return(&mdev->local_cnt);
Lars Ellenberg9a0d9d02011-05-02 11:51:31 +02001961
1962 /* This may be called from some endio handler,
1963 * so we must not sleep here. */
1964
Philipp Reisnerb411b362009-09-25 16:07:19 -07001965 __release(local);
Lars Ellenberg1d7734a2010-08-11 21:21:50 +02001966 D_ASSERT(i >= 0);
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +02001967 if (i == 0) {
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001968 if (mdev->state.disk == D_DISKLESS)
1969 /* even internal references gone, safe to destroy */
1970 drbd_ldev_destroy(mdev);
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +02001971 if (mdev->state.disk == D_FAILED)
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001972 /* all application IO references gone. */
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +02001973 drbd_go_diskless(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001974 wake_up(&mdev->misc_wait);
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +02001975 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001976}
1977
1978#ifndef __CHECKER__
1979static inline int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_state mins)
1980{
1981 int io_allowed;
1982
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001983 /* never get a reference while D_DISKLESS */
1984 if (mdev->state.disk == D_DISKLESS)
1985 return 0;
1986
Philipp Reisnerb411b362009-09-25 16:07:19 -07001987 atomic_inc(&mdev->local_cnt);
1988 io_allowed = (mdev->state.disk >= mins);
1989 if (!io_allowed)
1990 put_ldev(mdev);
1991 return io_allowed;
1992}
1993#else
1994extern int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_state mins);
1995#endif
1996
1997/* you must have an "get_ldev" reference */
1998static inline void drbd_get_syncer_progress(struct drbd_conf *mdev,
1999 unsigned long *bits_left, unsigned int *per_mil_done)
2000{
Lars Ellenberg4b0715f2010-12-14 15:13:04 +01002001 /* this is to break it at compile time when we change that, in case we
2002 * want to support more than (1<<32) bits on a 32bit arch. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002003 typecheck(unsigned long, mdev->rs_total);
2004
2005 /* note: both rs_total and rs_left are in bits, i.e. in
2006 * units of BM_BLOCK_SIZE.
2007 * for the percentage, we don't care. */
2008
Lars Ellenberg439d5952010-11-05 09:52:46 +01002009 if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T)
2010 *bits_left = mdev->ov_left;
2011 else
2012 *bits_left = drbd_bm_total_weight(mdev) - mdev->rs_failed;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002013 /* >> 10 to prevent overflow,
2014 * +1 to prevent division by zero */
2015 if (*bits_left > mdev->rs_total) {
2016 /* doh. maybe a logic bug somewhere.
2017 * may also be just a race condition
2018 * between this and a disconnect during sync.
2019 * for now, just prevent in-kernel buffer overflow.
2020 */
2021 smp_rmb();
2022 dev_warn(DEV, "cs:%s rs_left=%lu > rs_total=%lu (rs_failed %lu)\n",
2023 drbd_conn_str(mdev->state.conn),
2024 *bits_left, mdev->rs_total, mdev->rs_failed);
2025 *per_mil_done = 0;
2026 } else {
Lars Ellenberg4b0715f2010-12-14 15:13:04 +01002027 /* Make sure the division happens in long context.
2028 * We allow up to one petabyte storage right now,
2029 * at a granularity of 4k per bit that is 2**38 bits.
2030 * After shift right and multiplication by 1000,
2031 * this should still fit easily into a 32bit long,
2032 * so we don't need a 64bit division on 32bit arch.
2033 * Note: currently we don't support such large bitmaps on 32bit
2034 * arch anyways, but no harm done to be prepared for it here.
2035 */
2036 unsigned int shift = mdev->rs_total >= (1ULL << 32) ? 16 : 10;
2037 unsigned long left = *bits_left >> shift;
2038 unsigned long total = 1UL + (mdev->rs_total >> shift);
2039 unsigned long tmp = 1000UL - left * 1000UL/total;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002040 *per_mil_done = tmp;
2041 }
2042}
2043
2044
2045/* this throttles on-the-fly application requests
2046 * according to max_buffers settings;
2047 * maybe re-implement using semaphores? */
2048static inline int drbd_get_max_buffers(struct drbd_conf *mdev)
2049{
Philipp Reisner44ed1672011-04-19 17:10:19 +02002050 struct net_conf *nc;
2051 int mxb;
2052
2053 rcu_read_lock();
2054 nc = rcu_dereference(mdev->tconn->net_conf);
2055 mxb = nc ? nc->max_buffers : 1000000; /* arbitrary limit on open requests */
2056 rcu_read_unlock();
2057
Philipp Reisnerb411b362009-09-25 16:07:19 -07002058 return mxb;
2059}
2060
Philipp Reisner37190942010-11-10 12:08:37 +01002061static inline int drbd_state_is_stable(struct drbd_conf *mdev)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002062{
Philipp Reisnerda9fbc22011-03-29 10:52:01 +02002063 union drbd_dev_state s = mdev->state;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002064
2065 /* DO NOT add a default clause, we want the compiler to warn us
2066 * for any newly introduced state we may have forgotten to add here */
2067
2068 switch ((enum drbd_conns)s.conn) {
2069 /* new io only accepted when there is no connection, ... */
2070 case C_STANDALONE:
2071 case C_WF_CONNECTION:
2072 /* ... or there is a well established connection. */
2073 case C_CONNECTED:
2074 case C_SYNC_SOURCE:
2075 case C_SYNC_TARGET:
2076 case C_VERIFY_S:
2077 case C_VERIFY_T:
2078 case C_PAUSED_SYNC_S:
2079 case C_PAUSED_SYNC_T:
Philipp Reisner67531712010-10-27 12:21:30 +02002080 case C_AHEAD:
2081 case C_BEHIND:
Philipp Reisner37190942010-11-10 12:08:37 +01002082 /* transitional states, IO allowed */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002083 case C_DISCONNECTING:
2084 case C_UNCONNECTED:
2085 case C_TIMEOUT:
2086 case C_BROKEN_PIPE:
2087 case C_NETWORK_FAILURE:
2088 case C_PROTOCOL_ERROR:
2089 case C_TEAR_DOWN:
2090 case C_WF_REPORT_PARAMS:
2091 case C_STARTING_SYNC_S:
2092 case C_STARTING_SYNC_T:
Philipp Reisner37190942010-11-10 12:08:37 +01002093 break;
2094
2095 /* Allow IO in BM exchange states with new protocols */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002096 case C_WF_BITMAP_S:
Philipp Reisner31890f42011-01-19 14:12:51 +01002097 if (mdev->tconn->agreed_pro_version < 96)
Philipp Reisner37190942010-11-10 12:08:37 +01002098 return 0;
2099 break;
2100
2101 /* no new io accepted in these states */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002102 case C_WF_BITMAP_T:
2103 case C_WF_SYNC_UUID:
2104 case C_MASK:
2105 /* not "stable" */
2106 return 0;
2107 }
2108
2109 switch ((enum drbd_disk_state)s.disk) {
2110 case D_DISKLESS:
2111 case D_INCONSISTENT:
2112 case D_OUTDATED:
2113 case D_CONSISTENT:
2114 case D_UP_TO_DATE:
2115 /* disk state is stable as well. */
2116 break;
2117
2118 /* no new io accepted during tansitional states */
2119 case D_ATTACHING:
2120 case D_FAILED:
2121 case D_NEGOTIATING:
2122 case D_UNKNOWN:
2123 case D_MASK:
2124 /* not "stable" */
2125 return 0;
2126 }
2127
2128 return 1;
2129}
2130
Philipp Reisner2aebfab2011-03-28 16:48:11 +02002131static inline int drbd_suspended(struct drbd_conf *mdev)
Philipp Reisnerfb22c402010-09-08 23:20:21 +02002132{
Philipp Reisner8e0af252011-03-28 16:18:39 +02002133 struct drbd_tconn *tconn = mdev->tconn;
2134
2135 return tconn->susp || tconn->susp_fen || tconn->susp_nod;
Philipp Reisnerfb22c402010-09-08 23:20:21 +02002136}
2137
Andreas Gruenbacher1b881ef2010-12-13 18:03:38 +01002138static inline bool may_inc_ap_bio(struct drbd_conf *mdev)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002139{
2140 int mxb = drbd_get_max_buffers(mdev);
2141
Philipp Reisner2aebfab2011-03-28 16:48:11 +02002142 if (drbd_suspended(mdev))
Andreas Gruenbacher1b881ef2010-12-13 18:03:38 +01002143 return false;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002144 if (test_bit(SUSPEND_IO, &mdev->flags))
Andreas Gruenbacher1b881ef2010-12-13 18:03:38 +01002145 return false;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002146
2147 /* to avoid potential deadlock or bitmap corruption,
2148 * in various places, we only allow new application io
2149 * to start during "stable" states. */
2150
2151 /* no new io accepted when attaching or detaching the disk */
Philipp Reisner37190942010-11-10 12:08:37 +01002152 if (!drbd_state_is_stable(mdev))
Andreas Gruenbacher1b881ef2010-12-13 18:03:38 +01002153 return false;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002154
2155 /* since some older kernels don't have atomic_add_unless,
2156 * and we are within the spinlock anyways, we have this workaround. */
2157 if (atomic_read(&mdev->ap_bio_cnt) > mxb)
Andreas Gruenbacher1b881ef2010-12-13 18:03:38 +01002158 return false;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002159 if (test_bit(BITMAP_IO, &mdev->flags))
Andreas Gruenbacher1b881ef2010-12-13 18:03:38 +01002160 return false;
2161 return true;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002162}
2163
Lars Ellenberg23361cf2011-03-31 16:36:43 +02002164static inline bool inc_ap_bio_cond(struct drbd_conf *mdev)
Philipp Reisner8869d682010-11-17 18:24:19 +01002165{
Andreas Gruenbacher1b881ef2010-12-13 18:03:38 +01002166 bool rv = false;
Philipp Reisner8869d682010-11-17 18:24:19 +01002167
Philipp Reisner87eeee42011-01-19 14:16:30 +01002168 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacher1b881ef2010-12-13 18:03:38 +01002169 rv = may_inc_ap_bio(mdev);
Philipp Reisner8869d682010-11-17 18:24:19 +01002170 if (rv)
Lars Ellenberg23361cf2011-03-31 16:36:43 +02002171 atomic_inc(&mdev->ap_bio_cnt);
Philipp Reisner87eeee42011-01-19 14:16:30 +01002172 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisner8869d682010-11-17 18:24:19 +01002173
2174 return rv;
2175}
2176
Lars Ellenberg23361cf2011-03-31 16:36:43 +02002177static inline void inc_ap_bio(struct drbd_conf *mdev)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002178{
Philipp Reisnerb411b362009-09-25 16:07:19 -07002179 /* we wait here
2180 * as long as the device is suspended
2181 * until the bitmap is no longer on the fly during connection
2182 * handshake as long as we would exeed the max_buffer limit.
2183 *
2184 * to avoid races with the reconnect code,
2185 * we need to atomic_inc within the spinlock. */
2186
Lars Ellenberg23361cf2011-03-31 16:36:43 +02002187 wait_event(mdev->misc_wait, inc_ap_bio_cond(mdev));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002188}
2189
2190static inline void dec_ap_bio(struct drbd_conf *mdev)
2191{
2192 int mxb = drbd_get_max_buffers(mdev);
2193 int ap_bio = atomic_dec_return(&mdev->ap_bio_cnt);
2194
2195 D_ASSERT(ap_bio >= 0);
2196 /* this currently does wake_up for every dec_ap_bio!
2197 * maybe rather introduce some type of hysteresis?
2198 * e.g. (ap_bio == mxb/2 || ap_bio == 0) ? */
2199 if (ap_bio < mxb)
2200 wake_up(&mdev->misc_wait);
2201 if (ap_bio == 0 && test_bit(BITMAP_IO, &mdev->flags)) {
2202 if (!test_and_set_bit(BITMAP_IO_QUEUED, &mdev->flags))
Philipp Reisnere42325a2011-01-19 13:55:45 +01002203 drbd_queue_work(&mdev->tconn->data.work, &mdev->bm_io_work.w);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002204 }
2205}
2206
Lars Ellenberg62b0da32011-01-20 13:25:21 +01002207static inline int drbd_set_ed_uuid(struct drbd_conf *mdev, u64 val)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002208{
Lars Ellenberg62b0da32011-01-20 13:25:21 +01002209 int changed = mdev->ed_uuid != val;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002210 mdev->ed_uuid = val;
Lars Ellenberg62b0da32011-01-20 13:25:21 +01002211 return changed;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002212}
2213
Philipp Reisnerb411b362009-09-25 16:07:19 -07002214static inline int drbd_queue_order_type(struct drbd_conf *mdev)
2215{
2216 /* sorry, we currently have no working implementation
2217 * of distributed TCQ stuff */
2218#ifndef QUEUE_ORDERED_NONE
2219#define QUEUE_ORDERED_NONE 0
2220#endif
2221 return QUEUE_ORDERED_NONE;
2222}
2223
Philipp Reisnerb411b362009-09-25 16:07:19 -07002224static inline void drbd_md_flush(struct drbd_conf *mdev)
2225{
2226 int r;
2227
Philipp Reisnera8a4e512010-08-25 10:21:04 +02002228 if (test_bit(MD_NO_FUA, &mdev->flags))
Philipp Reisnerb411b362009-09-25 16:07:19 -07002229 return;
2230
Christoph Hellwigdd3932e2010-09-16 20:51:46 +02002231 r = blkdev_issue_flush(mdev->ldev->md_bdev, GFP_KERNEL, NULL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002232 if (r) {
Philipp Reisnera8a4e512010-08-25 10:21:04 +02002233 set_bit(MD_NO_FUA, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002234 dev_err(DEV, "meta data flush failed with status %d, disabling md-flushes\n", r);
2235 }
2236}
2237
2238#endif