drbd_int.h 80.8 KB
Newer Older
Philipp Reisner's avatar
Philipp Reisner committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/*
  drbd_int.h

  This file is part of DRBD by Philipp Reisner and Lars Ellenberg.

  Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
  Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
  Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.

  drbd is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2, or (at your option)
  any later version.

  drbd is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with drbd; see the file COPYING.  If not, write to
  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef _DRBD_INT_H
#define _DRBD_INT_H

Herbert Xu's avatar
Herbert Xu committed
29
#include <crypto/hash.h>
Philipp Reisner's avatar
Philipp Reisner committed
30 31 32
#include <linux/compiler.h>
#include <linux/types.h>
#include <linux/list.h>
33
#include <linux/sched/signal.h>
Philipp Reisner's avatar
Philipp Reisner committed
34 35
#include <linux/bitops.h>
#include <linux/slab.h>
Randy Dunlap's avatar
Randy Dunlap committed
36
#include <linux/ratelimit.h>
Philipp Reisner's avatar
Philipp Reisner committed
37 38 39 40
#include <linux/tcp.h>
#include <linux/mutex.h>
#include <linux/major.h>
#include <linux/blkdev.h>
41
#include <linux/backing-dev.h>
Philipp Reisner's avatar
Philipp Reisner committed
42
#include <linux/genhd.h>
43
#include <linux/idr.h>
44
#include <linux/dynamic_debug.h>
Philipp Reisner's avatar
Philipp Reisner committed
45 46
#include <net/tcp.h>
#include <linux/lru_cache.h>
47
#include <linux/prefetch.h>
48
#include <linux/drbd_genl_api.h>
49
#include <linux/drbd.h>
50
#include "drbd_strings.h"
51
#include "drbd_state.h"
52
#include "drbd_protocol.h"
Philipp Reisner's avatar
Philipp Reisner committed
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

#ifdef __CHECKER__
# define __protected_by(x)       __attribute__((require_context(x,1,999,"rdwr")))
# define __protected_read_by(x)  __attribute__((require_context(x,1,999,"read")))
# define __protected_write_by(x) __attribute__((require_context(x,1,999,"write")))
# define __must_hold(x)       __attribute__((context(x,1,1), require_context(x,1,999,"call")))
#else
# define __protected_by(x)
# define __protected_read_by(x)
# define __protected_write_by(x)
# define __must_hold(x)
#endif

/* module parameter, defined in drbd_main.c */
extern unsigned int minor_count;
68 69
extern bool disable_sendpage;
extern bool allow_oos;
70
void tl_abort_disk_io(struct drbd_device *device);
Philipp Reisner's avatar
Philipp Reisner committed
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

#ifdef CONFIG_DRBD_FAULT_INJECTION
extern int enable_faults;
extern int fault_rate;
extern int fault_devs;
#endif

extern char usermode_helper[];


/* This is used to stop/restart our threads.
 * Cannot use SIGTERM nor SIGKILL, since these
 * are sent out by init on runlevel changes
 * I choose SIGHUP for now.
 */
#define DRBD_SIGKILL SIGHUP

#define ID_IN_SYNC      (4711ULL)
#define ID_OUT_OF_SYNC  (4712ULL)
#define ID_SYNCER (-1ULL)
91

92
#define UUID_NEW_BM_OFFSET ((u64)0x0001000000000000ULL)
Philipp Reisner's avatar
Philipp Reisner committed
93

94
struct drbd_device;
95
struct drbd_connection;
Philipp Reisner's avatar
Philipp Reisner committed
96

97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
#define __drbd_printk_device(level, device, fmt, args...) \
	dev_printk(level, disk_to_dev((device)->vdisk), fmt, ## args)
#define __drbd_printk_peer_device(level, peer_device, fmt, args...) \
	dev_printk(level, disk_to_dev((peer_device)->device->vdisk), fmt, ## args)
#define __drbd_printk_resource(level, resource, fmt, args...) \
	printk(level "drbd %s: " fmt, (resource)->name, ## args)
#define __drbd_printk_connection(level, connection, fmt, args...) \
	printk(level "drbd %s: " fmt, (connection)->resource->name, ## args)

void drbd_printk_with_wrong_object_type(void);

#define __drbd_printk_if_same_type(obj, type, func, level, fmt, args...) \
	(__builtin_types_compatible_p(typeof(obj), type) || \
	 __builtin_types_compatible_p(typeof(obj), const type)), \
	func(level, (const type)(obj), fmt, ## args)

#define drbd_printk(level, obj, fmt, args...) \
	__builtin_choose_expr( \
	  __drbd_printk_if_same_type(obj, struct drbd_device *, \
			     __drbd_printk_device, level, fmt, ## args), \
	  __builtin_choose_expr( \
	    __drbd_printk_if_same_type(obj, struct drbd_resource *, \
			       __drbd_printk_resource, level, fmt, ## args), \
	    __builtin_choose_expr( \
	      __drbd_printk_if_same_type(obj, struct drbd_connection *, \
				 __drbd_printk_connection, level, fmt, ## args), \
	      __builtin_choose_expr( \
		__drbd_printk_if_same_type(obj, struct drbd_peer_device *, \
				 __drbd_printk_peer_device, level, fmt, ## args), \
		drbd_printk_with_wrong_object_type()))))

#define drbd_dbg(obj, fmt, args...) \
	drbd_printk(KERN_DEBUG, obj, fmt, ## args)
#define drbd_alert(obj, fmt, args...) \
	drbd_printk(KERN_ALERT, obj, fmt, ## args)
#define drbd_err(obj, fmt, args...) \
	drbd_printk(KERN_ERR, obj, fmt, ## args)
#define drbd_warn(obj, fmt, args...) \
	drbd_printk(KERN_WARNING, obj, fmt, ## args)
#define drbd_info(obj, fmt, args...) \
	drbd_printk(KERN_INFO, obj, fmt, ## args)
#define drbd_emerg(obj, fmt, args...) \
	drbd_printk(KERN_EMERG, obj, fmt, ## args)
140 141 142

#define dynamic_drbd_dbg(device, fmt, args...) \
	dynamic_dev_dbg(disk_to_dev(device->vdisk), fmt, ## args)
Philipp Reisner's avatar
Philipp Reisner committed
143

144 145 146 147
#define D_ASSERT(device, exp)	do { \
	if (!(exp)) \
		drbd_err(device, "ASSERT( " #exp " ) in %s:%d\n", __FILE__, __LINE__); \
	} while (0)
Philipp Reisner's avatar
Philipp Reisner committed
148

149 150 151 152 153 154 155 156
/**
 * expect  -  Make an assertion
 *
 * Unlike the assert macro, this macro returns a boolean result.
 */
#define expect(exp) ({								\
		bool _bool = (exp);						\
		if (!_bool)							\
157
			drbd_err(device, "ASSERTION %s FAILED in %s\n",		\
158 159 160
			        #exp, __func__);				\
		_bool;								\
		})
Philipp Reisner's avatar
Philipp Reisner committed
161 162 163 164 165 166 167 168 169 170 171 172

/* Defines to control fault insertion */
enum {
	DRBD_FAULT_MD_WR = 0,	/* meta data write */
	DRBD_FAULT_MD_RD = 1,	/*           read  */
	DRBD_FAULT_RS_WR = 2,	/* resync          */
	DRBD_FAULT_RS_RD = 3,
	DRBD_FAULT_DT_WR = 4,	/* data            */
	DRBD_FAULT_DT_RD = 5,
	DRBD_FAULT_DT_RA = 6,	/* data read ahead */
	DRBD_FAULT_BM_ALLOC = 7,	/* bitmap allocation */
	DRBD_FAULT_AL_EE = 8,	/* alloc ee */
173
	DRBD_FAULT_RECEIVE = 9, /* Changes some bytes upon receiving a [rs]data block */
Philipp Reisner's avatar
Philipp Reisner committed
174 175 176 177 178

	DRBD_FAULT_MAX,
};

extern unsigned int
179
_drbd_insert_fault(struct drbd_device *device, unsigned int type);
180

Philipp Reisner's avatar
Philipp Reisner committed
181
static inline int
182
drbd_insert_fault(struct drbd_device *device, unsigned int type) {
183
#ifdef CONFIG_DRBD_FAULT_INJECTION
Philipp Reisner's avatar
Philipp Reisner committed
184 185
	return fault_rate &&
		(enable_faults & (1<<type)) &&
186
		_drbd_insert_fault(device, type);
Philipp Reisner's avatar
Philipp Reisner committed
187
#else
188
	return 0;
Philipp Reisner's avatar
Philipp Reisner committed
189
#endif
190
}
Philipp Reisner's avatar
Philipp Reisner committed
191 192 193 194 195 196 197

/* integer division, round _UP_ to the next integer */
#define div_ceil(A, B) ((A)/(B) + ((A)%(B) ? 1 : 0))
/* usual integer division */
#define div_floor(A, B) ((A)/(B))

extern struct ratelimit_state drbd_ratelimit_state;
198
extern struct idr drbd_devices; /* RCU, updates: genl_lock() */
199
extern struct list_head drbd_resources; /* RCU, updates: genl_lock() */
Philipp Reisner's avatar
Philipp Reisner committed
200

201
extern const char *cmdname(enum drbd_packet cmd);
Philipp Reisner's avatar
Philipp Reisner committed
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220

/* for sending/receiving the bitmap,
 * possibly in some encoding scheme */
struct bm_xfer_ctx {
	/* "const"
	 * stores total bits and long words
	 * of the bitmap, so we don't need to
	 * call the accessor functions over and again. */
	unsigned long bm_bits;
	unsigned long bm_words;
	/* during xfer, current position within the bitmap */
	unsigned long bit_offset;
	unsigned long word_offset;

	/* statistics; index: (h->command == P_BITMAP) */
	unsigned packets[2];
	unsigned bytes[2];
};

221
extern void INFO_bm_xfer_stats(struct drbd_device *device,
Philipp Reisner's avatar
Philipp Reisner committed
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
		const char *direction, struct bm_xfer_ctx *c);

static inline void bm_xfer_ctx_bit_to_word_offset(struct bm_xfer_ctx *c)
{
	/* word_offset counts "native long words" (32 or 64 bit),
	 * aligned at 64 bit.
	 * Encoded packet may end at an unaligned bit offset.
	 * In case a fallback clear text packet is transmitted in
	 * between, we adjust this offset back to the last 64bit
	 * aligned "native long word", which makes coding and decoding
	 * the plain text bitmap much more convenient.  */
#if BITS_PER_LONG == 64
	c->word_offset = c->bit_offset >> 6;
#elif BITS_PER_LONG == 32
	c->word_offset = c->bit_offset >> 5;
	c->word_offset &= ~(1UL);
#else
# error "unsupported BITS_PER_LONG"
#endif
}

243
extern unsigned int drbd_header_size(struct drbd_connection *connection);
Philipp Reisner's avatar
Philipp Reisner committed
244 245 246

/**********************************************************************/
enum drbd_thread_state {
247 248 249 250
	NONE,
	RUNNING,
	EXITING,
	RESTARTING
Philipp Reisner's avatar
Philipp Reisner committed
251 252 253 254 255 256 257 258
};

struct drbd_thread {
	spinlock_t t_lock;
	struct task_struct *task;
	struct completion stop;
	enum drbd_thread_state t_state;
	int (*function) (struct drbd_thread *);
259
	struct drbd_resource *resource;
260
	struct drbd_connection *connection;
Philipp Reisner's avatar
Philipp Reisner committed
261
	int reset_cpu_mask;
262
	const char *name;
Philipp Reisner's avatar
Philipp Reisner committed
263 264 265 266 267 268 269 270 271 272 273 274 275 276
};

static inline enum drbd_thread_state get_t_state(struct drbd_thread *thi)
{
	/* THINK testing the t_state seems to be uncritical in all cases
	 * (but thread_{start,stop}), so we can read it *without* the lock.
	 *	--lge */

	smp_rmb();
	return thi->t_state;
}

struct drbd_work {
	struct list_head list;
277
	int (*cb)(struct drbd_work *, int cancel);
278 279 280 281 282
};

struct drbd_device_work {
	struct drbd_work w;
	struct drbd_device *device;
Philipp Reisner's avatar
Philipp Reisner committed
283 284
};

285 286
#include "drbd_interval.h"

287
extern int drbd_wait_misc(struct drbd_device *, struct drbd_interval *);
288

289 290 291
extern void lock_all_resources(void);
extern void unlock_all_resources(void);

Philipp Reisner's avatar
Philipp Reisner committed
292 293
struct drbd_request {
	struct drbd_work w;
294
	struct drbd_device *device;
Philipp Reisner's avatar
Philipp Reisner committed
295 296 297 298

	/* if local IO is not allowed, will be NULL.
	 * if local IO _is_ allowed, holds the locally submitted bio clone,
	 * or, after local IO completion, the ERR_PTR(error).
299
	 * see drbd_request_endio(). */
Philipp Reisner's avatar
Philipp Reisner committed
300 301
	struct bio *private_bio;

302
	struct drbd_interval i;
Philipp Reisner's avatar
Philipp Reisner committed
303

304
	/* epoch: used to check on "completion" whether this req was in
Philipp Reisner's avatar
Philipp Reisner committed
305
	 * the current epoch, and we therefore have to close it,
306 307 308 309 310
	 * causing a p_barrier packet to be send, starting a new epoch.
	 *
	 * This corresponds to "barrier" in struct p_barrier[_ack],
	 * and to "barrier_nr" in struct drbd_epoch (and various
	 * comments/function parameters/local variable names).
Philipp Reisner's avatar
Philipp Reisner committed
311
	 */
312
	unsigned int epoch;
Philipp Reisner's avatar
Philipp Reisner committed
313 314 315

	struct list_head tl_requests; /* ring list in the transfer log */
	struct bio *master_bio;       /* master bio pointer */
316

317 318 319 320
	/* see struct drbd_device */
	struct list_head req_pending_master_completion;
	struct list_head req_pending_local;

321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
	/* for generic IO accounting */
	unsigned long start_jif;

	/* for DRBD internal statistics */

	/* Minimal set of time stamps to determine if we wait for activity log
	 * transactions, local disk or peer.  32 bit "jiffies" are good enough,
	 * we don't expect a DRBD request to be stalled for several month.
	 */

	/* before actual request processing */
	unsigned long in_actlog_jif;

	/* local disk */
	unsigned long pre_submit_jif;

	/* per connection */
	unsigned long pre_send_jif;
	unsigned long acked_jif;
	unsigned long net_done_jif;

	/* Possibly even more detail to track each phase:
	 *  master_completion_jif
	 *      how long did it take to complete the master bio
	 *      (application visible latency)
	 *  allocated_jif
	 *      how long the master bio was blocked until we finally allocated
	 *      a tracking struct
	 *  in_actlog_jif
	 *      how long did we wait for activity log transactions
	 *
	 *  net_queued_jif
	 *      when did we finally queue it for sending
	 *  pre_send_jif
	 *      when did we start sending it
	 *  post_send_jif
	 *      how long did we block in the network stack trying to send it
	 *  acked_jif
	 *      when did we receive (or fake, in protocol A) a remote ACK
	 *  net_done_jif
	 *      when did we receive final acknowledgement (P_BARRIER_ACK),
	 *      or decide, e.g. on connection loss, that we do no longer expect
	 *      anything from this peer for this request.
	 *
	 *  pre_submit_jif
	 *  post_sub_jif
	 *      when did we start submiting to the lower level device,
	 *      and how long did we block in that submit function
	 *  local_completion_jif
	 *      how long did it take the lower level device to complete this request
	 */

Philipp Reisner's avatar
Philipp Reisner committed
373

374 375 376 377
	/* once it hits 0, we may complete the master_bio */
	atomic_t completion_ref;
	/* once it hits 0, we may destroy this drbd_request object */
	struct kref kref;
Philipp Reisner's avatar
Philipp Reisner committed
378

379
	unsigned rq_state; /* see comments above _req_mod() */
Philipp Reisner's avatar
Philipp Reisner committed
380 381 382
};

struct drbd_epoch {
383
	struct drbd_connection *connection;
Philipp Reisner's avatar
Philipp Reisner committed
384 385 386 387 388 389 390
	struct list_head list;
	unsigned int barrier_nr;
	atomic_t epoch_size; /* increased on every request added. */
	atomic_t active;     /* increased on every req. added, and dec on every finished. */
	unsigned long flags;
};

391 392 393 394
/* Prototype declaration of function defined in drbd_receiver.c */
int drbdd_init(struct drbd_thread *);
int drbd_asender(struct drbd_thread *);

Philipp Reisner's avatar
Philipp Reisner committed
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
/* drbd_epoch flag bits */
enum {
	DE_HAVE_BARRIER_NUMBER,
};

enum epoch_event {
	EV_PUT,
	EV_GOT_BARRIER_NR,
	EV_BECAME_LAST,
	EV_CLEANUP = 32, /* used as flag */
};

struct digest_info {
	int digest_size;
	void *digest;
};

412
struct drbd_peer_request {
413 414
	struct drbd_work w;
	struct drbd_peer_device *peer_device;
415
	struct drbd_epoch *epoch; /* for writes */
416 417
	struct page *pages;
	atomic_t pending_bios;
418
	struct drbd_interval i;
419 420
	/* see comments on ee flag bits below */
	unsigned long flags;
421
	unsigned long submit_jif;
422 423 424 425
	union {
		u64 block_id;
		struct digest_info *digest;
	};
426 427 428 429 430 431 432 433
};

/* ee flag bits.
 * While corresponding bios are in flight, the only modification will be
 * set_bit WAS_ERROR, which has to be atomic.
 * If no bios are in flight yet, or all have been completed,
 * non-atomic modification to ee->flags is ok.
 */
Philipp Reisner's avatar
Philipp Reisner committed
434 435 436
enum {
	__EE_CALL_AL_COMPLETE_IO,
	__EE_MAY_SET_IN_SYNC,
437

438 439 440
	/* is this a TRIM aka REQ_DISCARD? */
	__EE_IS_TRIM,

441 442 443 444
	/* In case a barrier failed,
	 * we need to resubmit without the barrier flag. */
	__EE_RESUBMITTED,

445
	/* we may have several bios per peer request.
446 447 448
	 * if any of those fail, we set this flag atomically
	 * from the endio callback */
	__EE_WAS_ERROR,
449 450 451

	/* This ee has a pointer to a digest instead of a block id */
	__EE_HAS_DIGEST,
452 453 454

	/* Conflicting local requests need to be restarted after this request */
	__EE_RESTART_REQUESTS,
455 456 457

	/* The peer wants a write ACK for this (wire proto C) */
	__EE_SEND_WRITE_ACK,
458 459 460

	/* Is set when net_conf had two_primaries set while creating this peer_req */
	__EE_IN_INTERVAL_TREE,
461 462 463 464 465 466 467 468

	/* for debugfs: */
	/* has this been submitted, or does it still wait for something else? */
	__EE_SUBMITTED,

	/* this is/was a write request */
	__EE_WRITE,

469 470 471
	/* this is/was a write same request */
	__EE_WRITE_SAME,

472 473 474
	/* this originates from application on peer
	 * (not some resync or verify or other DRBD internal request) */
	__EE_APPLICATION,
475 476 477

	/* If it contains only 0 bytes, send back P_RS_DEALLOCATED */
	__EE_RS_THIN_REQ,
Philipp Reisner's avatar
Philipp Reisner committed
478 479 480
};
#define EE_CALL_AL_COMPLETE_IO (1<<__EE_CALL_AL_COMPLETE_IO)
#define EE_MAY_SET_IN_SYNC     (1<<__EE_MAY_SET_IN_SYNC)
481 482
#define EE_IS_TRIM             (1<<__EE_IS_TRIM)
#define EE_RESUBMITTED         (1<<__EE_RESUBMITTED)
483
#define EE_WAS_ERROR           (1<<__EE_WAS_ERROR)
484
#define EE_HAS_DIGEST          (1<<__EE_HAS_DIGEST)
485
#define EE_RESTART_REQUESTS	(1<<__EE_RESTART_REQUESTS)
486
#define EE_SEND_WRITE_ACK	(1<<__EE_SEND_WRITE_ACK)
487
#define EE_IN_INTERVAL_TREE	(1<<__EE_IN_INTERVAL_TREE)
488 489
#define EE_SUBMITTED		(1<<__EE_SUBMITTED)
#define EE_WRITE		(1<<__EE_WRITE)
490
#define EE_WRITE_SAME		(1<<__EE_WRITE_SAME)
491
#define EE_APPLICATION		(1<<__EE_APPLICATION)
492
#define EE_RS_THIN_REQ		(1<<__EE_RS_THIN_REQ)
Philipp Reisner's avatar
Philipp Reisner committed
493

494
/* flag bits per device */
Philipp Reisner's avatar
Philipp Reisner committed
495 496 497 498 499 500 501 502 503 504 505
enum {
	UNPLUG_REMOTE,		/* sending a "UnplugRemote" could help */
	MD_DIRTY,		/* current uuids and flags not yet on disk */
	USE_DEGR_WFC_T,		/* degr-wfc-timeout instead of wfc-timeout. */
	CL_ST_CHG_SUCCESS,
	CL_ST_CHG_FAIL,
	CRASHED_PRIMARY,	/* This node was a crashed primary.
				 * Gets cleared when the state.conn
				 * goes into C_CONNECTED state. */
	CONSIDER_RESYNC,

506
	MD_NO_FUA,		/* Users wants us to not use FUA/FLUSH on meta data dev */
507

Philipp Reisner's avatar
Philipp Reisner committed
508 509 510
	BITMAP_IO,		/* suspend application io;
				   once no more io in flight, start bitmap io */
	BITMAP_IO_QUEUED,       /* Started bitmap IO */
511 512
	WAS_IO_ERROR,		/* Local disk failed, returned IO error */
	WAS_READ_ERROR,		/* Local disk READ failed (set additionally to the above) */
513
	FORCE_DETACH,		/* Force-detach from local disk, aborting any pending local IO */
Philipp Reisner's avatar
Philipp Reisner committed
514 515 516
	RESYNC_AFTER_NEG,       /* Resync after online grow after the attach&negotiate finished. */
	RESIZE_PENDING,		/* Size change detected locally, waiting for the response from
				 * the peer, if it changed there as well. */
517
	NEW_CUR_UUID,		/* Create new current UUID when thawing IO */
518
	AL_SUSPENDED,		/* Activity logging is currently suspended. */
519
	AHEAD_TO_SYNC_SOURCE,   /* Ahead -> SyncSource queued */
520
	B_RS_H_DONE,		/* Before resync handler done (already executed) */
521
	DISCARD_MY_DATA,	/* discard_my_data flag per volume */
522
	READ_BALANCE_RR,
523

524 525 526
	FLUSH_PENDING,		/* if set, device->flush_jif is when we submitted that flush
				 * from drbd_flush_after_epoch() */

527 528 529 530 531 532
	/* cleared only after backing device related structures have been destroyed. */
	GOING_DISKLESS,		/* Disk is being detached, because of io-error, or admin request. */

	/* to be used in drbd_device_post_work() */
	GO_DISKLESS,		/* tell worker to schedule cleanup before detach */
	DESTROY_DISK,		/* tell worker to close backing devices and destroy related structures. */
533 534
	MD_SYNC,		/* tell worker to call drbd_md_sync() */
	RS_START,		/* tell worker to start resync/OV */
535 536
	RS_PROGRESS,		/* tell worker that resync made significant progress */
	RS_DONE,		/* tell worker that resync is done */
Philipp Reisner's avatar
Philipp Reisner committed
537 538
};

539
struct drbd_bitmap; /* opaque for drbd_device */
Philipp Reisner's avatar
Philipp Reisner committed
540

541 542 543 544
/* definition of bits in bm_flags to be used in drbd_bm_lock
 * and drbd_bitmap_io and friends. */
enum bm_flag {
	/* currently locked for bulk operation */
545
	BM_LOCKED_MASK = 0xf,
546 547 548 549 550 551

	/* in detail, that is: */
	BM_DONT_CLEAR = 0x1,
	BM_DONT_SET   = 0x2,
	BM_DONT_TEST  = 0x4,

552 553 554 555
	/* so we can mark it locked for bulk operation,
	 * and still allow all non-bulk operations */
	BM_IS_LOCKED  = 0x8,

556
	/* (test bit, count bit) allowed (common case) */
557
	BM_LOCKED_TEST_ALLOWED = BM_DONT_CLEAR | BM_DONT_SET | BM_IS_LOCKED,
558 559 560 561

	/* testing bits, as well as setting new bits allowed, but clearing bits
	 * would be unexpected.  Used during bitmap receive.  Setting new bits
	 * requires sending of "out-of-sync" information, though. */
562
	BM_LOCKED_SET_ALLOWED = BM_DONT_CLEAR | BM_IS_LOCKED,
563

564 565 566
	/* for drbd_bm_write_copy_pages, everything is allowed,
	 * only concurrent bulk operations are locked out. */
	BM_LOCKED_CHANGE_ALLOWED = BM_IS_LOCKED,
567 568
};

Philipp Reisner's avatar
Philipp Reisner committed
569 570 571
struct drbd_work_queue {
	struct list_head q;
	spinlock_t q_lock;  /* to protect the list. */
572
	wait_queue_head_t q_wait;
Philipp Reisner's avatar
Philipp Reisner committed
573 574 575 576 577 578 579
};

struct drbd_socket {
	struct mutex mutex;
	struct socket    *socket;
	/* this way we get our
	 * send/receive buffers off the stack */
580
	void *sbuf;
581
	void *rbuf;
Philipp Reisner's avatar
Philipp Reisner committed
582 583 584 585 586 587
};

struct drbd_md {
	u64 md_offset;		/* sector offset to 'super' block */

	u64 la_size_sect;	/* last agreed size, unit sectors */
588
	spinlock_t uuid_lock;
Philipp Reisner's avatar
Philipp Reisner committed
589 590 591 592 593
	u64 uuid[UI_SIZE];
	u64 device_uuid;
	u32 flags;
	u32 md_size_sect;

594
	s32 al_offset;	/* signed relative sector offset to activity log */
Philipp Reisner's avatar
Philipp Reisner committed
595
	s32 bm_offset;	/* signed relative sector offset to bitmap */
596 597 598 599 600 601 602 603

	/* cached value of bdev->disk_conf->meta_dev_idx (see below) */
	s32 meta_dev_idx;

	/* see al_tr_number_to_on_disk_sector() */
	u32 al_stripes;
	u32 al_stripe_size_4k;
	u32 al_size_4k; /* cached product of the above */
Philipp Reisner's avatar
Philipp Reisner committed
604 605 606 607 608 609
};

struct drbd_backing_dev {
	struct block_device *backing_bdev;
	struct block_device *md_bdev;
	struct drbd_md md;
610
	struct disk_conf *disk_conf; /* RCU, for updates: resource->conf_update */
Philipp Reisner's avatar
Philipp Reisner committed
611 612 613 614
	sector_t known_size; /* last known size of that backing device */
};

struct drbd_md_io {
615 616 617 618 619
	struct page *page;
	unsigned long start_jif;	/* last call to drbd_md_get_buffer */
	unsigned long submit_jif;	/* last _drbd_md_sync_page_io() submit */
	const char *current_use;
	atomic_t in_use;
620
	unsigned int done;
Philipp Reisner's avatar
Philipp Reisner committed
621 622 623 624 625 626
	int error;
};

struct bm_io_work {
	struct drbd_work w;
	char *why;
627
	enum bm_flag flags;
628 629
	int (*io_fn)(struct drbd_device *device);
	void (*done)(struct drbd_device *device, int rv);
Philipp Reisner's avatar
Philipp Reisner committed
630 631
};

632 633 634
struct fifo_buffer {
	unsigned int head_index;
	unsigned int size;
635 636
	int total; /* sum of all values */
	int values[0];
637
};
638
extern struct fifo_buffer *fifo_alloc(int fifo_size);
639

640
/* flag bits per connection */
641 642
enum {
	NET_CONGESTED,		/* The data socket is congested */
643
	RESOLVE_CONFLICTS,	/* Set on one node, cleared on the peer! */
644
	SEND_PING,
645
	GOT_PING_ACK,		/* set when we receive a ping_ack packet, ping_wait gets woken */
646
	CONN_WD_ST_CHG_REQ,	/* A cluster wide state change on the connection is active */
647 648
	CONN_WD_ST_CHG_OKAY,
	CONN_WD_ST_CHG_FAIL,
649
	CONN_DRY_RUN,		/* Expect disconnect after resync handshake. */
650
	CREATE_BARRIER,		/* next P_DATA is preceded by a P_BARRIER */
651
	STATE_SENT,		/* Do not change state/UUIDs while this is set */
652 653 654 655 656 657
	CALLBACK_PENDING,	/* Whether we have a call_usermodehelper(, UMH_WAIT_PROC)
				 * pending, from drbd worker context.
				 * If set, bdi_write_congested() returns true,
				 * so shrink_page_list() would not recurse into,
				 * and potentially deadlock on, this drbd worker.
				 */
658
	DISCONNECT_SENT,
659 660

	DEVICE_WORK_PENDING,	/* tell worker that some device has pending work */
661 662
};

663 664
enum which_state { NOW, OLD = NOW, NEW };

665 666
struct drbd_resource {
	char *name;
667 668 669 670 671 672
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_res;
	struct dentry *debugfs_res_volumes;
	struct dentry *debugfs_res_connections;
	struct dentry *debugfs_res_in_flight_summary;
#endif
673
	struct kref kref;
674
	struct idr devices;		/* volume number to device mapping */
675 676
	struct list_head connections;
	struct list_head resources;
677
	struct res_opts res_opts;
678
	struct mutex conf_update;	/* mutex for ready-copy-update of net_conf and disk_conf */
679
	struct mutex adm_mutex;		/* mutex to serialize administrative requests */
680
	spinlock_t req_lock;
681 682 683 684

	unsigned susp:1;		/* IO suspended by user */
	unsigned susp_nod:1;		/* IO suspended because no data */
	unsigned susp_fen:1;		/* IO suspended because fence peer handler runs */
685

686 687
	enum write_ordering_e write_ordering;

688
	cpumask_var_t cpu_mask;
689 690
};

691 692 693 694 695 696 697 698 699
struct drbd_thread_timing_details
{
	unsigned long start_jif;
	void *cb_addr;
	const char *caller_fn;
	unsigned int line;
	unsigned int cb_nr;
};

700 701 702
struct drbd_connection {
	struct list_head connections;
	struct drbd_resource *resource;
703 704 705 706 707
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_conn;
	struct dentry *debugfs_conn_callback_history;
	struct dentry *debugfs_conn_oldest_requests;
#endif
708
	struct kref kref;
709
	struct idr peer_devices;	/* volume number to peer device mapping */
710 711
	enum drbd_conns cstate;		/* Only C_STANDALONE to C_WF_REPORT_PARAMS */
	struct mutex cstate_mutex;	/* Protects graceful disconnects */
712
	unsigned int connect_cnt;	/* Inc each time a connection is established */
713

714
	unsigned long flags;
715
	struct net_conf *net_conf;	/* content protected by rcu */
716
	wait_queue_head_t ping_wait;	/* Woken upon reception of a ping, and a state change */
717

718 719 720 721 722
	struct sockaddr_storage my_addr;
	int my_addr_len;
	struct sockaddr_storage peer_addr;
	int peer_addr_len;

723 724
	struct drbd_socket data;	/* data/barrier/cstate/parameter packets */
	struct drbd_socket meta;	/* ping/ack (metadata) packets */
725
	int agreed_pro_version;		/* actually used protocol version */
726
	u32 agreed_features;
727 728
	unsigned long last_received;	/* in jiffies, either socket */
	unsigned int ko_count;
729

730
	struct list_head transfer_log;	/* all requests not yet fully processed */
731

Herbert Xu's avatar
Herbert Xu committed
732 733 734 735 736
	struct crypto_shash *cram_hmac_tfm;
	struct crypto_ahash *integrity_tfm;  /* checksums we compute, updates protected by connection->data->mutex */
	struct crypto_ahash *peer_integrity_tfm;  /* checksums we verify, only accessed from receiver thread  */
	struct crypto_ahash *csums_tfm;
	struct crypto_ahash *verify_tfm;
737 738 739
	void *int_dig_in;
	void *int_dig_vv;

740
	/* receiver side */
741 742 743
	struct drbd_epoch *current_epoch;
	spinlock_t epoch_lock;
	unsigned int epochs;
744
	atomic_t current_tle_nr;	/* transfer log epoch number */
745
	unsigned current_tle_writes;	/* writes seen within this tl epoch */
746

747
	unsigned long last_reconnect_jif;
748 749
	struct drbd_thread receiver;
	struct drbd_thread worker;
750
	struct drbd_thread ack_receiver;
751
	struct workqueue_struct *ack_sender;
752

753 754 755 756 757 758 759
	/* cached pointers,
	 * so we can look up the oldest pending requests more quickly.
	 * protected by resource->req_lock */
	struct drbd_request *req_next; /* DRBD 9: todo.req_next */
	struct drbd_request *req_ack_pending;
	struct drbd_request *req_not_net_done;

760
	/* sender side */
761
	struct drbd_work_queue sender_work;
762

763 764 765 766 767 768
#define DRBD_THREAD_DETAILS_HIST	16
	unsigned int w_cb_nr; /* keeps counting up */
	unsigned int r_cb_nr; /* keeps counting up */
	struct drbd_thread_timing_details w_timing_details[DRBD_THREAD_DETAILS_HIST];
	struct drbd_thread_timing_details r_timing_details[DRBD_THREAD_DETAILS_HIST];

769
	struct {
770 771
		unsigned long last_sent_barrier_jif;

772 773 774 775 776 777 778 779 780 781 782 783
		/* whether this sender thread
		 * has processed a single write yet. */
		bool seen_any_write_yet;

		/* Which barrier number to send with the next P_BARRIER */
		int current_epoch_nr;

		/* how many write requests have been sent
		 * with req->epoch == current_epoch_nr.
		 * If none, no P_BARRIER will be sent. */
		unsigned current_epoch_writes;
	} send;
784 785
};

786 787 788 789 790 791 792 793 794 795 796
static inline bool has_net_conf(struct drbd_connection *connection)
{
	bool has_net_conf;

	rcu_read_lock();
	has_net_conf = rcu_dereference(connection->net_conf);
	rcu_read_unlock();

	return has_net_conf;
}

797 798 799 800 801 802 803 804 805 806 807
void __update_timing_details(
		struct drbd_thread_timing_details *tdp,
		unsigned int *cb_nr,
		void *cb,
		const char *fn, const unsigned int line);

#define update_worker_timing_details(c, cb) \
	__update_timing_details(c->w_timing_details, &c->w_cb_nr, cb, __func__ , __LINE__ )
#define update_receiver_timing_details(c, cb) \
	__update_timing_details(c->r_timing_details, &c->r_cb_nr, cb, __func__ , __LINE__ )

808 809 810 811
struct submit_worker {
	struct workqueue_struct *wq;
	struct work_struct worker;

812
	/* protected by ..->resource->req_lock */
813 814 815
	struct list_head writes;
};

816 817 818
struct drbd_peer_device {
	struct list_head peer_devices;
	struct drbd_device *device;
819
	struct drbd_connection *connection;
820
	struct work_struct send_acks_work;
821 822 823
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_peer_dev;
#endif
824 825 826
};

struct drbd_device {
827
	struct drbd_resource *resource;
828
	struct list_head peer_devices;
829
	struct list_head pending_bitmap_io;
830 831 832 833 834 835 836 837 838

	unsigned long flush_jif;
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_minor;
	struct dentry *debugfs_vol;
	struct dentry *debugfs_vol_oldest_requests;
	struct dentry *debugfs_vol_act_log_extents;
	struct dentry *debugfs_vol_resync_extents;
	struct dentry *debugfs_vol_data_gen_id;
839
	struct dentry *debugfs_vol_ed_gen_id;
840 841 842 843 844
#endif

	unsigned int vnr;	/* volume number within the connection */
	unsigned int minor;	/* device minor number */

845
	struct kref kref;
846

Philipp Reisner's avatar
Philipp Reisner committed
847 848 849 850 851 852 853 854 855 856 857
	/* things that are stored as / read from meta data on disk */
	unsigned long flags;

	/* configured by drbdsetup */
	struct drbd_backing_dev *ldev __protected_by(local);

	sector_t p_size;     /* partner's disk size */
	struct request_queue *rq_queue;
	struct block_device *this_bdev;
	struct gendisk	    *vdisk;

858
	unsigned long last_reattach_jif;
859 860
	struct drbd_work resync_work;
	struct drbd_work unplug_work;
Philipp Reisner's avatar
Philipp Reisner committed
861 862
	struct timer_list resync_timer;
	struct timer_list md_sync_timer;
863
	struct timer_list start_resync_timer;
864
	struct timer_list request_timer;
Philipp Reisner's avatar
Philipp Reisner committed
865 866 867 868

	/* Used after attach while negotiating new disk state. */
	union drbd_state new_state_tmp;

869
	union drbd_dev_state state;
Philipp Reisner's avatar
Philipp Reisner committed
870 871 872 873 874 875 876 877 878
	wait_queue_head_t misc_wait;
	wait_queue_head_t state_wait;  /* upon each state change. */
	unsigned int send_cnt;
	unsigned int recv_cnt;
	unsigned int read_cnt;
	unsigned int writ_cnt;
	unsigned int al_writ_cnt;
	unsigned int bm_writ_cnt;
	atomic_t ap_bio_cnt;	 /* Requests we need to complete */
879
	atomic_t ap_actlog_cnt;  /* Requests waiting for activity log */
Philipp Reisner's avatar
Philipp Reisner committed
880 881
	atomic_t ap_pending_cnt; /* AP data packets on the wire, ack expected */
	atomic_t rs_pending_cnt; /* RS request/data packets on the wire */
882
	atomic_t unacked_cnt;	 /* Need to send replies for */
Philipp Reisner's avatar
Philipp Reisner committed
883
	atomic_t local_cnt;	 /* Waiting for local completion */
884
	atomic_t suspend_cnt;
885

886 887
	/* Interval tree of pending local requests */
	struct rb_root read_requests;
888
	struct rb_root write_requests;
Philipp Reisner's avatar
Philipp Reisner committed
889

890 891 892 893 894
	/* for statistics and timeouts */
	/* [0] read, [1] write */
	struct list_head pending_master_completion[2];
	struct list_head pending_completion[2];

895 896
	/* use checksums for *this* resync */
	bool use_csums;
897
	/* blocks to resync in this run [unit BM_BLOCK_SIZE] */
Philipp Reisner's avatar
Philipp Reisner committed
898
	unsigned long rs_total;
899
	/* number of resync blocks that failed in this run */
Philipp Reisner's avatar
Philipp Reisner committed
900 901 902 903 904
	unsigned long rs_failed;
	/* Syncer's start time [unit jiffies] */
	unsigned long rs_start;
	/* cumulated time in PausedSyncX state [unit jiffies] */
	unsigned long rs_paused;
905 906 907 908
	/* skipped because csum was equal [unit BM_BLOCK_SIZE] */
	unsigned long rs_same_csum;
#define DRBD_SYNC_MARKS 8
#define DRBD_SYNC_MARK_STEP (3*HZ)
Philipp Reisner's avatar
Philipp Reisner committed
909
	/* block not up-to-date at mark [unit BM_BLOCK_SIZE] */
910
	unsigned long rs_mark_left[DRBD_SYNC_MARKS];
Philipp Reisner's avatar
Philipp Reisner committed
911
	/* marks's time [unit jiffies] */
912 913 914
	unsigned long rs_mark_time[DRBD_SYNC_MARKS];
	/* current index into rs_mark_{left,time} */
	int rs_last_mark;
915
	unsigned long rs_last_bcast; /* [unit jiffies] */
Philipp Reisner's avatar
Philipp Reisner committed
916 917 918

	/* where does the admin want us to start? (sector) */
	sector_t ov_start_sector;
919
	sector_t ov_stop_sector;
Philipp Reisner's avatar
Philipp Reisner committed
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939
	/* where are we now? (sector) */
	sector_t ov_position;
	/* Start sector of out of sync range (to merge printk reporting). */
	sector_t ov_last_oos_start;
	/* size of out-of-sync range in sectors. */
	sector_t ov_last_oos_size;
	unsigned long ov_left; /* in bits */

	struct drbd_bitmap *bitmap;
	unsigned long bm_resync_fo; /* bit offset for drbd_bm_find_next */

	/* Used to track operations of resync... */
	struct lru_cache *resync;
	/* Number of locked elements in resync LRU */
	unsigned int resync_locked;
	/* resync extent number waiting for application requests */
	unsigned int resync_wenr;

	int open_cnt;
	u64 *p_uuid;
940

941 942
	struct list_head active_ee; /* IO in progress (P_DATA gets written to disk) */
	struct list_head sync_ee;   /* IO in progress (P_RS_DATA_REPLY gets written to disk) */
943 944
	struct list_head done_ee;   /* need to send P_WRITE_ACK */
	struct list_head read_ee;   /* [RS]P_DATA_REQUEST being read */
Philipp Reisner's avatar
Philipp Reisner committed
945 946 947 948
	struct list_head net_ee;    /* zero-copy network send in progress */

	int next_barrier_nr;
	struct list_head resync_reads;
949 950
	atomic_t pp_in_use;		/* allocated from page pool */
	atomic_t pp_in_use_by_net;	/* sendpage()d, still referenced by tcp */
Philipp Reisner's avatar
Philipp Reisner committed
951
	wait_queue_head_t ee_wait;
952
	struct drbd_md_io md_io;
Philipp Reisner's avatar
Philipp Reisner committed
953 954 955 956 957 958 959 960 961 962 963 964
	spinlock_t al_lock;
	wait_queue_head_t al_wait;
	struct lru_cache *act_log;	/* activity log */
	unsigned int al_tr_number;
	int al_tr_cycle;
	wait_queue_head_t seq_wait;
	atomic_t packet_seq;
	unsigned int peer_seq;
	spinlock_t peer_seq_lock;
	unsigned long comm_bm_set; /* communicated number of set bits. */
	struct bm_io_work bm_io_work;
	u64 ed_uuid; /* UUID of the exposed data */
965
	struct mutex own_state_mutex;
966
	struct mutex *state_mutex; /* either own_state_mutex or first_peer_device(device)->connection->cstate_mutex */
Philipp Reisner's avatar
Philipp Reisner committed
967
	char congestion_reason;  /* Why we where congested... */
968 969 970 971 972 973
	atomic_t rs_sect_in; /* for incoming resync data rate, SyncTarget */
	atomic_t rs_sect_ev; /* for submitted resync data rate, both */
	int rs_last_sect_ev; /* counter to compare with */
	int rs_last_events;  /* counter of read or write "events" (unit sectors)
			      * on the lower level device when we last looked. */
	int c_sync_rate; /* current resync rate after syncer throttle magic */
974
	struct fifo_buffer *rs_plan_s; /* correction values of resync planer (RCU, connection->conn_update) */
975
	int rs_in_flight; /* resync sectors in flight (to proxy, in proxy and from proxy) */
976
	atomic_t ap_in_flight; /* App sectors in flight (waiting for ack) */
977 978
	unsigned int peer_max_bio_size;
	unsigned int local_max_bio_size;
979 980 981 982

	/* any requests that would block in drbd_make_request()
	 * are deferred to this single-threaded work queue */
	struct submit_worker submit;
Philipp Reisner's avatar
Philipp Reisner committed
983 984
};

985 986 987 988 989 990 991 992 993 994 995 996 997 998 999
struct drbd_bm_aio_ctx {
	struct drbd_device *device;
	struct list_head list; /* on device->pending_bitmap_io */;
	unsigned long start_jif;
	atomic_t in_flight;
	unsigned int done;
	unsigned flags;
#define BM_AIO_COPY_PAGES	1
#define BM_AIO_WRITE_HINTED	2
#define BM_AIO_WRITE_ALL_PAGES	4
#define BM_AIO_READ		8
	int error;
	struct kref kref;
};

1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
struct drbd_config_context {
	/* assigned from drbd_genlmsghdr */
	unsigned int minor;
	/* assigned from request attributes, if present */
	unsigned int volume;
#define VOLUME_UNSPECIFIED		(-1U)
	/* pointer into the request skb,
	 * limited lifetime! */
	char *resource_name;
	struct nlattr *my_addr;
	struct nlattr *peer_addr;

	/* reply buffer */
	struct sk_buff *reply_skb;
	/* pointer into reply buffer */
	struct drbd_genlmsghdr *reply_dh;
	/* resolved from attributes, if possible */
	struct drbd_device *device;
	struct drbd_resource *resource;
	struct drbd_connection *connection;
};

1022
static inline struct drbd_device *minor_to_device(unsigned int minor)
Philipp Reisner's avatar
Philipp Reisner committed
1023
{
1024
	return (struct drbd_device *)idr_find(&drbd_devices, minor);
Philipp Reisner's avatar
Philipp Reisner committed
1025 1026
}

1027 1028
static inline struct drbd_peer_device *first_peer_device(struct drbd_device *device)
{
1029
	return list_first_entry_or_null(&device->peer_devices, struct drbd_peer_device, peer_devices);
1030 1031
}

1032 1033 1034 1035 1036 1037
static inline struct drbd_peer_device *
conn_peer_device(struct drbd_connection *connection, int volume_number)
{
	return idr_find(&connection->peer_devices, volume_number);
}

1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
#define for_each_resource(resource, _resources) \
	list_for_each_entry(resource, _resources, resources)

#define for_each_resource_rcu(resource, _resources) \
	list_for_each_entry_rcu(resource, _resources, resources)

#define for_each_resource_safe(resource, tmp, _resources) \
	list_for_each_entry_safe(resource, tmp, _resources, resources)

#define for_each_connection(connection, resource) \
	list_for_each_entry(connection, &resource->connections, connections)

#define for_each_connection_rcu(connection, resource) \
	list_for_each_entry_rcu(connection, &resource->connections, connections)

#define for_each_connection_safe(connection, tmp, resource) \
	list_for_each_entry_safe(connection, tmp, &resource->connections, connections)

1056 1057 1058 1059 1060 1061 1062 1063 1064
#define for_each_peer_device(peer_device, device) \
	list_for_each_entry(peer_device, &device->peer_devices, peer_devices)

#define for_each_peer_device_rcu(peer_device, device) \
	list_for_each_entry_rcu(peer_device, &device->peer_devices, peer_devices)

#define for_each_peer_device_safe(peer_device, tmp, device) \
	list_for_each_entry_safe(peer_device, tmp, &device->peer_devices, peer_devices)

1065
static inline unsigned int device_to_minor(struct drbd_device *device)
Philipp Reisner's avatar
Philipp Reisner committed
1066
{
1067
	return device->minor;
Philipp Reisner's avatar
Philipp Reisner committed
1068 1069 1070 1071 1072 1073 1074 1075
}

/*
 * function declarations
 *************************/

/* drbd_main.c */

1076 1077 1078 1079 1080
enum dds_flags {
	DDSF_FORCED    = 1,
	DDSF_NO_RESYNC = 2, /* Do not run a resync for the new space */
};

1081
extern void drbd_init_set_defaults(struct drbd_device *device);
Philipp Reisner's avatar
Philipp Reisner committed
1082 1083 1084
extern int  drbd_thread_start(struct drbd_thread *thi);
extern void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait);
#ifdef CONFIG_SMP
1085
extern void drbd_thread_current_set_cpu(struct drbd_thread *thi);
Philipp Reisner's avatar
Philipp Reisner committed
1086 1087 1088
#else
#define drbd_thread_current_set_cpu(A) ({})
#endif
1089
extern void tl_release(struct drbd_connection *, unsigned int barrier_nr,
Philipp Reisner's avatar
Philipp Reisner committed
1090
		       unsigned int set_size);
1091 1092 1093
extern void tl_clear(struct drbd_connection *);
extern void drbd_free_sock(struct drbd_connection *connection);
extern int drbd_send(struct drbd_connection *connection, struct socket *sock,
1094
		     void *buf, size_t size, unsigned msg_flags);
1095
extern int drbd_send_all(struct drbd_connection *, struct socket *, void *, size_t,
1096 1097
			 unsigned);

1098 1099
extern int __drbd_send_protocol(struct drbd_connection *connection, enum drbd_packet cmd);
extern int drbd_send_protocol(struct drbd_connection *connection);
1100 1101 1102 1103 1104 1105 1106
extern int drbd_send_uuids(struct drbd_peer_device *);
extern int drbd_send_uuids_skip_initial_sync(struct drbd_peer_device *);
extern void drbd_gen_and_send_sync_uuid(struct drbd_peer_device *);
extern int drbd_send_sizes(struct drbd_peer_device *, int trigger_reply, enum dds_flags flags);
extern int drbd_send_state(struct drbd_peer_device *, union drbd_state s);
extern int drbd_send_current_state(struct drbd_peer_device *);
extern int drbd_send_sync_param(struct drbd_peer_device *);
1107
extern void drbd_send_b_ack(struct drbd_connection *connection, u32 barrier_nr,
1108
			    u32 set_size);
1109
extern int drbd_send_ack(struct drbd_peer_device *, enum drbd_packet,
1110
			 struct drbd_peer_request *);
1111
extern void drbd_send_ack_rp(struct drbd_peer_device *, enum drbd_packet,
1112
			     struct p_block_req *rp);
1113
extern void drbd_send_ack_dp(struct drbd_peer_device *, enum drbd_packet,
1114
			     struct p_data *dp, int data_size);
1115
extern int drbd_send_ack_ex(struct drbd_peer_device *, enum drbd_packet,
Philipp Reisner's avatar
Philipp Reisner committed
1116
			    sector_t sector, int blksize, u64 block_id);
1117 1118
extern int drbd_send_out_of_sync(struct drbd_peer_device *, struct drbd_request *);
extern int drbd_send_block(struct drbd_peer_device *, enum drbd_packet,
1119
			   struct drbd_peer_request *);
1120 1121
extern int drbd_send_dblock(struct drbd_peer_device *, struct drbd_request *req);
extern int drbd_send_drequest(struct drbd_peer_device *, int cmd,
Philipp Reisner's avatar
Philipp Reisner committed
1122
			      sector_t sector, int size, u64 block_id);
1123
extern int drbd_send_drequest_csum(struct drbd_peer_device *, sector_t sector,
1124 1125
				   int size, void *digest, int digest_size,
				   enum drbd_packet cmd);
1126
extern int drbd_send_ov_request(struct drbd_peer_device *, sector_t sector, int size);
Philipp Reisner's avatar
Philipp Reisner committed
1127

1128
extern int drbd_send_bitmap(struct drbd_device *device);
1129
extern void drbd_send_sr_reply(struct drbd_peer_device *, enum drbd_state_rv retcode);
1130
extern void conn_send_sr_reply(struct drbd_connection *connection, enum drbd_state_rv retcode);
1131
extern int drbd_send_rs_deallocated(struct drbd_peer_device *, struct drbd_peer_request *);
1132
extern void drbd_backing_dev_free(struct drbd_device *device, struct drbd_backing_dev *ldev);
1133 1134
extern void drbd_device_cleanup(struct drbd_device *device);
void drbd_print_uuids(struct drbd_device *device, const char *text);
Philipp Reisner's avatar
Philipp Reisner committed
1135

1136
extern void conn_md_sync(struct drbd_connection *connection);
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
extern void drbd_md_write(struct drbd_device *device, void *buffer);
extern void drbd_md_sync(struct drbd_device *device);
extern int  drbd_md_read(struct drbd_device *device, struct drbd_backing_dev *bdev);
extern void drbd_uuid_set(struct drbd_device *device, int idx, u64 val) __must_hold(local);
extern void _drbd_uuid_set(struct drbd_device *device, int idx, u64 val) __must_hold(local);
extern void drbd_uuid_new_current(struct drbd_device *device) __must_hold(local);
extern void drbd_uuid_set_bm(struct drbd_device *device, u64 val) __must_hold(local);
extern void drbd_uuid_move_history(struct drbd_device *device) __must_hold(local);
extern void __drbd_uuid_set(struct drbd_device *device, int idx, u64 val) __must_hold(local);
extern void drbd_md_set_flag(struct drbd_device *device, int flags) __must_hold(local);
extern void drbd_md_clear_flag(struct drbd_device *device, int flags)__must_hold(local);
Philipp Reisner's avatar
Philipp Reisner committed
1148
extern int drbd_md_test_flag(struct drbd_backing_dev *, int);
1149 1150
extern void drbd_md_mark_dirty(struct drbd_device *device);
extern void drbd_queue_bitmap_io(struct drbd_device *device,
1151 1152
				 int (*io_fn)(struct drbd_device *),
				 void (*done)(struct drbd_device *, int),
1153
				 char *why, enum bm_flag flags);
1154
extern int drbd_bitmap_io(struct drbd_device *device,
1155
		int (*io_fn)(struct drbd_device *),
1156
		char *why, enum bm_flag flags);
1157
extern int drbd_bitmap_io_from_worker(struct drbd_device *device,
1158
		int (*io_fn)(struct drbd_device *),
1159
		char *why, enum bm_flag flags);
1160 1161
extern int drbd_bmio_set_n_write(struct drbd_device *device) __must_hold(local);
extern int drbd_bmio_clear_n_write(struct drbd_device *device) __must_hold(local);
Philipp Reisner's avatar
Philipp Reisner committed
1162 1163

/* Meta data layout
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
 *
 * We currently have two possible layouts.
 * Offsets in (512 byte) sectors.
 * external:
 *   |----------- md_size_sect ------------------|
 *   [ 4k superblock ][ activity log ][  Bitmap  ]
 *   | al_offset == 8 |
 *   | bm_offset = al_offset + X      |
 *  ==> bitmap sectors = md_size_sect - bm_offset
 *
 *  Variants:
 *     old, indexed fixed size meta data:
 *
 * internal:
 *            |----------- md_size_sect ------------------|
 * [data.....][  Bitmap  ][ activity log ][ 4k superblock ][padding*]
 *                        | al_offset < 0 |
 *            | bm_offset = al_offset - Y |
 *  ==> bitmap sectors = Y = al_offset - bm_offset
 *
 *  [padding*] are zero or up to 7 unused 512 Byte sectors to the
 *  end of the device, so that the [4k superblock] will be 4k aligned.
 *
 *  The activity log consists of 4k transaction blocks,
 *  which are written in a ring-buffer, or striped ring-buffer like fashion,
 *  which are writtensize used to be fixed 32kB,
 *  but is about to become configurable.
 */
Philipp Reisner's avatar
Philipp Reisner committed
1192

1193 1194
/* Our old fixed size meta data layout
 * allows up to about 3.8TB, so if you want more,
1195
 * you need to use the "flexible" meta data format. */
1196 1197 1198
#define MD_128MB_SECT (128LLU << 11)  /* 128 MB, unit sectors */
#define MD_4kB_SECT	 8
#define MD_32kB_SECT	64
1199 1200 1201

/* One activity log extent represents 4M of storage */
#define AL_EXTENT_SHIFT 22
Philipp Reisner's avatar
Philipp Reisner committed
1202 1203
#define AL_EXTENT_SIZE (1<<AL_EXTENT_SHIFT)

1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
/* We could make these currently hardcoded constants configurable
 * variables at create-md time (or even re-configurable at runtime?).
 * Which will require some more changes to the DRBD "super block"
 * and attach code.
 *
 * updates per transaction:
 *   This many changes to the active set can be logged with one transaction.
 *   This number is arbitrary.
 * context per transaction:
 *   This many context extent numbers are logged with each transaction.
 *   This number is resulting from the transaction block size (4k), the layout
 *   of the transaction header, and the number of updates per transaction.
 *   See drbd_actlog.c:struct al_transaction_on_disk
 * */
#define AL_UPDATES_PER_TRANSACTION	 64	// arbitrary
#define AL_CONTEXT_PER_TRANSACTION	919	// (4096 - 36 - 6*64)/4

Philipp Reisner's avatar
Philipp Reisner committed
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
#if BITS_PER_LONG == 32
#define LN2_BPL 5
#define cpu_to_lel(A) cpu_to_le32(A)
#define lel_to_cpu(A) le32_to_cpu(A)
#elif BITS_PER_LONG == 64
#define LN2_BPL 6
#define cpu_to_lel(A) cpu_to_le64(A)
#define lel_to_cpu(A) le64_to_cpu(A)
#else
#error "LN2 of BITS_PER_LONG unknown!"
#endif

/* resync bitmap */
/* 16MB sized 'bitmap extent' to track syncer usage */
struct bm_extent {
	int rs_left; /* number of bits set (out of sync) in this extent. */
	int rs_failed; /* number of failed resync requests in this extent. */
	unsigned long flags;
	struct lc_element lce;
};

#define BME_NO_WRITES  0  /* bm_extent.flags: no more requests on this one! */
#define BME_LOCKED     1  /* bm_extent.flags: syncer active on this one. */
1244
#define BME_PRIORITY   2  /* finish resync IO on this extent ASAP! App IO waiting! */
Philipp Reisner's avatar
Philipp Reisner committed
1245 1246 1247 1248 1249 1250 1251 1252 1253

/* drbd_bitmap.c */
/*
 * We need to store one bit for a block.
 * Example: 1GB disk @ 4096 byte blocks ==> we need 32 KB bitmap.
 * Bit 0 ==> local node thinks this block is binary identical on both nodes
 * Bit 1 ==> local node thinks this block needs to be synced.
 */

1254 1255
#define SLEEP_TIME (HZ/10)

1256 1257 1258
/* We do bitmap IO in units of 4k blocks.
 * We also still have a hardcoded 4k per bit relation. */
#define BM_BLOCK_SHIFT	12			 /* 4k per bit */
Philipp Reisner's avatar
Philipp Reisner committed
1259
#define BM_BLOCK_SIZE	 (1<<BM_BLOCK_SHIFT)
1260 1261 1262 1263
/* mostly arbitrarily set the represented size of one bitmap extent,
 * aka resync extent, to 16 MiB (which is also 512 Byte worth of bitmap
 * at 4k per bit resolution) */
#define BM_EXT_SHIFT	 24	/* 16 MiB per resync extent */
Philipp Reisner's avatar
Philipp Reisner committed
1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
#define BM_EXT_SIZE	 (1<<BM_EXT_SHIFT)

#if (BM_EXT_SHIFT != 24) || (BM_BLOCK_SHIFT != 12)
#error "HAVE YOU FIXED drbdmeta AS WELL??"
#endif

/* thus many _storage_ sectors are described by one bit */
#define BM_SECT_TO_BIT(x)   ((x)>>(BM_BLOCK_SHIFT-9))
#define BM_BIT_TO_SECT(x)   ((sector_t)(x)<<(BM_BLOCK_SHIFT-9))
#define BM_SECT_PER_BIT     BM_BIT_TO_SECT(1)

/* bit to represented kilo byte conversion */
#define Bit2KB(bits) ((bits)<<(BM_BLOCK_SHIFT-10))

/* in which _bitmap_ extent (resp. sector) the bit for a certain
 * _storage_ sector is located in */
#define BM_SECT_TO_EXT(x)   ((x)>>(BM_EXT_SHIFT-9))
1281
#define BM_BIT_TO_EXT(x)    ((x) >> (BM_EXT_SHIFT - BM_BLOCK_SHIFT))
Philipp Reisner's avatar
Philipp Reisner committed
1282

1283
/* first storage sector a bitmap extent corresponds to */
Philipp Reisner's avatar
Philipp Reisner committed
1284
#define BM_EXT_TO_SECT(x)   ((sector_t)(x) << (BM_EXT_SHIFT-9))
1285
/* how much _storage_ sectors we have per bitmap extent */
Philipp Reisner's avatar
Philipp Reisner committed
1286
#define BM_SECT_PER_EXT     BM_EXT_TO_SECT(1)
1287 1288 1289 1290 1291
/* how many bits are covered by one bitmap extent (resync extent) */
#define BM_BITS_PER_EXT     (1UL << (BM_EXT_SHIFT - BM_BLOCK_SHIFT))

#define BM_BLOCKS_PER_BM_EXT_MASK  (BM_BITS_PER_EXT - 1)

Philipp Reisner's avatar
Philipp Reisner committed
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310

/* in one sector of the bitmap, we have this many activity_log extents. */
#define AL_EXT_PER_BM_SECT  (1 << (BM_EXT_SHIFT - AL_EXTENT_SHIFT))

/* the extent in "PER_EXTENT" below is an activity log extent
 * we need that many (long words/bytes) to store the bitmap
 *		     of one AL_EXTENT_SIZE chunk of storage.
 * we can store the bitmap for that many AL_EXTENTS within
 * one sector of the _on_disk_ bitmap:
 * bit	 0	  bit 37   bit 38	     bit (512*8)-1
 *	     ...|........|........|.. // ..|........|
 * sect. 0	 `296	  `304			   ^(512*8*8)-1
 *
#define BM_WORDS_PER_EXT    ( (AL_EXT_SIZE/BM_BLOCK_SIZE) / BITS_PER_LONG )
#define BM_BYTES_PER_EXT    ( (AL_EXT_SIZE/BM_BLOCK_SIZE) / 8 )  // 128
#define BM_EXT_PER_SECT	    ( 512 / BM_BYTES_PER_EXTENT )	 //   4
 */

#define DRBD_MAX_SECTORS_32 (0xffffffffLU)
1311 1312 1313 1314 1315 1316 1317 1318
/* we have a certain meta data variant that has a fixed on-disk size of 128
 * MiB, of which 4k are our "superblock", and 32k are the fixed size activity
 * log, leaving this many sectors for the bitmap.
 */

#define DRBD_MAX_SECTORS_FIXED_BM \
	  ((MD_128MB_SECT - MD_32kB_SECT - MD_4kB_SECT) * (1LL<<(BM_EXT_SHIFT-9)))
#if !defined(CONFIG_LBDAF) && BITS_PER_LONG == 32
Philipp Reisner's avatar
Philipp Reisner committed
1319 1320 1321
#define DRBD_MAX_SECTORS      DRBD_MAX_SECTORS_32
#define DRBD_MAX_SECTORS_FLEX DRBD_MAX_SECTORS_32
#else
1322
#define DRBD_MAX_SECTORS      DRBD_MAX_SECTORS_FIXED_BM
Philipp Reisner's avatar
Philipp Reisner committed
1323 1324 1325 1326 1327 1328 1329
/* 16 TB in units of sectors */
#if BITS_PER_LONG == 32
/* adjust by one page worth of bitmap,
 * so we won't wrap around in drbd_bm_find_next_bit.
 * you should use 64bit OS for that much storage, anyways. */
#define DRBD_MAX_SECTORS_FLEX BM_BIT_TO_SECT(0xffff7fff)
#else
1330 1331 1332
/* we allow up to 1 PiB now on 64bit architecture with "flexible" meta data */
#define DRBD_MAX_SECTORS_FLEX (1UL << 51)
/* corresponds to (1UL << 38) bits right now. */
Philipp Reisner's avatar
Philipp Reisner committed
1333 1334 1335
#endif
#endif

1336
/* Estimate max bio size as 256 * PAGE_SIZE,
1337
 * so for typical PAGE_SIZE of 4k, that is (1<<20) Byte.
1338 1339 1340 1341
 * Since we may live in a mixed-platform cluster,
 * we limit us to a platform agnostic constant here for now.
 * A followup commit may allow even bigger BIO sizes,
 * once we thought that through. */
1342
#define DRBD_MAX_BIO_SIZE (1U << 20)
1343
#if DRBD_MAX_BIO_SIZE > (BIO_MAX_PAGES << PAGE_SHIFT)
1344 1345
#error Architecture not supported: DRBD_MAX_BIO_SIZE > BIO_MAX_SIZE
#endif
1346
#define DRBD_MAX_BIO_SIZE_SAFE (1U << 12)       /* Works always = 4k */
Philipp Reisner's avatar
Philipp Reisner committed
1347

1348 1349
#define DRBD_MAX_SIZE_H80_PACKET (1U << 15) /* Header 80 only allows packets up to 32KiB data */
#define DRBD_MAX_BIO_SIZE_P95    (1U << 17) /* Protocol 95 to 99 allows bios up to 128KiB */
Philipp Reisner's avatar
Philipp Reisner committed
1350

1351 1352 1353
/* For now, don't allow more than half of what we can "activate" in one
 * activity log transaction to be discarded in one go. We may need to rework
 * drbd_al_begin_io() to allow for even larger discard ranges */
1354 1355
#define DRBD_MAX_BATCH_BIO_SIZE	 (AL_UPDATES_PER_TRANSACTION/2*AL_EXTENT_SIZE)
#define DRBD_MAX_BBIO_SECTORS    (DRBD_MAX_BATCH_BIO_SIZE >> 9)
1356

1357 1358 1359 1360 1361
extern int  drbd_bm_init(struct drbd_device *device);
extern int  drbd_bm_resize(struct drbd_device *device, sector_t sectors, int set_new_bits);
extern void drbd_bm_cleanup(struct drbd_device *device);
extern void drbd_bm_set_all(struct drbd_device *device);
extern void drbd_bm_clear_all(struct drbd_device *device);
1362
/* set/clear/test only a few bits at a time */
Philipp Reisner's avatar
Philipp Reisner committed
1363
extern int  drbd_bm_set_bits(
1364
		struct drbd_device *device, unsigned long s, unsigned long e);
Philipp Reisner's avatar
Philipp Reisner committed
1365
extern int  drbd_bm_clear_bits(
1366
		struct drbd_device *device, unsigned long s, unsigned long e);
1367
extern int drbd_bm_count_bits(
1368
	struct drbd_device *device, const unsigned long s, const unsigned long e);
1369 1370
/* bm_set_bits variant for use while holding drbd_bm_lock,
 * may process the whole bitmap in one go */
1371
extern void _drbd_bm_set_bits(struct drbd_device *device,
Philipp Reisner's avatar
Philipp Reisner committed
1372
		const unsigned long s, const unsigned long e);
1373 1374 1375 1376 1377
extern int  drbd_bm_test_bit(struct drbd_device *device, unsigned long bitnr);
extern int  drbd_bm_e_weight(struct drbd_device *device, unsigned long enr);
extern int  drbd_bm_read(struct drbd_device *device) __must_hold(local);
extern void drbd_bm_mark_for_writeout(struct drbd_device *device, int page_nr);
extern int  drbd_bm_write(struct drbd_device *device) __must_hold(local);
1378
extern void drbd_bm_reset_al_hints(struct drbd_device *device) __must_hold(local);
1379
extern int  drbd_bm_write_hinted(struct drbd_device *device) __must_hold(local);
1380
extern int  drbd_bm_write_lazy(struct drbd_device *device, unsigned upper_idx) __must_hold(local);
1381 1382 1383 1384 1385
extern int drbd_bm_write_all(struct drbd_device *device) __must_hold(local);
extern int  drbd_bm_write_copy_pages(struct drbd_device *device) __must_hold(local);
extern size_t	     drbd_bm_words(struct drbd_device *device);
extern unsigned long drbd_bm_bits(struct drbd_device *device);
extern sector_t      drbd_bm_capacity(struct drbd_device *device);
1386 1387

#define DRBD_END_OF_BITMAP	(~(unsigned long)0)
1388
extern unsigned long drbd_bm_find_next(struct drbd_device *device, unsigned long bm_fo);
Philipp Reisner's avatar
Philipp Reisner committed
1389
/* bm_find_next variants for use while you hold drbd_bm_lock() */
1390 1391 1392 1393
extern unsigned long _drbd_bm_find_next(struct drbd_device *device, unsigned long bm_fo);
extern unsigned long _drbd_bm_find_next_zero(struct drbd_device *device, unsigned long bm_fo);
extern unsigned long _drbd_bm_total_weight(struct drbd_device *device);
extern unsigned long drbd_bm_total_weight(struct drbd_device *device);
Philipp Reisner's avatar
Philipp Reisner committed
1394
/* for receive_bitmap */
1395
extern void drbd_bm_merge_lel(struct drbd_device *device, size_t offset,
Philipp Reisner's avatar
Philipp Reisner committed
1396
		size_t number, unsigned long *buffer);
1397
/* for _drbd_send_bitmap */
1398
extern void drbd_bm_get_lel(struct drbd_device *device, size_t offset,
Philipp Reisner's avatar
Philipp Reisner committed
1399 1400
		size_t number, unsigned long *buffer);

1401 1402
extern void drbd_bm_lock(struct drbd_device *device, char *why, enum bm_flag flags);
extern void drbd_bm_unlock(struct drbd_device *device);
Philipp Reisner's avatar
Philipp Reisner committed
1403 1404 1405
/* drbd_main.c */

extern struct kmem_cache *drbd_request_cache;
1406
extern struct kmem_cache *drbd_ee_cache;	/* peer requests */
Philipp Reisner's avatar
Philipp Reisner committed
1407 1408 1409 1410 1411
extern struct kmem_cache *drbd_bm_ext_cache;	/* bitmap extents */
extern struct kmem_cache *drbd_al_ext_cache;	/* activity log extents */
extern mempool_t *drbd_request_mempool;
extern mempool_t *drbd_ee_mempool;

1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
/* drbd's page pool, used to buffer data received from the peer,
 * or data requested by the peer.
 *
 * This does not have an emergency reserve.
 *
 * When allocating from this pool, it first takes pages from the pool.
 * Only if the pool is depleted will try to allocate from the system.
 *
 * The assumption is that pages taken from this pool will be processed,
 * and given back, "quickly", and then can be recycled, so we can avoid
 * frequent calls to alloc_page(), and still will be able to make progress even
 * under memory pressure.
 */
extern struct page *drbd_pp_pool;
Philipp Reisner's avatar
Philipp Reisner committed
1426 1427 1428 1429
extern spinlock_t   drbd_pp_lock;
extern int	    drbd_pp_vacant;
extern wait_queue_head_t drbd_pp_wait;

1430 1431 1432 1433 1434 1435 1436 1437
/* We also need a standard (emergency-reserve backed) page pool
 * for meta data IO (activity log, bitmap).
 * We can keep it global, as long as it is used as "N pages at a time".
 * 128 should be plenty, currently we probably can get away with as few as 1.
 */
#define DRBD_MIN_POOL_PAGES	128
extern mempool_t *drbd_md_io_page_pool;

1438 1439 1440 1441 1442 1443
/* We also need to make sure we get a bio
 * when we need it for housekeeping purposes */
extern struct bio_set *drbd_md_io_bio_set;
/* to allocate from that set */
extern struct bio *bio_alloc_drbd(gfp_t gfp_mask);

1444
extern struct mutex resources_mutex;
Philipp Reisner's avatar
Philipp Reisner committed
1445

1446
extern int conn_lowest_minor(struct drbd_connection *connection);
1447
extern enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsigned int minor);
1448
extern void drbd_destroy_device(struct kref *kref);
1449
extern void drbd_delete_device(struct drbd_device *device);
Philipp Reisner's avatar
Philipp Reisner committed
1450

1451 1452 1453
extern struct drbd_resource *drbd_create_resource(const char *name);
extern void drbd_free_resource(struct drbd_resource *resource);

1454
extern int set_resource_options(struct drbd_resource *resource, struct res_opts *res_opts);
1455
extern struct drbd_connection *conn_create(const char *name, struct res_opts *res_opts);
1456
extern void drbd_destroy_connection(struct kref *kref);
1457
extern struct drbd_connection *conn_get_by_addrs(void *my_addr, int my_addr_len,
1458
					    void *peer_addr, int peer_addr_len);
1459
extern struct drbd_resource *drbd_find_resource(const char *name);
1460
extern void drbd_destroy_resource(struct kref *kref);
1461
extern void conn_free_crypto(struct drbd_connection *connection);
Philipp Reisner's avatar
Philipp Reisner committed
1462 1463 1464 1465

extern int proc_details;

/* drbd_req */
1466
extern void do_submit(struct work_struct *ws);
1467
extern void __drbd_make_request(struct drbd_device *, struct bio *, unsigned long);
1468
extern blk_qc_t drbd_make_request(struct request_queue *q, struct bio *bio);
1469