2009-09-26 03:07:19 +04:00
|
|
|
/*
|
|
|
|
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
|
|
|
|
|
2016-01-24 16:19:21 +03:00
|
|
|
#include <crypto/hash.h>
|
2009-09-26 03:07:19 +04:00
|
|
|
#include <linux/compiler.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/list.h>
|
2017-02-08 20:51:30 +03:00
|
|
|
#include <linux/sched/signal.h>
|
2009-09-26 03:07:19 +04:00
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <linux/slab.h>
|
2009-10-07 21:26:00 +04:00
|
|
|
#include <linux/ratelimit.h>
|
2009-09-26 03:07:19 +04:00
|
|
|
#include <linux/tcp.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/blkdev.h>
|
2015-05-23 00:13:32 +03:00
|
|
|
#include <linux/backing-dev.h>
|
2009-09-26 03:07:19 +04:00
|
|
|
#include <linux/genhd.h>
|
2011-02-08 13:09:18 +03:00
|
|
|
#include <linux/idr.h>
|
2016-08-03 00:03:47 +03:00
|
|
|
#include <linux/dynamic_debug.h>
|
2009-09-26 03:07:19 +04:00
|
|
|
#include <net/tcp.h>
|
|
|
|
#include <linux/lru_cache.h>
|
2011-05-23 00:47:17 +04:00
|
|
|
#include <linux/prefetch.h>
|
2011-03-07 14:49:34 +03:00
|
|
|
#include <linux/drbd_genl_api.h>
|
2011-01-27 16:07:51 +03:00
|
|
|
#include <linux/drbd.h>
|
2011-09-01 15:18:31 +04:00
|
|
|
#include "drbd_strings.h"
|
2011-01-27 16:07:51 +03:00
|
|
|
#include "drbd_state.h"
|
2011-05-30 13:47:37 +04:00
|
|
|
#include "drbd_protocol.h"
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
#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
|
|
|
|
|
2017-08-29 11:20:46 +03:00
|
|
|
/* shared module parameters, defined in drbd_main.c */
|
2009-09-26 03:07:19 +04:00
|
|
|
#ifdef CONFIG_DRBD_FAULT_INJECTION
|
2017-08-29 11:20:46 +03:00
|
|
|
extern int drbd_enable_faults;
|
|
|
|
extern int drbd_fault_rate;
|
2009-09-26 03:07:19 +04:00
|
|
|
#endif
|
|
|
|
|
2017-08-29 11:20:46 +03:00
|
|
|
extern unsigned int drbd_minor_count;
|
2017-08-29 11:20:45 +03:00
|
|
|
extern char drbd_usermode_helper[];
|
2017-08-29 11:20:46 +03:00
|
|
|
extern int drbd_proc_details;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
|
|
|
|
/* 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)
|
2011-01-13 20:40:57 +03:00
|
|
|
|
2011-01-11 19:42:17 +03:00
|
|
|
#define UUID_NEW_BM_OFFSET ((u64)0x0001000000000000ULL)
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-05-30 18:15:21 +04:00
|
|
|
struct drbd_device;
|
2011-05-30 18:32:41 +04:00
|
|
|
struct drbd_connection;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-07-06 12:57:39 +04:00
|
|
|
#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)
|
2011-07-03 19:53:52 +04:00
|
|
|
|
|
|
|
#define dynamic_drbd_dbg(device, fmt, args...) \
|
|
|
|
dynamic_dev_dbg(disk_to_dev(device->vdisk), fmt, ## args)
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-06-27 18:23:33 +04:00
|
|
|
#define D_ASSERT(device, exp) do { \
|
|
|
|
if (!(exp)) \
|
|
|
|
drbd_err(device, "ASSERT( " #exp " ) in %s:%d\n", __FILE__, __LINE__); \
|
|
|
|
} while (0)
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2010-12-15 21:31:20 +03:00
|
|
|
/**
|
|
|
|
* expect - Make an assertion
|
|
|
|
*
|
|
|
|
* Unlike the assert macro, this macro returns a boolean result.
|
|
|
|
*/
|
|
|
|
#define expect(exp) ({ \
|
|
|
|
bool _bool = (exp); \
|
|
|
|
if (!_bool) \
|
2011-07-03 19:53:52 +04:00
|
|
|
drbd_err(device, "ASSERTION %s FAILED in %s\n", \
|
2010-12-15 21:31:20 +03:00
|
|
|
#exp, __func__); \
|
|
|
|
_bool; \
|
|
|
|
})
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* 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 */
|
2010-04-26 16:11:45 +04:00
|
|
|
DRBD_FAULT_RECEIVE = 9, /* Changes some bytes upon receiving a [rs]data block */
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
DRBD_FAULT_MAX,
|
|
|
|
};
|
|
|
|
|
|
|
|
extern unsigned int
|
2011-07-03 15:26:43 +04:00
|
|
|
_drbd_insert_fault(struct drbd_device *device, unsigned int type);
|
2010-12-07 12:43:29 +03:00
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
static inline int
|
2011-07-03 15:26:43 +04:00
|
|
|
drbd_insert_fault(struct drbd_device *device, unsigned int type) {
|
2010-12-07 12:43:29 +03:00
|
|
|
#ifdef CONFIG_DRBD_FAULT_INJECTION
|
2017-08-29 11:20:46 +03:00
|
|
|
return drbd_fault_rate &&
|
|
|
|
(drbd_enable_faults & (1<<type)) &&
|
2011-07-03 15:26:43 +04:00
|
|
|
_drbd_insert_fault(device, type);
|
2009-09-26 03:07:19 +04:00
|
|
|
#else
|
2010-12-07 12:43:29 +03:00
|
|
|
return 0;
|
2009-09-26 03:07:19 +04:00
|
|
|
#endif
|
2010-12-07 12:43:29 +03:00
|
|
|
}
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* 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;
|
2011-06-08 00:54:17 +04:00
|
|
|
extern struct idr drbd_devices; /* RCU, updates: genl_lock() */
|
2011-06-09 00:17:38 +04:00
|
|
|
extern struct list_head drbd_resources; /* RCU, updates: genl_lock() */
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-01-26 19:39:41 +03:00
|
|
|
extern const char *cmdname(enum drbd_packet cmd);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* 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];
|
|
|
|
};
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void INFO_bm_xfer_stats(struct drbd_device *device,
|
2009-09-26 03:07:19 +04:00
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2011-05-30 18:32:41 +04:00
|
|
|
extern unsigned int drbd_header_size(struct drbd_connection *connection);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/**********************************************************************/
|
|
|
|
enum drbd_thread_state {
|
2011-01-25 17:43:39 +03:00
|
|
|
NONE,
|
|
|
|
RUNNING,
|
|
|
|
EXITING,
|
|
|
|
RESTARTING
|
2009-09-26 03:07:19 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
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 *);
|
2011-07-21 15:45:21 +04:00
|
|
|
struct drbd_resource *resource;
|
2011-05-30 18:32:41 +04:00
|
|
|
struct drbd_connection *connection;
|
2009-09-26 03:07:19 +04:00
|
|
|
int reset_cpu_mask;
|
2011-08-10 17:05:02 +04:00
|
|
|
const char *name;
|
2009-09-26 03:07:19 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
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;
|
2010-12-21 14:38:39 +03:00
|
|
|
int (*cb)(struct drbd_work *, int cancel);
|
2011-07-28 17:27:51 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct drbd_device_work {
|
|
|
|
struct drbd_work w;
|
|
|
|
struct drbd_device *device;
|
2009-09-26 03:07:19 +04:00
|
|
|
};
|
|
|
|
|
2011-01-03 19:09:58 +03:00
|
|
|
#include "drbd_interval.h"
|
|
|
|
|
2011-05-30 18:15:21 +04:00
|
|
|
extern int drbd_wait_misc(struct drbd_device *, struct drbd_interval *);
|
2011-02-22 04:15:32 +03:00
|
|
|
|
2014-08-14 20:33:30 +04:00
|
|
|
extern void lock_all_resources(void);
|
|
|
|
extern void unlock_all_resources(void);
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
struct drbd_request {
|
|
|
|
struct drbd_work w;
|
2011-07-28 17:27:51 +04:00
|
|
|
struct drbd_device *device;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* 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).
|
2011-02-17 18:46:59 +03:00
|
|
|
* see drbd_request_endio(). */
|
2009-09-26 03:07:19 +04:00
|
|
|
struct bio *private_bio;
|
|
|
|
|
2011-01-03 19:09:58 +03:00
|
|
|
struct drbd_interval i;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-11-28 18:04:49 +04:00
|
|
|
/* epoch: used to check on "completion" whether this req was in
|
2009-09-26 03:07:19 +04:00
|
|
|
* the current epoch, and we therefore have to close it,
|
2011-11-28 18:04:49 +04:00
|
|
|
* 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).
|
2009-09-26 03:07:19 +04:00
|
|
|
*/
|
2011-11-28 18:04:49 +04:00
|
|
|
unsigned int epoch;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
struct list_head tl_requests; /* ring list in the transfer log */
|
|
|
|
struct bio *master_bio; /* master bio pointer */
|
2013-11-22 15:32:01 +04:00
|
|
|
|
2013-11-22 15:52:03 +04:00
|
|
|
/* see struct drbd_device */
|
|
|
|
struct list_head req_pending_master_completion;
|
|
|
|
struct list_head req_pending_local;
|
|
|
|
|
2013-11-22 15:32:01 +04:00
|
|
|
/* 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
|
|
|
|
*/
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2012-01-24 19:58:11 +04:00
|
|
|
/* 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;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2012-01-24 20:19:42 +04:00
|
|
|
unsigned rq_state; /* see comments above _req_mod() */
|
2009-09-26 03:07:19 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct drbd_epoch {
|
2011-05-30 18:32:41 +04:00
|
|
|
struct drbd_connection *connection;
|
2009-09-26 03:07:19 +04:00
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
2013-12-19 13:37:47 +04:00
|
|
|
/* Prototype declaration of function defined in drbd_receiver.c */
|
|
|
|
int drbdd_init(struct drbd_thread *);
|
|
|
|
int drbd_asender(struct drbd_thread *);
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
/* 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;
|
|
|
|
};
|
|
|
|
|
2011-02-04 17:30:34 +03:00
|
|
|
struct drbd_peer_request {
|
2011-08-25 17:49:40 +04:00
|
|
|
struct drbd_work w;
|
|
|
|
struct drbd_peer_device *peer_device;
|
2010-07-21 12:20:17 +04:00
|
|
|
struct drbd_epoch *epoch; /* for writes */
|
2010-05-14 19:10:48 +04:00
|
|
|
struct page *pages;
|
|
|
|
atomic_t pending_bios;
|
2011-01-14 22:59:35 +03:00
|
|
|
struct drbd_interval i;
|
2010-05-14 19:10:48 +04:00
|
|
|
/* see comments on ee flag bits below */
|
|
|
|
unsigned long flags;
|
2014-05-06 01:42:24 +04:00
|
|
|
unsigned long submit_jif;
|
2010-07-21 12:20:17 +04:00
|
|
|
union {
|
|
|
|
u64 block_id;
|
|
|
|
struct digest_info *digest;
|
|
|
|
};
|
2010-05-14 19:10:48 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
2009-09-26 03:07:19 +04:00
|
|
|
enum {
|
|
|
|
__EE_CALL_AL_COMPLETE_IO,
|
|
|
|
__EE_MAY_SET_IN_SYNC,
|
2010-05-14 19:10:48 +04:00
|
|
|
|
2014-04-28 20:43:23 +04:00
|
|
|
/* is this a TRIM aka REQ_DISCARD? */
|
|
|
|
__EE_IS_TRIM,
|
|
|
|
|
2010-05-14 19:10:48 +04:00
|
|
|
/* In case a barrier failed,
|
|
|
|
* we need to resubmit without the barrier flag. */
|
|
|
|
__EE_RESUBMITTED,
|
|
|
|
|
2011-02-04 17:38:52 +03:00
|
|
|
/* we may have several bios per peer request.
|
2010-05-14 19:10:48 +04:00
|
|
|
* if any of those fail, we set this flag atomically
|
|
|
|
* from the endio callback */
|
|
|
|
__EE_WAS_ERROR,
|
2010-08-11 22:42:55 +04:00
|
|
|
|
|
|
|
/* This ee has a pointer to a digest instead of a block id */
|
|
|
|
__EE_HAS_DIGEST,
|
2011-02-22 04:15:32 +03:00
|
|
|
|
|
|
|
/* Conflicting local requests need to be restarted after this request */
|
|
|
|
__EE_RESTART_REQUESTS,
|
2011-04-14 03:24:47 +04:00
|
|
|
|
|
|
|
/* The peer wants a write ACK for this (wire proto C) */
|
|
|
|
__EE_SEND_WRITE_ACK,
|
2011-04-21 13:36:49 +04:00
|
|
|
|
|
|
|
/* Is set when net_conf had two_primaries set while creating this peer_req */
|
|
|
|
__EE_IN_INTERVAL_TREE,
|
2014-05-06 01:42:24 +04:00
|
|
|
|
|
|
|
/* for debugfs: */
|
|
|
|
/* has this been submitted, or does it still wait for something else? */
|
|
|
|
__EE_SUBMITTED,
|
|
|
|
|
|
|
|
/* this is/was a write request */
|
|
|
|
__EE_WRITE,
|
|
|
|
|
2016-06-14 01:26:31 +03:00
|
|
|
/* this is/was a write same request */
|
|
|
|
__EE_WRITE_SAME,
|
|
|
|
|
2014-05-06 01:42:24 +04:00
|
|
|
/* this originates from application on peer
|
|
|
|
* (not some resync or verify or other DRBD internal request) */
|
|
|
|
__EE_APPLICATION,
|
2016-06-14 01:26:13 +03:00
|
|
|
|
|
|
|
/* If it contains only 0 bytes, send back P_RS_DEALLOCATED */
|
|
|
|
__EE_RS_THIN_REQ,
|
2009-09-26 03:07:19 +04:00
|
|
|
};
|
|
|
|
#define EE_CALL_AL_COMPLETE_IO (1<<__EE_CALL_AL_COMPLETE_IO)
|
|
|
|
#define EE_MAY_SET_IN_SYNC (1<<__EE_MAY_SET_IN_SYNC)
|
2014-04-28 20:43:23 +04:00
|
|
|
#define EE_IS_TRIM (1<<__EE_IS_TRIM)
|
|
|
|
#define EE_RESUBMITTED (1<<__EE_RESUBMITTED)
|
2010-05-14 19:10:48 +04:00
|
|
|
#define EE_WAS_ERROR (1<<__EE_WAS_ERROR)
|
2010-08-11 22:42:55 +04:00
|
|
|
#define EE_HAS_DIGEST (1<<__EE_HAS_DIGEST)
|
2011-02-22 04:15:32 +03:00
|
|
|
#define EE_RESTART_REQUESTS (1<<__EE_RESTART_REQUESTS)
|
2011-04-14 03:24:47 +04:00
|
|
|
#define EE_SEND_WRITE_ACK (1<<__EE_SEND_WRITE_ACK)
|
2011-04-21 13:36:49 +04:00
|
|
|
#define EE_IN_INTERVAL_TREE (1<<__EE_IN_INTERVAL_TREE)
|
2014-05-06 01:42:24 +04:00
|
|
|
#define EE_SUBMITTED (1<<__EE_SUBMITTED)
|
|
|
|
#define EE_WRITE (1<<__EE_WRITE)
|
2016-06-14 01:26:31 +03:00
|
|
|
#define EE_WRITE_SAME (1<<__EE_WRITE_SAME)
|
2014-05-06 01:42:24 +04:00
|
|
|
#define EE_APPLICATION (1<<__EE_APPLICATION)
|
2016-06-14 01:26:13 +03:00
|
|
|
#define EE_RS_THIN_REQ (1<<__EE_RS_THIN_REQ)
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
/* flag bits per device */
|
2009-09-26 03:07:19 +04:00
|
|
|
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,
|
|
|
|
|
2010-08-25 12:21:04 +04:00
|
|
|
MD_NO_FUA, /* Users wants us to not use FUA/FLUSH on meta data dev */
|
drbd: fix resync finished detection
This fixes one recent regresion,
and one long existing bug.
The bug:
drbd_try_clear_on_disk_bm() assumed that all "count" bits have to be
accounted in the resync extent corresponding to the start sector.
Since we allow application requests to cross our "extent" boundaries,
this assumption is no longer true, resulting in possible misaccounting,
scary messages
("BAD! sector=12345s enr=6 rs_left=-7 rs_failed=0 count=58 cstate=..."),
and potentially, if the last bit to be cleared during resync would
reside in previously misaccounted resync extent, the resync would never
be recognized as finished, but would be "stalled" forever, even though
all blocks are in sync again and all bits have been cleared...
The regression was introduced by
drbd: get rid of atomic update on disk bitmap works
For an "empty" resync (rs_total == 0), we must not "finish" the
resync on the SyncSource before the SyncTarget knows all relevant
information (sync uuid). We need to wait for the full round-trip,
the SyncTarget will then explicitly notify us.
Also for normal, non-empty resyncs (rs_total > 0), the resync-finished
condition needs to be tested before the schedule() in wait_for_work, or
it is likely to be missed.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2014-01-27 18:58:22 +04:00
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
BITMAP_IO, /* suspend application io;
|
|
|
|
once no more io in flight, start bitmap io */
|
|
|
|
BITMAP_IO_QUEUED, /* Started bitmap IO */
|
drbd: always write bitmap on detach
If we detach due to local read-error (which sets a bit in the bitmap),
stay Primary, and then re-attach (which re-reads the bitmap from disk),
we potentially lost the "out-of-sync" (or, "bad block") information in
the bitmap.
Always (try to) write out the changed bitmap pages before going diskless.
That way, we don't lose the bit for the bad block,
the next resync will fetch it from the peer, and rewrite
it locally, which may result in block reallocation in some
lower layer (or the hardware), and thereby "heal" the bad blocks.
If the bitmap writeout errors out as well, we will (again: try to)
mark the "we need a full sync" bit in our super block,
if it was a READ error; writes are covered by the activity log already.
If that superblock does not make it to disk either, we are sorry.
Maybe we just lost an entire disk or controller (or iSCSI connection),
and there actually are no bad blocks at all, so we don't need to
re-fetch from the peer, there is no "auto-healing" necessary.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-09-22 14:26:57 +04:00
|
|
|
WAS_IO_ERROR, /* Local disk failed, returned IO error */
|
|
|
|
WAS_READ_ERROR, /* Local disk READ failed (set additionally to the above) */
|
2012-06-14 16:21:32 +04:00
|
|
|
FORCE_DETACH, /* Force-detach from local disk, aborting any pending local IO */
|
2009-09-26 03:07:19 +04:00
|
|
|
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. */
|
2010-06-11 13:26:34 +04:00
|
|
|
NEW_CUR_UUID, /* Create new current UUID when thawing IO */
|
2010-08-31 14:00:50 +04:00
|
|
|
AL_SUSPENDED, /* Activity logging is currently suspended. */
|
2011-01-14 18:03:11 +03:00
|
|
|
AHEAD_TO_SYNC_SOURCE, /* Ahead -> SyncSource queued */
|
2011-02-05 19:34:11 +03:00
|
|
|
B_RS_H_DONE, /* Before resync handler done (already executed) */
|
2011-09-05 18:22:33 +04:00
|
|
|
DISCARD_MY_DATA, /* discard_my_data flag per volume */
|
2011-11-11 15:31:20 +04:00
|
|
|
READ_BALANCE_RR,
|
2014-02-11 12:30:49 +04:00
|
|
|
|
2014-05-06 01:05:47 +04:00
|
|
|
FLUSH_PENDING, /* if set, device->flush_jif is when we submitted that flush
|
|
|
|
* from drbd_flush_after_epoch() */
|
|
|
|
|
2014-02-11 12:30:49 +04:00
|
|
|
/* 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. */
|
2014-02-11 12:47:58 +04:00
|
|
|
MD_SYNC, /* tell worker to call drbd_md_sync() */
|
|
|
|
RS_START, /* tell worker to start resync/OV */
|
2014-02-11 12:30:49 +04:00
|
|
|
RS_PROGRESS, /* tell worker that resync made significant progress */
|
|
|
|
RS_DONE, /* tell worker that resync is done */
|
2009-09-26 03:07:19 +04:00
|
|
|
};
|
|
|
|
|
2011-05-30 18:15:21 +04:00
|
|
|
struct drbd_bitmap; /* opaque for drbd_device */
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-01-21 12:56:44 +03:00
|
|
|
/* 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 */
|
2012-04-26 01:06:45 +04:00
|
|
|
BM_LOCKED_MASK = 0xf,
|
2011-01-21 12:56:44 +03:00
|
|
|
|
|
|
|
/* in detail, that is: */
|
|
|
|
BM_DONT_CLEAR = 0x1,
|
|
|
|
BM_DONT_SET = 0x2,
|
|
|
|
BM_DONT_TEST = 0x4,
|
|
|
|
|
2012-04-26 01:06:45 +04:00
|
|
|
/* so we can mark it locked for bulk operation,
|
|
|
|
* and still allow all non-bulk operations */
|
|
|
|
BM_IS_LOCKED = 0x8,
|
|
|
|
|
2011-01-21 12:56:44 +03:00
|
|
|
/* (test bit, count bit) allowed (common case) */
|
2012-04-26 01:06:45 +04:00
|
|
|
BM_LOCKED_TEST_ALLOWED = BM_DONT_CLEAR | BM_DONT_SET | BM_IS_LOCKED,
|
2011-01-21 12:56:44 +03:00
|
|
|
|
|
|
|
/* 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. */
|
2012-04-26 01:06:45 +04:00
|
|
|
BM_LOCKED_SET_ALLOWED = BM_DONT_CLEAR | BM_IS_LOCKED,
|
2011-01-21 12:56:44 +03:00
|
|
|
|
2012-04-26 01:06:45 +04:00
|
|
|
/* for drbd_bm_write_copy_pages, everything is allowed,
|
|
|
|
* only concurrent bulk operations are locked out. */
|
|
|
|
BM_LOCKED_CHANGE_ALLOWED = BM_IS_LOCKED,
|
2011-01-21 12:56:44 +03:00
|
|
|
};
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
struct drbd_work_queue {
|
|
|
|
struct list_head q;
|
|
|
|
spinlock_t q_lock; /* to protect the list. */
|
2011-10-19 13:50:57 +04:00
|
|
|
wait_queue_head_t q_wait;
|
2009-09-26 03:07:19 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct drbd_socket {
|
|
|
|
struct mutex mutex;
|
|
|
|
struct socket *socket;
|
|
|
|
/* this way we get our
|
|
|
|
* send/receive buffers off the stack */
|
2011-03-24 23:17:52 +03:00
|
|
|
void *sbuf;
|
2011-03-24 20:07:54 +03:00
|
|
|
void *rbuf;
|
2009-09-26 03:07:19 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct drbd_md {
|
|
|
|
u64 md_offset; /* sector offset to 'super' block */
|
|
|
|
|
|
|
|
u64 la_size_sect; /* last agreed size, unit sectors */
|
2012-08-16 16:25:58 +04:00
|
|
|
spinlock_t uuid_lock;
|
2009-09-26 03:07:19 +04:00
|
|
|
u64 uuid[UI_SIZE];
|
|
|
|
u64 device_uuid;
|
|
|
|
u32 flags;
|
|
|
|
u32 md_size_sect;
|
|
|
|
|
2013-03-19 21:16:43 +04:00
|
|
|
s32 al_offset; /* signed relative sector offset to activity log */
|
2009-09-26 03:07:19 +04:00
|
|
|
s32 bm_offset; /* signed relative sector offset to bitmap */
|
2013-03-19 21:16:44 +04:00
|
|
|
|
|
|
|
/* 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 */
|
2009-09-26 03:07:19 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct drbd_backing_dev {
|
|
|
|
struct block_device *backing_bdev;
|
|
|
|
struct block_device *md_bdev;
|
|
|
|
struct drbd_md md;
|
2011-07-07 16:19:42 +04:00
|
|
|
struct disk_conf *disk_conf; /* RCU, for updates: resource->conf_update */
|
2009-09-26 03:07:19 +04:00
|
|
|
sector_t known_size; /* last known size of that backing device */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct drbd_md_io {
|
2014-04-02 01:53:30 +04:00
|
|
|
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;
|
2011-06-27 00:26:31 +04:00
|
|
|
unsigned int done;
|
2009-09-26 03:07:19 +04:00
|
|
|
int error;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct bm_io_work {
|
|
|
|
struct drbd_work w;
|
|
|
|
char *why;
|
2011-01-21 12:56:44 +03:00
|
|
|
enum bm_flag flags;
|
2011-07-03 15:26:43 +04:00
|
|
|
int (*io_fn)(struct drbd_device *device);
|
|
|
|
void (*done)(struct drbd_device *device, int rv);
|
2009-09-26 03:07:19 +04:00
|
|
|
};
|
|
|
|
|
2010-07-06 13:14:00 +04:00
|
|
|
struct fifo_buffer {
|
|
|
|
unsigned int head_index;
|
|
|
|
unsigned int size;
|
2011-05-03 18:19:31 +04:00
|
|
|
int total; /* sum of all values */
|
|
|
|
int values[0];
|
2010-07-06 13:14:00 +04:00
|
|
|
};
|
2011-05-03 18:19:31 +04:00
|
|
|
extern struct fifo_buffer *fifo_alloc(int fifo_size);
|
2010-07-06 13:14:00 +04:00
|
|
|
|
2011-05-30 18:32:41 +04:00
|
|
|
/* flag bits per connection */
|
2011-02-07 16:30:33 +03:00
|
|
|
enum {
|
|
|
|
NET_CONGESTED, /* The data socket is congested */
|
2012-08-01 14:43:01 +04:00
|
|
|
RESOLVE_CONFLICTS, /* Set on one node, cleared on the peer! */
|
2015-03-16 18:08:29 +03:00
|
|
|
SEND_PING,
|
2011-02-09 16:10:32 +03:00
|
|
|
GOT_PING_ACK, /* set when we receive a ping_ack packet, ping_wait gets woken */
|
2012-01-20 16:52:27 +04:00
|
|
|
CONN_WD_ST_CHG_REQ, /* A cluster wide state change on the connection is active */
|
2011-02-15 13:07:59 +03:00
|
|
|
CONN_WD_ST_CHG_OKAY,
|
|
|
|
CONN_WD_ST_CHG_FAIL,
|
2011-03-15 20:40:27 +03:00
|
|
|
CONN_DRY_RUN, /* Expect disconnect after resync handshake. */
|
2011-11-10 21:45:36 +04:00
|
|
|
CREATE_BARRIER, /* next P_DATA is preceded by a P_BARRIER */
|
2012-04-06 14:07:34 +04:00
|
|
|
STATE_SENT, /* Do not change state/UUIDs while this is set */
|
2012-07-30 11:08:25 +04:00
|
|
|
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.
|
|
|
|
*/
|
2012-08-08 23:19:09 +04:00
|
|
|
DISCONNECT_SENT,
|
2014-02-11 12:30:49 +04:00
|
|
|
|
|
|
|
DEVICE_WORK_PENDING, /* tell worker that some device has pending work */
|
2011-02-07 16:30:33 +03:00
|
|
|
};
|
|
|
|
|
2014-07-31 19:41:33 +04:00
|
|
|
enum which_state { NOW, OLD = NOW, NEW };
|
|
|
|
|
2011-06-09 00:17:38 +04:00
|
|
|
struct drbd_resource {
|
|
|
|
char *name;
|
2014-05-02 15:19:51 +04:00
|
|
|
#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
|
2011-06-09 00:17:38 +04:00
|
|
|
struct kref kref;
|
2011-06-09 03:40:48 +04:00
|
|
|
struct idr devices; /* volume number to device mapping */
|
2011-06-09 00:17:38 +04:00
|
|
|
struct list_head connections;
|
|
|
|
struct list_head resources;
|
2011-06-21 18:11:28 +04:00
|
|
|
struct res_opts res_opts;
|
2011-07-07 16:19:42 +04:00
|
|
|
struct mutex conf_update; /* mutex for ready-copy-update of net_conf and disk_conf */
|
2014-04-28 20:43:22 +04:00
|
|
|
struct mutex adm_mutex; /* mutex to serialize administrative requests */
|
2011-07-07 16:19:42 +04:00
|
|
|
spinlock_t req_lock;
|
2011-07-08 03:19:44 +04:00
|
|
|
|
|
|
|
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 */
|
2011-07-22 16:29:02 +04:00
|
|
|
|
2013-11-22 18:53:41 +04:00
|
|
|
enum write_ordering_e write_ordering;
|
|
|
|
|
2011-07-22 16:29:02 +04:00
|
|
|
cpumask_var_t cpu_mask;
|
2011-06-09 00:17:38 +04:00
|
|
|
};
|
|
|
|
|
2014-05-06 17:02:05 +04:00
|
|
|
struct drbd_thread_timing_details
|
|
|
|
{
|
|
|
|
unsigned long start_jif;
|
|
|
|
void *cb_addr;
|
|
|
|
const char *caller_fn;
|
|
|
|
unsigned int line;
|
|
|
|
unsigned int cb_nr;
|
|
|
|
};
|
|
|
|
|
2011-06-09 00:17:38 +04:00
|
|
|
struct drbd_connection {
|
|
|
|
struct list_head connections;
|
|
|
|
struct drbd_resource *resource;
|
2014-05-02 15:19:51 +04:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
struct dentry *debugfs_conn;
|
|
|
|
struct dentry *debugfs_conn_callback_history;
|
|
|
|
struct dentry *debugfs_conn_oldest_requests;
|
|
|
|
#endif
|
2011-04-22 17:23:32 +04:00
|
|
|
struct kref kref;
|
2011-06-21 19:23:59 +04:00
|
|
|
struct idr peer_devices; /* volume number to peer device mapping */
|
2011-02-11 22:11:10 +03:00
|
|
|
enum drbd_conns cstate; /* Only C_STANDALONE to C_WF_REPORT_PARAMS */
|
|
|
|
struct mutex cstate_mutex; /* Protects graceful disconnects */
|
2013-06-25 18:50:06 +04:00
|
|
|
unsigned int connect_cnt; /* Inc each time a connection is established */
|
2011-01-19 14:26:59 +03:00
|
|
|
|
2011-02-08 13:09:18 +03:00
|
|
|
unsigned long flags;
|
2011-04-19 19:10:19 +04:00
|
|
|
struct net_conf *net_conf; /* content protected by rcu */
|
2011-04-20 19:47:29 +04:00
|
|
|
wait_queue_head_t ping_wait; /* Woken upon reception of a ping, and a state change */
|
2011-01-19 15:55:45 +03:00
|
|
|
|
2011-06-14 20:28:09 +04:00
|
|
|
struct sockaddr_storage my_addr;
|
|
|
|
int my_addr_len;
|
|
|
|
struct sockaddr_storage peer_addr;
|
|
|
|
int peer_addr_len;
|
|
|
|
|
2011-01-19 15:55:45 +03:00
|
|
|
struct drbd_socket data; /* data/barrier/cstate/parameter packets */
|
|
|
|
struct drbd_socket meta; /* ping/ack (metadata) packets */
|
2011-01-19 16:12:51 +03:00
|
|
|
int agreed_pro_version; /* actually used protocol version */
|
2014-04-28 20:43:25 +04:00
|
|
|
u32 agreed_features;
|
2011-01-19 16:12:51 +03:00
|
|
|
unsigned long last_received; /* in jiffies, either socket */
|
|
|
|
unsigned int ko_count;
|
2011-01-19 16:02:01 +03:00
|
|
|
|
2011-11-28 18:04:49 +04:00
|
|
|
struct list_head transfer_log; /* all requests not yet fully processed */
|
2011-01-19 16:16:30 +03:00
|
|
|
|
2016-01-24 16:19:21 +03:00
|
|
|
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;
|
2011-01-19 16:31:32 +03:00
|
|
|
void *int_dig_in;
|
|
|
|
void *int_dig_vv;
|
|
|
|
|
2011-11-28 18:04:49 +04:00
|
|
|
/* receiver side */
|
2011-11-09 22:18:00 +04:00
|
|
|
struct drbd_epoch *current_epoch;
|
|
|
|
spinlock_t epoch_lock;
|
|
|
|
unsigned int epochs;
|
2011-11-17 14:49:46 +04:00
|
|
|
atomic_t current_tle_nr; /* transfer log epoch number */
|
2011-11-28 18:04:49 +04:00
|
|
|
unsigned current_tle_writes; /* writes seen within this tl epoch */
|
2011-11-09 23:12:34 +04:00
|
|
|
|
2012-05-07 13:53:08 +04:00
|
|
|
unsigned long last_reconnect_jif;
|
drbd: introduce drbd_recv_header_maybe_unplug
Recently, drbd_recv_header() was changed to potentially
implicitly "unplug" the backend device(s), in case there
is currently nothing to receive.
Be more explicit about it: re-introduce the original drbd_recv_header(),
and introduce a new drbd_recv_header_maybe_unplug() for use by the
receiver "main loop".
Using explicit plugging via blk_start_plug(); blk_finish_plug();
really helps the io-scheduler of the backend with merging requests.
Wrap the receiver "main loop" with such a plug.
Also catch unplug events on the Primary,
and try to propagate.
This is performance relevant. Without this, if the receiving side does
not merge requests, number of IOPS on the peer can me significantly
higher than IOPS on the Primary, and can easily become the bottleneck.
Together, both changes should help to reduce the number of IOPS
as seen on the backend of the receiving side, by increasing
the chance of merging mergable requests, without trading latency
for more throughput.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2017-08-29 11:20:32 +03:00
|
|
|
/* empty member on older kernels without blk_start_plug() */
|
|
|
|
struct blk_plug receiver_plug;
|
2011-01-19 16:02:01 +03:00
|
|
|
struct drbd_thread receiver;
|
|
|
|
struct drbd_thread worker;
|
2015-03-16 17:01:00 +03:00
|
|
|
struct drbd_thread ack_receiver;
|
2015-03-16 18:08:29 +03:00
|
|
|
struct workqueue_struct *ack_sender;
|
2011-11-28 18:04:49 +04:00
|
|
|
|
2013-11-22 16:00:12 +04:00
|
|
|
/* 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;
|
|
|
|
|
2011-11-28 18:04:49 +04:00
|
|
|
/* sender side */
|
2011-11-14 18:42:37 +04:00
|
|
|
struct drbd_work_queue sender_work;
|
2011-11-28 18:04:49 +04:00
|
|
|
|
2014-05-06 17:02:05 +04:00
|
|
|
#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];
|
|
|
|
|
2011-11-28 18:04:49 +04:00
|
|
|
struct {
|
2015-02-19 15:54:11 +03:00
|
|
|
unsigned long last_sent_barrier_jif;
|
|
|
|
|
2011-11-28 18:04:49 +04:00
|
|
|
/* 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;
|
2010-07-06 13:14:00 +04:00
|
|
|
};
|
|
|
|
|
2014-07-31 19:41:33 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-05-06 17:02:05 +04:00
|
|
|
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__ )
|
|
|
|
|
2013-03-23 04:14:40 +04:00
|
|
|
struct submit_worker {
|
|
|
|
struct workqueue_struct *wq;
|
|
|
|
struct work_struct worker;
|
|
|
|
|
2013-11-22 15:52:03 +04:00
|
|
|
/* protected by ..->resource->req_lock */
|
2013-03-23 04:14:40 +04:00
|
|
|
struct list_head writes;
|
|
|
|
};
|
|
|
|
|
2011-05-31 16:33:49 +04:00
|
|
|
struct drbd_peer_device {
|
|
|
|
struct list_head peer_devices;
|
|
|
|
struct drbd_device *device;
|
2011-05-30 18:32:41 +04:00
|
|
|
struct drbd_connection *connection;
|
2015-03-16 18:08:29 +03:00
|
|
|
struct work_struct send_acks_work;
|
2014-05-02 15:19:51 +04:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
struct dentry *debugfs_peer_dev;
|
|
|
|
#endif
|
2011-05-31 16:33:49 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct drbd_device {
|
2011-06-09 03:38:00 +04:00
|
|
|
struct drbd_resource *resource;
|
2011-05-31 16:33:49 +04:00
|
|
|
struct list_head peer_devices;
|
2014-05-06 02:44:59 +04:00
|
|
|
struct list_head pending_bitmap_io;
|
2014-05-02 15:19:51 +04:00
|
|
|
|
|
|
|
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;
|
2015-03-18 19:19:10 +03:00
|
|
|
struct dentry *debugfs_vol_ed_gen_id;
|
2014-05-02 15:19:51 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
unsigned int vnr; /* volume number within the connection */
|
|
|
|
unsigned int minor; /* device minor number */
|
|
|
|
|
2011-05-04 17:10:30 +04:00
|
|
|
struct kref kref;
|
2011-01-19 14:26:59 +03:00
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
/* 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;
|
|
|
|
|
2012-05-07 13:53:08 +04:00
|
|
|
unsigned long last_reattach_jif;
|
2011-07-28 17:27:51 +04:00
|
|
|
struct drbd_work resync_work;
|
|
|
|
struct drbd_work unplug_work;
|
2009-09-26 03:07:19 +04:00
|
|
|
struct timer_list resync_timer;
|
|
|
|
struct timer_list md_sync_timer;
|
2011-01-14 18:03:11 +03:00
|
|
|
struct timer_list start_resync_timer;
|
2011-03-01 13:08:28 +03:00
|
|
|
struct timer_list request_timer;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* Used after attach while negotiating new disk state. */
|
|
|
|
union drbd_state new_state_tmp;
|
|
|
|
|
2011-03-29 12:52:01 +04:00
|
|
|
union drbd_dev_state state;
|
2009-09-26 03:07:19 +04:00
|
|
|
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 */
|
2013-12-20 14:22:13 +04:00
|
|
|
atomic_t ap_actlog_cnt; /* Requests waiting for activity log */
|
2009-09-26 03:07:19 +04:00
|
|
|
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 */
|
2011-05-31 15:07:24 +04:00
|
|
|
atomic_t unacked_cnt; /* Need to send replies for */
|
2009-09-26 03:07:19 +04:00
|
|
|
atomic_t local_cnt; /* Waiting for local completion */
|
2013-02-28 13:30:19 +04:00
|
|
|
atomic_t suspend_cnt;
|
2011-01-19 15:48:44 +03:00
|
|
|
|
2011-01-21 19:18:39 +03:00
|
|
|
/* Interval tree of pending local requests */
|
|
|
|
struct rb_root read_requests;
|
2011-01-20 17:00:24 +03:00
|
|
|
struct rb_root write_requests;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2013-11-22 15:52:03 +04:00
|
|
|
/* for statistics and timeouts */
|
|
|
|
/* [0] read, [1] write */
|
|
|
|
struct list_head pending_master_completion[2];
|
|
|
|
struct list_head pending_completion[2];
|
|
|
|
|
2014-03-18 15:30:09 +04:00
|
|
|
/* use checksums for *this* resync */
|
|
|
|
bool use_csums;
|
2010-12-14 17:13:04 +03:00
|
|
|
/* blocks to resync in this run [unit BM_BLOCK_SIZE] */
|
2009-09-26 03:07:19 +04:00
|
|
|
unsigned long rs_total;
|
2010-12-14 17:13:04 +03:00
|
|
|
/* number of resync blocks that failed in this run */
|
2009-09-26 03:07:19 +04:00
|
|
|
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;
|
2010-08-11 23:21:50 +04:00
|
|
|
/* 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)
|
2009-09-26 03:07:19 +04:00
|
|
|
/* block not up-to-date at mark [unit BM_BLOCK_SIZE] */
|
2010-08-11 23:21:50 +04:00
|
|
|
unsigned long rs_mark_left[DRBD_SYNC_MARKS];
|
2009-09-26 03:07:19 +04:00
|
|
|
/* marks's time [unit jiffies] */
|
2010-08-11 23:21:50 +04:00
|
|
|
unsigned long rs_mark_time[DRBD_SYNC_MARKS];
|
|
|
|
/* current index into rs_mark_{left,time} */
|
|
|
|
int rs_last_mark;
|
2012-10-19 16:37:47 +04:00
|
|
|
unsigned long rs_last_bcast; /* [unit jiffies] */
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* where does the admin want us to start? (sector) */
|
|
|
|
sector_t ov_start_sector;
|
2012-06-28 20:26:52 +04:00
|
|
|
sector_t ov_stop_sector;
|
2009-09-26 03:07:19 +04:00
|
|
|
/* 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;
|
2011-11-09 23:12:34 +04:00
|
|
|
|
2010-07-21 12:20:17 +04:00
|
|
|
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) */
|
2011-02-04 17:36:22 +03:00
|
|
|
struct list_head done_ee; /* need to send P_WRITE_ACK */
|
|
|
|
struct list_head read_ee; /* [RS]P_DATA_REQUEST being read */
|
2009-09-26 03:07:19 +04:00
|
|
|
struct list_head net_ee; /* zero-copy network send in progress */
|
|
|
|
|
|
|
|
int next_barrier_nr;
|
|
|
|
struct list_head resync_reads;
|
2010-09-06 14:30:25 +04:00
|
|
|
atomic_t pp_in_use; /* allocated from page pool */
|
|
|
|
atomic_t pp_in_use_by_net; /* sendpage()d, still referenced by tcp */
|
2009-09-26 03:07:19 +04:00
|
|
|
wait_queue_head_t ee_wait;
|
2011-06-26 13:20:27 +04:00
|
|
|
struct drbd_md_io md_io;
|
2009-09-26 03:07:19 +04:00
|
|
|
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 */
|
2011-02-11 22:11:10 +03:00
|
|
|
struct mutex own_state_mutex;
|
2011-05-31 16:33:49 +04:00
|
|
|
struct mutex *state_mutex; /* either own_state_mutex or first_peer_device(device)->connection->cstate_mutex */
|
2009-09-26 03:07:19 +04:00
|
|
|
char congestion_reason; /* Why we where congested... */
|
2010-08-11 23:21:50 +04:00
|
|
|
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 */
|
2011-05-30 18:32:41 +04:00
|
|
|
struct fifo_buffer *rs_plan_s; /* correction values of resync planer (RCU, connection->conn_update) */
|
2010-07-06 13:14:00 +04:00
|
|
|
int rs_in_flight; /* resync sectors in flight (to proxy, in proxy and from proxy) */
|
2010-10-26 18:02:27 +04:00
|
|
|
atomic_t ap_in_flight; /* App sectors in flight (waiting for ack) */
|
2012-06-25 21:15:58 +04:00
|
|
|
unsigned int peer_max_bio_size;
|
|
|
|
unsigned int local_max_bio_size;
|
2013-03-23 04:14:40 +04:00
|
|
|
|
|
|
|
/* any requests that would block in drbd_make_request()
|
|
|
|
* are deferred to this single-threaded work queue */
|
|
|
|
struct submit_worker submit;
|
2009-09-26 03:07:19 +04:00
|
|
|
};
|
|
|
|
|
2014-05-06 02:44:59 +04:00
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
2014-04-28 20:43:21 +04:00
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline struct drbd_device *minor_to_device(unsigned int minor)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-06-08 00:54:17 +04:00
|
|
|
return (struct drbd_device *)idr_find(&drbd_devices, minor);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2011-05-31 16:33:49 +04:00
|
|
|
static inline struct drbd_peer_device *first_peer_device(struct drbd_device *device)
|
|
|
|
{
|
2014-04-28 20:43:35 +04:00
|
|
|
return list_first_entry_or_null(&device->peer_devices, struct drbd_peer_device, peer_devices);
|
2011-05-31 16:33:49 +04:00
|
|
|
}
|
|
|
|
|
2014-07-31 19:41:33 +04:00
|
|
|
static inline struct drbd_peer_device *
|
|
|
|
conn_peer_device(struct drbd_connection *connection, int volume_number)
|
|
|
|
{
|
|
|
|
return idr_find(&connection->peer_devices, volume_number);
|
|
|
|
}
|
|
|
|
|
2011-06-09 00:17:38 +04:00
|
|
|
#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)
|
|
|
|
|
2011-05-31 16:33:49 +04:00
|
|
|
#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)
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline unsigned int device_to_minor(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
return device->minor;
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* function declarations
|
|
|
|
*************************/
|
|
|
|
|
|
|
|
/* drbd_main.c */
|
|
|
|
|
2010-03-24 19:11:33 +03:00
|
|
|
enum dds_flags {
|
|
|
|
DDSF_FORCED = 1,
|
|
|
|
DDSF_NO_RESYNC = 2, /* Do not run a resync for the new space */
|
|
|
|
};
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_init_set_defaults(struct drbd_device *device);
|
2009-09-26 03:07:19 +04:00
|
|
|
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
|
2011-02-08 14:46:30 +03:00
|
|
|
extern void drbd_thread_current_set_cpu(struct drbd_thread *thi);
|
2009-09-26 03:07:19 +04:00
|
|
|
#else
|
|
|
|
#define drbd_thread_current_set_cpu(A) ({})
|
|
|
|
#endif
|
2011-05-30 18:32:41 +04:00
|
|
|
extern void tl_release(struct drbd_connection *, unsigned int barrier_nr,
|
2009-09-26 03:07:19 +04:00
|
|
|
unsigned int set_size);
|
2011-05-30 18:32:41 +04:00
|
|
|
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,
|
2011-02-07 17:08:48 +03:00
|
|
|
void *buf, size_t size, unsigned msg_flags);
|
2011-05-30 18:32:41 +04:00
|
|
|
extern int drbd_send_all(struct drbd_connection *, struct socket *, void *, size_t,
|
2010-12-15 19:04:36 +03:00
|
|
|
unsigned);
|
|
|
|
|
2011-05-30 18:32:41 +04:00
|
|
|
extern int __drbd_send_protocol(struct drbd_connection *connection, enum drbd_packet cmd);
|
|
|
|
extern int drbd_send_protocol(struct drbd_connection *connection);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
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 *);
|
2011-05-30 18:32:41 +04:00
|
|
|
extern void drbd_send_b_ack(struct drbd_connection *connection, u32 barrier_nr,
|
2011-03-16 03:25:28 +03:00
|
|
|
u32 set_size);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern int drbd_send_ack(struct drbd_peer_device *, enum drbd_packet,
|
2011-02-04 17:30:34 +03:00
|
|
|
struct drbd_peer_request *);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern void drbd_send_ack_rp(struct drbd_peer_device *, enum drbd_packet,
|
2011-03-16 03:30:14 +03:00
|
|
|
struct p_block_req *rp);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern void drbd_send_ack_dp(struct drbd_peer_device *, enum drbd_packet,
|
2011-03-16 03:30:14 +03:00
|
|
|
struct p_data *dp, int data_size);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern int drbd_send_ack_ex(struct drbd_peer_device *, enum drbd_packet,
|
2009-09-26 03:07:19 +04:00
|
|
|
sector_t sector, int blksize, u64 block_id);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
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,
|
2011-02-04 17:30:34 +03:00
|
|
|
struct drbd_peer_request *);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern int drbd_send_dblock(struct drbd_peer_device *, struct drbd_request *req);
|
|
|
|
extern int drbd_send_drequest(struct drbd_peer_device *, int cmd,
|
2009-09-26 03:07:19 +04:00
|
|
|
sector_t sector, int size, u64 block_id);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern int drbd_send_drequest_csum(struct drbd_peer_device *, sector_t sector,
|
2011-01-26 19:39:41 +03:00
|
|
|
int size, void *digest, int digest_size,
|
|
|
|
enum drbd_packet cmd);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern int drbd_send_ov_request(struct drbd_peer_device *, sector_t sector, int size);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
extern int drbd_send_bitmap(struct drbd_device *device);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern void drbd_send_sr_reply(struct drbd_peer_device *, enum drbd_state_rv retcode);
|
2011-05-30 18:32:41 +04:00
|
|
|
extern void conn_send_sr_reply(struct drbd_connection *connection, enum drbd_state_rv retcode);
|
2016-06-14 01:26:13 +03:00
|
|
|
extern int drbd_send_rs_deallocated(struct drbd_peer_device *, struct drbd_peer_request *);
|
2015-03-26 22:53:55 +03:00
|
|
|
extern void drbd_backing_dev_free(struct drbd_device *device, struct drbd_backing_dev *ldev);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_device_cleanup(struct drbd_device *device);
|
drbd: introduce drbd_recv_header_maybe_unplug
Recently, drbd_recv_header() was changed to potentially
implicitly "unplug" the backend device(s), in case there
is currently nothing to receive.
Be more explicit about it: re-introduce the original drbd_recv_header(),
and introduce a new drbd_recv_header_maybe_unplug() for use by the
receiver "main loop".
Using explicit plugging via blk_start_plug(); blk_finish_plug();
really helps the io-scheduler of the backend with merging requests.
Wrap the receiver "main loop" with such a plug.
Also catch unplug events on the Primary,
and try to propagate.
This is performance relevant. Without this, if the receiving side does
not merge requests, number of IOPS on the peer can me significantly
higher than IOPS on the Primary, and can easily become the bottleneck.
Together, both changes should help to reduce the number of IOPS
as seen on the backend of the receiving side, by increasing
the chance of merging mergable requests, without trading latency
for more throughput.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2017-08-29 11:20:32 +03:00
|
|
|
extern void drbd_print_uuids(struct drbd_device *device, const char *text);
|
|
|
|
extern void drbd_queue_unplug(struct drbd_device *device);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-05-30 18:32:41 +04:00
|
|
|
extern void conn_md_sync(struct drbd_connection *connection);
|
2011-07-03 15:26:43 +04:00
|
|
|
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);
|
2009-09-26 03:07:19 +04:00
|
|
|
extern int drbd_md_test_flag(struct drbd_backing_dev *, int);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_md_mark_dirty(struct drbd_device *device);
|
|
|
|
extern void drbd_queue_bitmap_io(struct drbd_device *device,
|
2011-05-30 18:15:21 +04:00
|
|
|
int (*io_fn)(struct drbd_device *),
|
|
|
|
void (*done)(struct drbd_device *, int),
|
2011-01-21 12:56:44 +03:00
|
|
|
char *why, enum bm_flag flags);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern int drbd_bitmap_io(struct drbd_device *device,
|
2011-05-30 18:15:21 +04:00
|
|
|
int (*io_fn)(struct drbd_device *),
|
2011-01-21 12:56:44 +03:00
|
|
|
char *why, enum bm_flag flags);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern int drbd_bitmap_io_from_worker(struct drbd_device *device,
|
2011-05-30 18:15:21 +04:00
|
|
|
int (*io_fn)(struct drbd_device *),
|
drbd: always write bitmap on detach
If we detach due to local read-error (which sets a bit in the bitmap),
stay Primary, and then re-attach (which re-reads the bitmap from disk),
we potentially lost the "out-of-sync" (or, "bad block") information in
the bitmap.
Always (try to) write out the changed bitmap pages before going diskless.
That way, we don't lose the bit for the bad block,
the next resync will fetch it from the peer, and rewrite
it locally, which may result in block reallocation in some
lower layer (or the hardware), and thereby "heal" the bad blocks.
If the bitmap writeout errors out as well, we will (again: try to)
mark the "we need a full sync" bit in our super block,
if it was a READ error; writes are covered by the activity log already.
If that superblock does not make it to disk either, we are sorry.
Maybe we just lost an entire disk or controller (or iSCSI connection),
and there actually are no bad blocks at all, so we don't need to
re-fetch from the peer, there is no "auto-healing" necessary.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2012-09-27 17:18:21 +04:00
|
|
|
char *why, enum bm_flag flags);
|
drbd: device->ldev is not guaranteed on an D_ATTACHING disk
Some parts of the code assumed that get_ldev_if_state(device, D_ATTACHING)
is sufficient to access the ldev member of the device object. That was
wrong. ldev may not be there or might be freed at any time if the device
has a disk state of D_ATTACHING.
bm_rw()
Documented that drbd_bm_read() is only called from drbd_adm_attach.
drbd_bm_write() is only called when a reference is held, and it is
documented that a caller has to hold a reference before calling
drbd_bm_write()
drbd_bm_write_page()
Use get_ldev() instead of get_ldev_if_state(device, D_ATTACHING)
drbd_bmio_set_n_write()
No longer use get_ldev_if_state(device, D_ATTACHING). All callers
hold a reference to ldev now.
drbd_bmio_clear_n_write()
All callers where holding a reference of ldev anyways. Remove the
misleading get_ldev_if_state(device, D_ATTACHING)
drbd_reconsider_max_bio_size()
Removed the get_ldev_if_state(device, D_ATTACHING). All callers
now pass a struct drbd_backing_dev* when they have a proper
reference, or a NULL pointer.
Before this fix, the receiver could trigger a NULL pointer
deref when in drbd_reconsider_max_bio_size()
drbd_bump_write_ordering()
Used get_ldev_if_state(device, D_ATTACHING) with the wrong assumption.
Remove it, and allow the caller to pass in a struct drbd_backing_dev*
when the caller knows that accessing this bdev is safe.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2013-11-22 16:22:13 +04:00
|
|
|
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);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* Meta data layout
|
2013-03-19 21:16:43 +04:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2013-03-19 21:16:43 +04:00
|
|
|
/* Our old fixed size meta data layout
|
|
|
|
* allows up to about 3.8TB, so if you want more,
|
2011-02-21 15:21:03 +03:00
|
|
|
* you need to use the "flexible" meta data format. */
|
2013-03-19 21:16:43 +04:00
|
|
|
#define MD_128MB_SECT (128LLU << 11) /* 128 MB, unit sectors */
|
|
|
|
#define MD_4kB_SECT 8
|
|
|
|
#define MD_32kB_SECT 64
|
2011-02-21 15:21:03 +03:00
|
|
|
|
|
|
|
/* One activity log extent represents 4M of storage */
|
|
|
|
#define AL_EXTENT_SHIFT 22
|
2009-09-26 03:07:19 +04:00
|
|
|
#define AL_EXTENT_SIZE (1<<AL_EXTENT_SHIFT)
|
|
|
|
|
2011-02-21 15:21:03 +03:00
|
|
|
/* 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
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
#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. */
|
2010-11-07 17:56:29 +03:00
|
|
|
#define BME_PRIORITY 2 /* finish resync IO on this extent ASAP! App IO waiting! */
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
|
2010-07-06 19:25:54 +04:00
|
|
|
#define SLEEP_TIME (HZ/10)
|
|
|
|
|
2011-02-21 15:21:00 +03:00
|
|
|
/* 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 */
|
2009-09-26 03:07:19 +04:00
|
|
|
#define BM_BLOCK_SIZE (1<<BM_BLOCK_SHIFT)
|
2011-02-21 15:21:00 +03:00
|
|
|
/* 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 */
|
2009-09-26 03:07:19 +04:00
|
|
|
#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))
|
drbd: fix resync finished detection
This fixes one recent regresion,
and one long existing bug.
The bug:
drbd_try_clear_on_disk_bm() assumed that all "count" bits have to be
accounted in the resync extent corresponding to the start sector.
Since we allow application requests to cross our "extent" boundaries,
this assumption is no longer true, resulting in possible misaccounting,
scary messages
("BAD! sector=12345s enr=6 rs_left=-7 rs_failed=0 count=58 cstate=..."),
and potentially, if the last bit to be cleared during resync would
reside in previously misaccounted resync extent, the resync would never
be recognized as finished, but would be "stalled" forever, even though
all blocks are in sync again and all bits have been cleared...
The regression was introduced by
drbd: get rid of atomic update on disk bitmap works
For an "empty" resync (rs_total == 0), we must not "finish" the
resync on the SyncSource before the SyncTarget knows all relevant
information (sync uuid). We need to wait for the full round-trip,
the SyncTarget will then explicitly notify us.
Also for normal, non-empty resyncs (rs_total > 0), the resync-finished
condition needs to be tested before the schedule() in wait_for_work, or
it is likely to be missed.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2014-01-27 18:58:22 +04:00
|
|
|
#define BM_BIT_TO_EXT(x) ((x) >> (BM_EXT_SHIFT - BM_BLOCK_SHIFT))
|
2009-09-26 03:07:19 +04:00
|
|
|
|
drbd: fix resync finished detection
This fixes one recent regresion,
and one long existing bug.
The bug:
drbd_try_clear_on_disk_bm() assumed that all "count" bits have to be
accounted in the resync extent corresponding to the start sector.
Since we allow application requests to cross our "extent" boundaries,
this assumption is no longer true, resulting in possible misaccounting,
scary messages
("BAD! sector=12345s enr=6 rs_left=-7 rs_failed=0 count=58 cstate=..."),
and potentially, if the last bit to be cleared during resync would
reside in previously misaccounted resync extent, the resync would never
be recognized as finished, but would be "stalled" forever, even though
all blocks are in sync again and all bits have been cleared...
The regression was introduced by
drbd: get rid of atomic update on disk bitmap works
For an "empty" resync (rs_total == 0), we must not "finish" the
resync on the SyncSource before the SyncTarget knows all relevant
information (sync uuid). We need to wait for the full round-trip,
the SyncTarget will then explicitly notify us.
Also for normal, non-empty resyncs (rs_total > 0), the resync-finished
condition needs to be tested before the schedule() in wait_for_work, or
it is likely to be missed.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2014-01-27 18:58:22 +04:00
|
|
|
/* first storage sector a bitmap extent corresponds to */
|
2009-09-26 03:07:19 +04:00
|
|
|
#define BM_EXT_TO_SECT(x) ((sector_t)(x) << (BM_EXT_SHIFT-9))
|
drbd: fix resync finished detection
This fixes one recent regresion,
and one long existing bug.
The bug:
drbd_try_clear_on_disk_bm() assumed that all "count" bits have to be
accounted in the resync extent corresponding to the start sector.
Since we allow application requests to cross our "extent" boundaries,
this assumption is no longer true, resulting in possible misaccounting,
scary messages
("BAD! sector=12345s enr=6 rs_left=-7 rs_failed=0 count=58 cstate=..."),
and potentially, if the last bit to be cleared during resync would
reside in previously misaccounted resync extent, the resync would never
be recognized as finished, but would be "stalled" forever, even though
all blocks are in sync again and all bits have been cleared...
The regression was introduced by
drbd: get rid of atomic update on disk bitmap works
For an "empty" resync (rs_total == 0), we must not "finish" the
resync on the SyncSource before the SyncTarget knows all relevant
information (sync uuid). We need to wait for the full round-trip,
the SyncTarget will then explicitly notify us.
Also for normal, non-empty resyncs (rs_total > 0), the resync-finished
condition needs to be tested before the schedule() in wait_for_work, or
it is likely to be missed.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2014-01-27 18:58:22 +04:00
|
|
|
/* how much _storage_ sectors we have per bitmap extent */
|
2009-09-26 03:07:19 +04:00
|
|
|
#define BM_SECT_PER_EXT BM_EXT_TO_SECT(1)
|
drbd: fix resync finished detection
This fixes one recent regresion,
and one long existing bug.
The bug:
drbd_try_clear_on_disk_bm() assumed that all "count" bits have to be
accounted in the resync extent corresponding to the start sector.
Since we allow application requests to cross our "extent" boundaries,
this assumption is no longer true, resulting in possible misaccounting,
scary messages
("BAD! sector=12345s enr=6 rs_left=-7 rs_failed=0 count=58 cstate=..."),
and potentially, if the last bit to be cleared during resync would
reside in previously misaccounted resync extent, the resync would never
be recognized as finished, but would be "stalled" forever, even though
all blocks are in sync again and all bits have been cleared...
The regression was introduced by
drbd: get rid of atomic update on disk bitmap works
For an "empty" resync (rs_total == 0), we must not "finish" the
resync on the SyncSource before the SyncTarget knows all relevant
information (sync uuid). We need to wait for the full round-trip,
the SyncTarget will then explicitly notify us.
Also for normal, non-empty resyncs (rs_total > 0), the resync-finished
condition needs to be tested before the schedule() in wait_for_work, or
it is likely to be missed.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2014-01-27 18:58:22 +04:00
|
|
|
/* 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)
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* 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)
|
2013-03-19 21:16:43 +04:00
|
|
|
/* 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
|
2009-09-26 03:07:19 +04:00
|
|
|
#define DRBD_MAX_SECTORS DRBD_MAX_SECTORS_32
|
|
|
|
#define DRBD_MAX_SECTORS_FLEX DRBD_MAX_SECTORS_32
|
|
|
|
#else
|
2013-03-19 21:16:43 +04:00
|
|
|
#define DRBD_MAX_SECTORS DRBD_MAX_SECTORS_FIXED_BM
|
2009-09-26 03:07:19 +04:00
|
|
|
/* 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
|
2010-12-14 17:13:04 +03:00
|
|
|
/* 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. */
|
2009-09-26 03:07:19 +04:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2016-05-30 16:34:35 +03:00
|
|
|
/* Estimate max bio size as 256 * PAGE_SIZE,
|
2016-04-01 15:29:48 +03:00
|
|
|
* so for typical PAGE_SIZE of 4k, that is (1<<20) Byte.
|
2011-03-31 18:36:43 +04:00
|
|
|
* 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. */
|
2012-11-09 17:18:43 +04:00
|
|
|
#define DRBD_MAX_BIO_SIZE (1U << 20)
|
2016-05-30 16:34:35 +03:00
|
|
|
#if DRBD_MAX_BIO_SIZE > (BIO_MAX_PAGES << PAGE_SHIFT)
|
2011-03-31 18:36:43 +04:00
|
|
|
#error Architecture not supported: DRBD_MAX_BIO_SIZE > BIO_MAX_SIZE
|
|
|
|
#endif
|
2012-06-25 21:15:58 +04:00
|
|
|
#define DRBD_MAX_BIO_SIZE_SAFE (1U << 12) /* Works always = 4k */
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2012-11-09 17:18:43 +04:00
|
|
|
#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 */
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2016-06-14 01:26:23 +03:00
|
|
|
/* 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 */
|
2016-06-14 01:26:31 +03:00
|
|
|
#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)
|
2014-04-28 20:43:23 +04:00
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
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);
|
2010-12-14 17:13:04 +03:00
|
|
|
/* set/clear/test only a few bits at a time */
|
2009-09-26 03:07:19 +04:00
|
|
|
extern int drbd_bm_set_bits(
|
2011-07-03 15:26:43 +04:00
|
|
|
struct drbd_device *device, unsigned long s, unsigned long e);
|
2009-09-26 03:07:19 +04:00
|
|
|
extern int drbd_bm_clear_bits(
|
2011-07-03 15:26:43 +04:00
|
|
|
struct drbd_device *device, unsigned long s, unsigned long e);
|
2010-12-14 17:13:04 +03:00
|
|
|
extern int drbd_bm_count_bits(
|
2011-07-03 15:26:43 +04:00
|
|
|
struct drbd_device *device, const unsigned long s, const unsigned long e);
|
2010-12-14 17:13:04 +03:00
|
|
|
/* bm_set_bits variant for use while holding drbd_bm_lock,
|
|
|
|
* may process the whole bitmap in one go */
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void _drbd_bm_set_bits(struct drbd_device *device,
|
2009-09-26 03:07:19 +04:00
|
|
|
const unsigned long s, const unsigned long e);
|
2011-07-03 15:26:43 +04:00
|
|
|
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);
|
2016-06-14 01:26:38 +03:00
|
|
|
extern void drbd_bm_reset_al_hints(struct drbd_device *device) __must_hold(local);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern int drbd_bm_write_hinted(struct drbd_device *device) __must_hold(local);
|
2013-12-20 14:39:48 +04:00
|
|
|
extern int drbd_bm_write_lazy(struct drbd_device *device, unsigned upper_idx) __must_hold(local);
|
2011-07-03 15:26:43 +04:00
|
|
|
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);
|
2010-12-14 17:13:04 +03:00
|
|
|
|
|
|
|
#define DRBD_END_OF_BITMAP (~(unsigned long)0)
|
2011-07-03 15:26:43 +04:00
|
|
|
extern unsigned long drbd_bm_find_next(struct drbd_device *device, unsigned long bm_fo);
|
2009-09-26 03:07:19 +04:00
|
|
|
/* bm_find_next variants for use while you hold drbd_bm_lock() */
|
2011-07-03 15:26:43 +04:00
|
|
|
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);
|
2009-09-26 03:07:19 +04:00
|
|
|
/* for receive_bitmap */
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_bm_merge_lel(struct drbd_device *device, size_t offset,
|
2009-09-26 03:07:19 +04:00
|
|
|
size_t number, unsigned long *buffer);
|
2010-12-15 10:59:11 +03:00
|
|
|
/* for _drbd_send_bitmap */
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_bm_get_lel(struct drbd_device *device, size_t offset,
|
2009-09-26 03:07:19 +04:00
|
|
|
size_t number, unsigned long *buffer);
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_bm_lock(struct drbd_device *device, char *why, enum bm_flag flags);
|
|
|
|
extern void drbd_bm_unlock(struct drbd_device *device);
|
2009-09-26 03:07:19 +04:00
|
|
|
/* drbd_main.c */
|
|
|
|
|
|
|
|
extern struct kmem_cache *drbd_request_cache;
|
2011-02-04 17:38:52 +03:00
|
|
|
extern struct kmem_cache *drbd_ee_cache; /* peer requests */
|
2009-09-26 03:07:19 +04:00
|
|
|
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;
|
|
|
|
|
2011-02-23 14:39:46 +03:00
|
|
|
/* 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;
|
2009-09-26 03:07:19 +04:00
|
|
|
extern spinlock_t drbd_pp_lock;
|
|
|
|
extern int drbd_pp_vacant;
|
|
|
|
extern wait_queue_head_t drbd_pp_wait;
|
|
|
|
|
2011-02-23 14:39:46 +03:00
|
|
|
/* 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;
|
|
|
|
|
2011-02-23 19:02:01 +03:00
|
|
|
/* 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);
|
|
|
|
|
2017-06-18 07:38:58 +03:00
|
|
|
/* And a bio_set for cloning */
|
|
|
|
extern struct bio_set *drbd_io_bio_set;
|
|
|
|
|
2014-08-14 20:33:30 +04:00
|
|
|
extern struct mutex resources_mutex;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-05-30 18:32:41 +04:00
|
|
|
extern int conn_lowest_minor(struct drbd_connection *connection);
|
2014-04-28 20:43:21 +04:00
|
|
|
extern enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsigned int minor);
|
2011-06-08 00:54:17 +04:00
|
|
|
extern void drbd_destroy_device(struct kref *kref);
|
2014-04-28 20:43:21 +04:00
|
|
|
extern void drbd_delete_device(struct drbd_device *device);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-06-09 00:17:38 +04:00
|
|
|
extern struct drbd_resource *drbd_create_resource(const char *name);
|
|
|
|
extern void drbd_free_resource(struct drbd_resource *resource);
|
|
|
|
|
2011-06-21 18:11:28 +04:00
|
|
|
extern int set_resource_options(struct drbd_resource *resource, struct res_opts *res_opts);
|
2011-05-30 18:32:41 +04:00
|
|
|
extern struct drbd_connection *conn_create(const char *name, struct res_opts *res_opts);
|
2011-06-08 00:54:17 +04:00
|
|
|
extern void drbd_destroy_connection(struct kref *kref);
|
2011-05-30 18:32:41 +04:00
|
|
|
extern struct drbd_connection *conn_get_by_addrs(void *my_addr, int my_addr_len,
|
2011-06-14 20:28:09 +04:00
|
|
|
void *peer_addr, int peer_addr_len);
|
2011-06-13 16:27:45 +04:00
|
|
|
extern struct drbd_resource *drbd_find_resource(const char *name);
|
2011-06-09 00:17:38 +04:00
|
|
|
extern void drbd_destroy_resource(struct kref *kref);
|
2011-05-30 18:32:41 +04:00
|
|
|
extern void conn_free_crypto(struct drbd_connection *connection);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* drbd_req */
|
2013-03-23 04:14:40 +04:00
|
|
|
extern void do_submit(struct work_struct *ws);
|
2011-05-30 18:15:21 +04:00
|
|
|
extern void __drbd_make_request(struct drbd_device *, struct bio *, unsigned long);
|
2015-11-05 20:41:16 +03:00
|
|
|
extern blk_qc_t drbd_make_request(struct request_queue *q, struct bio *bio);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern int drbd_read_remote(struct drbd_device *device, struct drbd_request *req);
|
2009-09-26 03:07:19 +04:00
|
|
|
extern int is_valid_ar_handle(struct drbd_request *, sector_t);
|
|
|
|
|
|
|
|
|
|
|
|
/* drbd_nl.c */
|
2014-07-31 19:41:33 +04:00
|
|
|
|
|
|
|
extern struct mutex notification_mutex;
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_suspend_io(struct drbd_device *device);
|
|
|
|
extern void drbd_resume_io(struct drbd_device *device);
|
2009-09-26 03:07:19 +04:00
|
|
|
extern char *ppsize(char *buf, unsigned long long size);
|
2011-05-30 18:15:21 +04:00
|
|
|
extern sector_t drbd_new_dev_size(struct drbd_device *, struct drbd_backing_dev *, sector_t, int);
|
2013-06-25 18:50:07 +04:00
|
|
|
enum determine_dev_size {
|
2013-06-25 18:50:08 +04:00
|
|
|
DS_ERROR_SHRINK = -3,
|
|
|
|
DS_ERROR_SPACE_MD = -2,
|
2013-06-25 18:50:07 +04:00
|
|
|
DS_ERROR = -1,
|
|
|
|
DS_UNCHANGED = 0,
|
|
|
|
DS_SHRUNK = 1,
|
2013-10-23 12:59:17 +04:00
|
|
|
DS_GREW = 2,
|
|
|
|
DS_GREW_FROM_ZERO = 3,
|
2013-06-25 18:50:07 +04:00
|
|
|
};
|
2013-06-25 18:50:08 +04:00
|
|
|
extern enum determine_dev_size
|
2011-05-30 18:15:21 +04:00
|
|
|
drbd_determine_dev_size(struct drbd_device *, enum dds_flags, struct resize_parms *) __must_hold(local);
|
|
|
|
extern void resync_after_online_grow(struct drbd_device *);
|
2016-06-14 01:26:31 +03:00
|
|
|
extern void drbd_reconsider_queue_parameters(struct drbd_device *device,
|
|
|
|
struct drbd_backing_dev *bdev, struct o_qlim *o);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern enum drbd_state_rv drbd_set_role(struct drbd_device *device,
|
2010-12-08 02:39:32 +03:00
|
|
|
enum drbd_role new_role,
|
|
|
|
int force);
|
2011-05-30 18:32:41 +04:00
|
|
|
extern bool conn_try_outdate_peer(struct drbd_connection *connection);
|
|
|
|
extern void conn_try_outdate_peer_async(struct drbd_connection *connection);
|
2016-06-14 01:26:35 +03:00
|
|
|
extern enum drbd_peer_state conn_khelper(struct drbd_connection *connection, char *cmd);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern int drbd_khelper(struct drbd_device *device, char *cmd);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* drbd_worker.c */
|
2014-04-28 20:43:14 +04:00
|
|
|
/* bi_end_io handlers */
|
2015-07-20 16:29:37 +03:00
|
|
|
extern void drbd_md_endio(struct bio *bio);
|
|
|
|
extern void drbd_peer_request_endio(struct bio *bio);
|
|
|
|
extern void drbd_request_endio(struct bio *bio);
|
2009-09-26 03:07:19 +04:00
|
|
|
extern int drbd_worker(struct drbd_thread *thi);
|
2011-07-03 15:26:43 +04:00
|
|
|
enum drbd_ret_code drbd_resync_after_valid(struct drbd_device *device, int o_minor);
|
|
|
|
void drbd_resync_after_changed(struct drbd_device *device);
|
|
|
|
extern void drbd_start_resync(struct drbd_device *device, enum drbd_conns side);
|
|
|
|
extern void resume_next_sg(struct drbd_device *device);
|
|
|
|
extern void suspend_other_sg(struct drbd_device *device);
|
|
|
|
extern int drbd_resync_finished(struct drbd_device *device);
|
2009-09-26 03:07:19 +04:00
|
|
|
/* maybe rather drbd_main.c ? */
|
2014-04-02 01:53:30 +04:00
|
|
|
extern void *drbd_md_get_buffer(struct drbd_device *device, const char *intent);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_md_put_buffer(struct drbd_device *device);
|
|
|
|
extern int drbd_md_sync_page_io(struct drbd_device *device,
|
2016-06-05 22:32:06 +03:00
|
|
|
struct drbd_backing_dev *bdev, sector_t sector, int op);
|
2011-05-30 18:15:21 +04:00
|
|
|
extern void drbd_ov_out_of_sync_found(struct drbd_device *, sector_t, int);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void wait_until_done_or_force_detached(struct drbd_device *device,
|
2012-09-27 15:03:45 +04:00
|
|
|
struct drbd_backing_dev *bdev, unsigned int *done);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_rs_controller_reset(struct drbd_device *device);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void ov_out_of_sync_print(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
if (device->ov_last_oos_size) {
|
2011-07-03 19:53:52 +04:00
|
|
|
drbd_err(device, "Out of sync: start=%llu, size=%lu (sectors)\n",
|
2011-07-03 15:26:43 +04:00
|
|
|
(unsigned long long)device->ov_last_oos_start,
|
|
|
|
(unsigned long)device->ov_last_oos_size);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
2011-07-03 15:26:43 +04:00
|
|
|
device->ov_last_oos_size = 0;
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-24 16:19:21 +03:00
|
|
|
extern void drbd_csum_bio(struct crypto_ahash *, struct bio *, void *);
|
|
|
|
extern void drbd_csum_ee(struct crypto_ahash *, struct drbd_peer_request *, void *);
|
2009-09-26 03:07:19 +04:00
|
|
|
/* worker callbacks */
|
2011-03-16 17:31:39 +03:00
|
|
|
extern int w_e_end_data_req(struct drbd_work *, int);
|
|
|
|
extern int w_e_end_rsdata_req(struct drbd_work *, int);
|
|
|
|
extern int w_e_end_csum_rs_req(struct drbd_work *, int);
|
|
|
|
extern int w_e_end_ov_reply(struct drbd_work *, int);
|
|
|
|
extern int w_e_end_ov_req(struct drbd_work *, int);
|
|
|
|
extern int w_ov_finished(struct drbd_work *, int);
|
|
|
|
extern int w_resync_timer(struct drbd_work *, int);
|
|
|
|
extern int w_send_write_hint(struct drbd_work *, int);
|
|
|
|
extern int w_send_dblock(struct drbd_work *, int);
|
|
|
|
extern int w_send_read_req(struct drbd_work *, int);
|
|
|
|
extern int w_e_reissue(struct drbd_work *, int);
|
|
|
|
extern int w_restart_disk_io(struct drbd_work *, int);
|
2010-12-20 01:53:14 +03:00
|
|
|
extern int w_send_out_of_sync(struct drbd_work *, int);
|
2011-03-16 17:31:39 +03:00
|
|
|
extern int w_start_resync(struct drbd_work *, int);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2017-10-18 06:33:01 +03:00
|
|
|
extern void resync_timer_fn(struct timer_list *t);
|
|
|
|
extern void start_resync_timer_fn(struct timer_list *t);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2014-04-28 20:43:23 +04:00
|
|
|
extern void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req);
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
/* drbd_receiver.c */
|
2011-07-22 13:14:41 +04:00
|
|
|
extern int drbd_receiver(struct drbd_thread *thi);
|
2015-03-16 17:01:00 +03:00
|
|
|
extern int drbd_ack_receiver(struct drbd_thread *thi);
|
2015-03-16 18:08:29 +03:00
|
|
|
extern void drbd_send_ping_wf(struct work_struct *ws);
|
|
|
|
extern void drbd_send_acks_wf(struct work_struct *ws);
|
2014-04-28 20:43:19 +04:00
|
|
|
extern bool drbd_rs_c_min_rate_throttle(struct drbd_device *device);
|
2013-12-20 14:22:13 +04:00
|
|
|
extern bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector,
|
|
|
|
bool throttle_if_app_is_waiting);
|
2011-05-30 18:15:21 +04:00
|
|
|
extern int drbd_submit_peer_request(struct drbd_device *,
|
2011-02-17 18:38:35 +03:00
|
|
|
struct drbd_peer_request *, const unsigned,
|
2016-06-05 22:32:06 +03:00
|
|
|
const unsigned, const int);
|
2011-05-30 18:15:21 +04:00
|
|
|
extern int drbd_free_peer_reqs(struct drbd_device *, struct list_head *);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern struct drbd_peer_request *drbd_alloc_peer_req(struct drbd_peer_device *, u64,
|
2011-04-06 18:09:15 +04:00
|
|
|
sector_t, unsigned int,
|
2016-06-14 01:26:31 +03:00
|
|
|
unsigned int,
|
2011-04-06 18:09:15 +04:00
|
|
|
gfp_t) __must_hold(local);
|
2011-05-30 18:15:21 +04:00
|
|
|
extern void __drbd_free_peer_req(struct drbd_device *, struct drbd_peer_request *,
|
2011-04-06 18:16:56 +04:00
|
|
|
int);
|
|
|
|
#define drbd_free_peer_req(m,e) __drbd_free_peer_req(m, e, 0)
|
|
|
|
#define drbd_free_net_peer_req(m,e) __drbd_free_peer_req(m, e, 1)
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern struct page *drbd_alloc_pages(struct drbd_peer_device *, unsigned int, bool);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_set_recv_tcq(struct drbd_device *device, int tcq_enabled);
|
|
|
|
extern void _drbd_clear_done_ee(struct drbd_device *device, struct list_head *to_be_freed);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern int drbd_connected(struct drbd_peer_device *);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
static inline void drbd_tcp_cork(struct socket *sock)
|
|
|
|
{
|
2011-04-23 16:45:14 +04:00
|
|
|
int val = 1;
|
2014-11-10 19:21:15 +03:00
|
|
|
(void) kernel_setsockopt(sock, SOL_TCP, TCP_CORK,
|
2011-04-23 16:45:14 +04:00
|
|
|
(char*)&val, sizeof(val));
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void drbd_tcp_uncork(struct socket *sock)
|
|
|
|
{
|
2011-04-23 16:45:14 +04:00
|
|
|
int val = 0;
|
2014-11-10 19:21:15 +03:00
|
|
|
(void) kernel_setsockopt(sock, SOL_TCP, TCP_CORK,
|
2011-04-23 16:45:14 +04:00
|
|
|
(char*)&val, sizeof(val));
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void drbd_tcp_nodelay(struct socket *sock)
|
|
|
|
{
|
2011-04-23 16:45:14 +04:00
|
|
|
int val = 1;
|
2014-11-10 19:21:15 +03:00
|
|
|
(void) kernel_setsockopt(sock, SOL_TCP, TCP_NODELAY,
|
2011-04-23 16:45:14 +04:00
|
|
|
(char*)&val, sizeof(val));
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void drbd_tcp_quickack(struct socket *sock)
|
|
|
|
{
|
2011-04-23 16:45:14 +04:00
|
|
|
int val = 2;
|
2014-11-10 19:21:15 +03:00
|
|
|
(void) kernel_setsockopt(sock, SOL_TCP, TCP_QUICKACK,
|
2011-04-23 16:45:14 +04:00
|
|
|
(char*)&val, sizeof(val));
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2014-04-28 20:43:14 +04:00
|
|
|
/* sets the number of 512 byte sectors of our virtual device */
|
|
|
|
static inline void drbd_set_my_capacity(struct drbd_device *device,
|
|
|
|
sector_t size)
|
|
|
|
{
|
|
|
|
/* set_capacity(device->this_bdev->bd_disk, size); */
|
|
|
|
set_capacity(device->vdisk, size);
|
|
|
|
device->this_bdev->bd_inode->i_size = (loff_t)size << 9;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* used to submit our private bio
|
|
|
|
*/
|
|
|
|
static inline void drbd_generic_make_request(struct drbd_device *device,
|
|
|
|
int fault_type, struct bio *bio)
|
|
|
|
{
|
|
|
|
__release(local);
|
2017-08-23 20:10:32 +03:00
|
|
|
if (!bio->bi_disk) {
|
|
|
|
drbd_err(device, "drbd_generic_make_request: bio->bi_disk == NULL\n");
|
2017-06-03 10:38:06 +03:00
|
|
|
bio->bi_status = BLK_STS_IOERR;
|
2015-07-20 16:29:37 +03:00
|
|
|
bio_endio(bio);
|
2014-04-28 20:43:14 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (drbd_insert_fault(device, fault_type))
|
2015-07-20 16:29:37 +03:00
|
|
|
bio_io_error(bio);
|
2014-04-28 20:43:14 +04:00
|
|
|
else
|
|
|
|
generic_make_request(bio);
|
|
|
|
}
|
|
|
|
|
drbd: device->ldev is not guaranteed on an D_ATTACHING disk
Some parts of the code assumed that get_ldev_if_state(device, D_ATTACHING)
is sufficient to access the ldev member of the device object. That was
wrong. ldev may not be there or might be freed at any time if the device
has a disk state of D_ATTACHING.
bm_rw()
Documented that drbd_bm_read() is only called from drbd_adm_attach.
drbd_bm_write() is only called when a reference is held, and it is
documented that a caller has to hold a reference before calling
drbd_bm_write()
drbd_bm_write_page()
Use get_ldev() instead of get_ldev_if_state(device, D_ATTACHING)
drbd_bmio_set_n_write()
No longer use get_ldev_if_state(device, D_ATTACHING). All callers
hold a reference to ldev now.
drbd_bmio_clear_n_write()
All callers where holding a reference of ldev anyways. Remove the
misleading get_ldev_if_state(device, D_ATTACHING)
drbd_reconsider_max_bio_size()
Removed the get_ldev_if_state(device, D_ATTACHING). All callers
now pass a struct drbd_backing_dev* when they have a proper
reference, or a NULL pointer.
Before this fix, the receiver could trigger a NULL pointer
deref when in drbd_reconsider_max_bio_size()
drbd_bump_write_ordering()
Used get_ldev_if_state(device, D_ATTACHING) with the wrong assumption.
Remove it, and allow the caller to pass in a struct drbd_backing_dev*
when the caller knows that accessing this bdev is safe.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2013-11-22 16:22:13 +04:00
|
|
|
void drbd_bump_write_ordering(struct drbd_resource *resource, struct drbd_backing_dev *bdev,
|
|
|
|
enum write_ordering_e wo);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* drbd_proc.c */
|
|
|
|
extern struct proc_dir_entry *drbd_proc;
|
2009-12-14 02:59:30 +03:00
|
|
|
extern const struct file_operations drbd_proc_fops;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* drbd_actlog.c */
|
2014-04-28 20:43:28 +04:00
|
|
|
extern bool drbd_al_begin_io_prepare(struct drbd_device *device, struct drbd_interval *i);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern int drbd_al_begin_io_nonblock(struct drbd_device *device, struct drbd_interval *i);
|
2014-02-11 14:15:36 +04:00
|
|
|
extern void drbd_al_begin_io_commit(struct drbd_device *device);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern bool drbd_al_begin_io_fastpath(struct drbd_device *device, struct drbd_interval *i);
|
2014-02-11 14:15:36 +04:00
|
|
|
extern void drbd_al_begin_io(struct drbd_device *device, struct drbd_interval *i);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_al_complete_io(struct drbd_device *device, struct drbd_interval *i);
|
|
|
|
extern void drbd_rs_complete_io(struct drbd_device *device, sector_t sector);
|
|
|
|
extern int drbd_rs_begin_io(struct drbd_device *device, sector_t sector);
|
|
|
|
extern int drbd_try_rs_begin_io(struct drbd_device *device, sector_t sector);
|
|
|
|
extern void drbd_rs_cancel_all(struct drbd_device *device);
|
|
|
|
extern int drbd_rs_del_all(struct drbd_device *device);
|
|
|
|
extern void drbd_rs_failed_io(struct drbd_device *device,
|
2009-09-26 03:07:19 +04:00
|
|
|
sector_t sector, int size);
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_advance_rs_marks(struct drbd_device *device, unsigned long still_to_go);
|
drbd: fix resync finished detection
This fixes one recent regresion,
and one long existing bug.
The bug:
drbd_try_clear_on_disk_bm() assumed that all "count" bits have to be
accounted in the resync extent corresponding to the start sector.
Since we allow application requests to cross our "extent" boundaries,
this assumption is no longer true, resulting in possible misaccounting,
scary messages
("BAD! sector=12345s enr=6 rs_left=-7 rs_failed=0 count=58 cstate=..."),
and potentially, if the last bit to be cleared during resync would
reside in previously misaccounted resync extent, the resync would never
be recognized as finished, but would be "stalled" forever, even though
all blocks are in sync again and all bits have been cleared...
The regression was introduced by
drbd: get rid of atomic update on disk bitmap works
For an "empty" resync (rs_total == 0), we must not "finish" the
resync on the SyncSource before the SyncTarget knows all relevant
information (sync uuid). We need to wait for the full round-trip,
the SyncTarget will then explicitly notify us.
Also for normal, non-empty resyncs (rs_total > 0), the resync-finished
condition needs to be tested before the schedule() in wait_for_work, or
it is likely to be missed.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2014-01-27 18:58:22 +04:00
|
|
|
|
|
|
|
enum update_sync_bits_mode { RECORD_RS_FAILED, SET_OUT_OF_SYNC, SET_IN_SYNC };
|
|
|
|
extern int __drbd_change_sync(struct drbd_device *device, sector_t sector, int size,
|
2014-11-10 19:21:09 +03:00
|
|
|
enum update_sync_bits_mode mode);
|
2011-07-03 15:26:43 +04:00
|
|
|
#define drbd_set_in_sync(device, sector, size) \
|
2014-11-10 19:21:09 +03:00
|
|
|
__drbd_change_sync(device, sector, size, SET_IN_SYNC)
|
2011-07-03 15:26:43 +04:00
|
|
|
#define drbd_set_out_of_sync(device, sector, size) \
|
2014-11-10 19:21:09 +03:00
|
|
|
__drbd_change_sync(device, sector, size, SET_OUT_OF_SYNC)
|
drbd: fix resync finished detection
This fixes one recent regresion,
and one long existing bug.
The bug:
drbd_try_clear_on_disk_bm() assumed that all "count" bits have to be
accounted in the resync extent corresponding to the start sector.
Since we allow application requests to cross our "extent" boundaries,
this assumption is no longer true, resulting in possible misaccounting,
scary messages
("BAD! sector=12345s enr=6 rs_left=-7 rs_failed=0 count=58 cstate=..."),
and potentially, if the last bit to be cleared during resync would
reside in previously misaccounted resync extent, the resync would never
be recognized as finished, but would be "stalled" forever, even though
all blocks are in sync again and all bits have been cleared...
The regression was introduced by
drbd: get rid of atomic update on disk bitmap works
For an "empty" resync (rs_total == 0), we must not "finish" the
resync on the SyncSource before the SyncTarget knows all relevant
information (sync uuid). We need to wait for the full round-trip,
the SyncTarget will then explicitly notify us.
Also for normal, non-empty resyncs (rs_total > 0), the resync-finished
condition needs to be tested before the schedule() in wait_for_work, or
it is likely to be missed.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2014-01-27 18:58:22 +04:00
|
|
|
#define drbd_rs_failed_io(device, sector, size) \
|
2014-11-10 19:21:09 +03:00
|
|
|
__drbd_change_sync(device, sector, size, RECORD_RS_FAILED)
|
2011-07-03 15:26:43 +04:00
|
|
|
extern void drbd_al_shrink(struct drbd_device *device);
|
drbd: avoid potential deadlock during handshake
During handshake communication, we also reconsider our device size,
using drbd_determine_dev_size(). Just in case we need to change the
offsets or layout of our on-disk metadata, we lock out application
and other meta data IO, and wait for the activity log to be "idle"
(no more referenced extents).
If this handshake happens just after a connection loss, with a fencing
policy of "resource-and-stonith", we have frozen IO.
If, additionally, the activity log was "starving" (too many incoming
random writes at that point in time), it won't become idle, ever,
because of the frozen IO, and this would be a lockup of the receiver
thread, and consquentially of DRBD.
Previous logic (re-)initialized with a special "empty" transaction
block, which required the activity log to fully drain first.
Instead, write out some standard activity log transactions.
Using lc_try_lock_for_transaction() instead of lc_try_lock() does not
care about pending activity log references, avoiding the potential
deadlock.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-06-08 16:18:45 +03:00
|
|
|
extern int drbd_al_initialize(struct drbd_device *, void *);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* drbd_nl.c */
|
2011-03-07 14:49:34 +03:00
|
|
|
/* state info broadcast */
|
|
|
|
struct sib_info {
|
|
|
|
enum drbd_state_info_bcast_reason sib_reason;
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
char *helper_name;
|
|
|
|
unsigned helper_exit_code;
|
|
|
|
};
|
|
|
|
struct {
|
|
|
|
union drbd_state os;
|
|
|
|
union drbd_state ns;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
2011-07-03 15:26:43 +04:00
|
|
|
void drbd_bcast_event(struct drbd_device *device, const struct sib_info *sib);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2014-07-31 19:41:33 +04:00
|
|
|
extern void notify_resource_state(struct sk_buff *,
|
|
|
|
unsigned int,
|
|
|
|
struct drbd_resource *,
|
|
|
|
struct resource_info *,
|
|
|
|
enum drbd_notification_type);
|
|
|
|
extern void notify_device_state(struct sk_buff *,
|
|
|
|
unsigned int,
|
|
|
|
struct drbd_device *,
|
|
|
|
struct device_info *,
|
|
|
|
enum drbd_notification_type);
|
|
|
|
extern void notify_connection_state(struct sk_buff *,
|
|
|
|
unsigned int,
|
|
|
|
struct drbd_connection *,
|
|
|
|
struct connection_info *,
|
|
|
|
enum drbd_notification_type);
|
|
|
|
extern void notify_peer_device_state(struct sk_buff *,
|
|
|
|
unsigned int,
|
|
|
|
struct drbd_peer_device *,
|
|
|
|
struct peer_device_info *,
|
|
|
|
enum drbd_notification_type);
|
|
|
|
extern void notify_helper(enum drbd_notification_type, struct drbd_device *,
|
|
|
|
struct drbd_connection *, const char *, int);
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
/*
|
|
|
|
* inline helper functions
|
|
|
|
*************************/
|
|
|
|
|
2010-05-14 19:10:48 +04:00
|
|
|
/* see also page_chain_add and friends in drbd_receiver.c */
|
|
|
|
static inline struct page *page_chain_next(struct page *page)
|
|
|
|
{
|
|
|
|
return (struct page *)page_private(page);
|
|
|
|
}
|
|
|
|
#define page_chain_for_each(page) \
|
|
|
|
for (; page && ({ prefetch(page_chain_next(page)); 1; }); \
|
|
|
|
page = page_chain_next(page))
|
|
|
|
#define page_chain_for_each_safe(page, n) \
|
|
|
|
for (; page && ({ n = page_chain_next(page); 1; }); page = n)
|
|
|
|
|
|
|
|
|
2011-04-07 23:34:24 +04:00
|
|
|
static inline int drbd_peer_req_has_active_page(struct drbd_peer_request *peer_req)
|
2010-05-14 19:10:48 +04:00
|
|
|
{
|
2011-02-04 17:57:48 +03:00
|
|
|
struct page *page = peer_req->pages;
|
2010-05-14 19:10:48 +04:00
|
|
|
page_chain_for_each(page) {
|
|
|
|
if (page_count(page) > 1)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline union drbd_state drbd_read_state(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-07-08 03:19:44 +04:00
|
|
|
struct drbd_resource *resource = device->resource;
|
2011-03-28 17:40:12 +04:00
|
|
|
union drbd_state rv;
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
rv.i = device->state.i;
|
2011-07-08 03:19:44 +04:00
|
|
|
rv.susp = resource->susp;
|
|
|
|
rv.susp_nod = resource->susp_nod;
|
|
|
|
rv.susp_fen = resource->susp_fen;
|
2011-03-28 17:40:12 +04:00
|
|
|
|
|
|
|
return rv;
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2012-06-14 16:21:32 +04:00
|
|
|
enum drbd_force_detach_flags {
|
drbd: always write bitmap on detach
If we detach due to local read-error (which sets a bit in the bitmap),
stay Primary, and then re-attach (which re-reads the bitmap from disk),
we potentially lost the "out-of-sync" (or, "bad block") information in
the bitmap.
Always (try to) write out the changed bitmap pages before going diskless.
That way, we don't lose the bit for the bad block,
the next resync will fetch it from the peer, and rewrite
it locally, which may result in block reallocation in some
lower layer (or the hardware), and thereby "heal" the bad blocks.
If the bitmap writeout errors out as well, we will (again: try to)
mark the "we need a full sync" bit in our super block,
if it was a READ error; writes are covered by the activity log already.
If that superblock does not make it to disk either, we are sorry.
Maybe we just lost an entire disk or controller (or iSCSI connection),
and there actually are no bad blocks at all, so we don't need to
re-fetch from the peer, there is no "auto-healing" necessary.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-09-22 14:26:57 +04:00
|
|
|
DRBD_READ_ERROR,
|
|
|
|
DRBD_WRITE_ERROR,
|
2012-06-14 16:21:32 +04:00
|
|
|
DRBD_META_IO_ERROR,
|
|
|
|
DRBD_FORCE_DETACH,
|
|
|
|
};
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
#define __drbd_chk_io_error(m,f) __drbd_chk_io_error_(m,f, __func__)
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void __drbd_chk_io_error_(struct drbd_device *device,
|
drbd: always write bitmap on detach
If we detach due to local read-error (which sets a bit in the bitmap),
stay Primary, and then re-attach (which re-reads the bitmap from disk),
we potentially lost the "out-of-sync" (or, "bad block") information in
the bitmap.
Always (try to) write out the changed bitmap pages before going diskless.
That way, we don't lose the bit for the bad block,
the next resync will fetch it from the peer, and rewrite
it locally, which may result in block reallocation in some
lower layer (or the hardware), and thereby "heal" the bad blocks.
If the bitmap writeout errors out as well, we will (again: try to)
mark the "we need a full sync" bit in our super block,
if it was a READ error; writes are covered by the activity log already.
If that superblock does not make it to disk either, we are sorry.
Maybe we just lost an entire disk or controller (or iSCSI connection),
and there actually are no bad blocks at all, so we don't need to
re-fetch from the peer, there is no "auto-healing" necessary.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-09-22 14:26:57 +04:00
|
|
|
enum drbd_force_detach_flags df,
|
2012-06-14 16:21:32 +04:00
|
|
|
const char *where)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-05-03 17:00:55 +04:00
|
|
|
enum drbd_io_error_p ep;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2011-07-03 15:26:43 +04:00
|
|
|
ep = rcu_dereference(device->ldev->disk_conf)->on_io_error;
|
2011-05-03 17:00:55 +04:00
|
|
|
rcu_read_unlock();
|
|
|
|
switch (ep) {
|
|
|
|
case EP_PASS_ON: /* FIXME would this be better named "Ignore"? */
|
drbd: always write bitmap on detach
If we detach due to local read-error (which sets a bit in the bitmap),
stay Primary, and then re-attach (which re-reads the bitmap from disk),
we potentially lost the "out-of-sync" (or, "bad block") information in
the bitmap.
Always (try to) write out the changed bitmap pages before going diskless.
That way, we don't lose the bit for the bad block,
the next resync will fetch it from the peer, and rewrite
it locally, which may result in block reallocation in some
lower layer (or the hardware), and thereby "heal" the bad blocks.
If the bitmap writeout errors out as well, we will (again: try to)
mark the "we need a full sync" bit in our super block,
if it was a READ error; writes are covered by the activity log already.
If that superblock does not make it to disk either, we are sorry.
Maybe we just lost an entire disk or controller (or iSCSI connection),
and there actually are no bad blocks at all, so we don't need to
re-fetch from the peer, there is no "auto-healing" necessary.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-09-22 14:26:57 +04:00
|
|
|
if (df == DRBD_READ_ERROR || df == DRBD_WRITE_ERROR) {
|
2010-05-27 13:51:56 +04:00
|
|
|
if (__ratelimit(&drbd_ratelimit_state))
|
2011-07-03 19:53:52 +04:00
|
|
|
drbd_err(device, "Local IO failed in %s.\n", where);
|
2011-07-03 15:26:43 +04:00
|
|
|
if (device->state.disk > D_INCONSISTENT)
|
|
|
|
_drbd_set_state(_NS(device, disk, D_INCONSISTENT), CS_HARD, NULL);
|
2009-09-26 03:07:19 +04:00
|
|
|
break;
|
|
|
|
}
|
drbd: always write bitmap on detach
If we detach due to local read-error (which sets a bit in the bitmap),
stay Primary, and then re-attach (which re-reads the bitmap from disk),
we potentially lost the "out-of-sync" (or, "bad block") information in
the bitmap.
Always (try to) write out the changed bitmap pages before going diskless.
That way, we don't lose the bit for the bad block,
the next resync will fetch it from the peer, and rewrite
it locally, which may result in block reallocation in some
lower layer (or the hardware), and thereby "heal" the bad blocks.
If the bitmap writeout errors out as well, we will (again: try to)
mark the "we need a full sync" bit in our super block,
if it was a READ error; writes are covered by the activity log already.
If that superblock does not make it to disk either, we are sorry.
Maybe we just lost an entire disk or controller (or iSCSI connection),
and there actually are no bad blocks at all, so we don't need to
re-fetch from the peer, there is no "auto-healing" necessary.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-09-22 14:26:57 +04:00
|
|
|
/* NOTE fall through for DRBD_META_IO_ERROR or DRBD_FORCE_DETACH */
|
2009-09-26 03:07:19 +04:00
|
|
|
case EP_DETACH:
|
|
|
|
case EP_CALL_HELPER:
|
drbd: always write bitmap on detach
If we detach due to local read-error (which sets a bit in the bitmap),
stay Primary, and then re-attach (which re-reads the bitmap from disk),
we potentially lost the "out-of-sync" (or, "bad block") information in
the bitmap.
Always (try to) write out the changed bitmap pages before going diskless.
That way, we don't lose the bit for the bad block,
the next resync will fetch it from the peer, and rewrite
it locally, which may result in block reallocation in some
lower layer (or the hardware), and thereby "heal" the bad blocks.
If the bitmap writeout errors out as well, we will (again: try to)
mark the "we need a full sync" bit in our super block,
if it was a READ error; writes are covered by the activity log already.
If that superblock does not make it to disk either, we are sorry.
Maybe we just lost an entire disk or controller (or iSCSI connection),
and there actually are no bad blocks at all, so we don't need to
re-fetch from the peer, there is no "auto-healing" necessary.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-09-22 14:26:57 +04:00
|
|
|
/* Remember whether we saw a READ or WRITE error.
|
|
|
|
*
|
|
|
|
* Recovery of the affected area for WRITE failure is covered
|
|
|
|
* by the activity log.
|
|
|
|
* READ errors may fall outside that area though. Certain READ
|
|
|
|
* errors can be "healed" by writing good data to the affected
|
|
|
|
* blocks, which triggers block re-allocation in lower layers.
|
|
|
|
*
|
|
|
|
* If we can not write the bitmap after a READ error,
|
|
|
|
* we may need to trigger a full sync (see w_go_diskless()).
|
|
|
|
*
|
|
|
|
* Force-detach is not really an IO error, but rather a
|
|
|
|
* desperate measure to try to deal with a completely
|
|
|
|
* unresponsive lower level IO stack.
|
|
|
|
* Still it should be treated as a WRITE error.
|
|
|
|
*
|
|
|
|
* Meta IO error is always WRITE error:
|
|
|
|
* we read meta data only once during attach,
|
|
|
|
* which will fail in case of errors.
|
|
|
|
*/
|
2011-07-03 15:26:43 +04:00
|
|
|
set_bit(WAS_IO_ERROR, &device->flags);
|
drbd: always write bitmap on detach
If we detach due to local read-error (which sets a bit in the bitmap),
stay Primary, and then re-attach (which re-reads the bitmap from disk),
we potentially lost the "out-of-sync" (or, "bad block") information in
the bitmap.
Always (try to) write out the changed bitmap pages before going diskless.
That way, we don't lose the bit for the bad block,
the next resync will fetch it from the peer, and rewrite
it locally, which may result in block reallocation in some
lower layer (or the hardware), and thereby "heal" the bad blocks.
If the bitmap writeout errors out as well, we will (again: try to)
mark the "we need a full sync" bit in our super block,
if it was a READ error; writes are covered by the activity log already.
If that superblock does not make it to disk either, we are sorry.
Maybe we just lost an entire disk or controller (or iSCSI connection),
and there actually are no bad blocks at all, so we don't need to
re-fetch from the peer, there is no "auto-healing" necessary.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-09-22 14:26:57 +04:00
|
|
|
if (df == DRBD_READ_ERROR)
|
2011-07-03 15:26:43 +04:00
|
|
|
set_bit(WAS_READ_ERROR, &device->flags);
|
drbd: always write bitmap on detach
If we detach due to local read-error (which sets a bit in the bitmap),
stay Primary, and then re-attach (which re-reads the bitmap from disk),
we potentially lost the "out-of-sync" (or, "bad block") information in
the bitmap.
Always (try to) write out the changed bitmap pages before going diskless.
That way, we don't lose the bit for the bad block,
the next resync will fetch it from the peer, and rewrite
it locally, which may result in block reallocation in some
lower layer (or the hardware), and thereby "heal" the bad blocks.
If the bitmap writeout errors out as well, we will (again: try to)
mark the "we need a full sync" bit in our super block,
if it was a READ error; writes are covered by the activity log already.
If that superblock does not make it to disk either, we are sorry.
Maybe we just lost an entire disk or controller (or iSCSI connection),
and there actually are no bad blocks at all, so we don't need to
re-fetch from the peer, there is no "auto-healing" necessary.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-09-22 14:26:57 +04:00
|
|
|
if (df == DRBD_FORCE_DETACH)
|
2011-07-03 15:26:43 +04:00
|
|
|
set_bit(FORCE_DETACH, &device->flags);
|
|
|
|
if (device->state.disk > D_FAILED) {
|
|
|
|
_drbd_set_state(_NS(device, disk, D_FAILED), CS_HARD, NULL);
|
2011-07-03 19:53:52 +04:00
|
|
|
drbd_err(device,
|
2010-10-16 14:13:47 +04:00
|
|
|
"Local IO failed in %s. Detaching...\n", where);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_chk_io_error: Handle the on_io_error setting, should be called from all io completion handlers
|
2011-07-03 15:26:43 +04:00
|
|
|
* @device: DRBD device.
|
2009-09-26 03:07:19 +04:00
|
|
|
* @error: Error code passed to the IO completion callback
|
|
|
|
* @forcedetach: Force detach. I.e. the error happened while accessing the meta data
|
|
|
|
*
|
|
|
|
* See also drbd_main.c:after_state_ch() if (os.disk > D_FAILED && ns.disk == D_FAILED)
|
|
|
|
*/
|
|
|
|
#define drbd_chk_io_error(m,e,f) drbd_chk_io_error_(m,e,f, __func__)
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void drbd_chk_io_error_(struct drbd_device *device,
|
2012-06-14 16:21:32 +04:00
|
|
|
int error, enum drbd_force_detach_flags forcedetach, const char *where)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
|
|
|
if (error) {
|
|
|
|
unsigned long flags;
|
2011-07-07 16:19:42 +04:00
|
|
|
spin_lock_irqsave(&device->resource->req_lock, flags);
|
2011-07-03 15:26:43 +04:00
|
|
|
__drbd_chk_io_error_(device, forcedetach, where);
|
2011-07-07 16:19:42 +04:00
|
|
|
spin_unlock_irqrestore(&device->resource->req_lock, flags);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_md_first_sector() - Returns the first sector number of the meta data area
|
|
|
|
* @bdev: Meta data block device.
|
|
|
|
*
|
|
|
|
* BTW, for internal meta data, this happens to be the maximum capacity
|
|
|
|
* we could agree upon with our peer node.
|
|
|
|
*/
|
2013-03-19 21:16:45 +04:00
|
|
|
static inline sector_t drbd_md_first_sector(struct drbd_backing_dev *bdev)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2013-03-19 21:16:45 +04:00
|
|
|
switch (bdev->md.meta_dev_idx) {
|
2009-09-26 03:07:19 +04:00
|
|
|
case DRBD_MD_INDEX_INTERNAL:
|
|
|
|
case DRBD_MD_INDEX_FLEX_INT:
|
|
|
|
return bdev->md.md_offset + bdev->md.bm_offset;
|
|
|
|
case DRBD_MD_INDEX_FLEX_EXT:
|
|
|
|
default:
|
|
|
|
return bdev->md.md_offset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_md_last_sector() - Return the last sector number of the meta data area
|
|
|
|
* @bdev: Meta data block device.
|
|
|
|
*/
|
|
|
|
static inline sector_t drbd_md_last_sector(struct drbd_backing_dev *bdev)
|
|
|
|
{
|
2013-03-19 21:16:45 +04:00
|
|
|
switch (bdev->md.meta_dev_idx) {
|
2009-09-26 03:07:19 +04:00
|
|
|
case DRBD_MD_INDEX_INTERNAL:
|
|
|
|
case DRBD_MD_INDEX_FLEX_INT:
|
2013-03-19 21:16:43 +04:00
|
|
|
return bdev->md.md_offset + MD_4kB_SECT -1;
|
2009-09-26 03:07:19 +04:00
|
|
|
case DRBD_MD_INDEX_FLEX_EXT:
|
|
|
|
default:
|
2013-03-19 21:16:43 +04:00
|
|
|
return bdev->md.md_offset + bdev->md.md_size_sect -1;
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns the number of 512 byte sectors of the device */
|
|
|
|
static inline sector_t drbd_get_capacity(struct block_device *bdev)
|
|
|
|
{
|
|
|
|
/* return bdev ? get_capacity(bdev->bd_disk) : 0; */
|
2010-11-08 16:39:12 +03:00
|
|
|
return bdev ? i_size_read(bdev->bd_inode) >> 9 : 0;
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_get_max_capacity() - Returns the capacity we announce to out peer
|
|
|
|
* @bdev: Meta data block device.
|
|
|
|
*
|
|
|
|
* returns the capacity we announce to out peer. we clip ourselves at the
|
|
|
|
* various MAX_SECTORS, because if we don't, current implementation will
|
|
|
|
* oops sooner or later
|
|
|
|
*/
|
|
|
|
static inline sector_t drbd_get_max_capacity(struct drbd_backing_dev *bdev)
|
|
|
|
{
|
|
|
|
sector_t s;
|
2011-05-03 17:00:55 +04:00
|
|
|
|
2013-03-19 21:16:45 +04:00
|
|
|
switch (bdev->md.meta_dev_idx) {
|
2009-09-26 03:07:19 +04:00
|
|
|
case DRBD_MD_INDEX_INTERNAL:
|
|
|
|
case DRBD_MD_INDEX_FLEX_INT:
|
|
|
|
s = drbd_get_capacity(bdev->backing_bdev)
|
|
|
|
? min_t(sector_t, DRBD_MAX_SECTORS_FLEX,
|
2013-03-19 21:16:45 +04:00
|
|
|
drbd_md_first_sector(bdev))
|
2009-09-26 03:07:19 +04:00
|
|
|
: 0;
|
|
|
|
break;
|
|
|
|
case DRBD_MD_INDEX_FLEX_EXT:
|
|
|
|
s = min_t(sector_t, DRBD_MAX_SECTORS_FLEX,
|
|
|
|
drbd_get_capacity(bdev->backing_bdev));
|
|
|
|
/* clip at maximum size the meta device can support */
|
|
|
|
s = min_t(sector_t, s,
|
|
|
|
BM_EXT_TO_SECT(bdev->md.md_size_sect
|
|
|
|
- bdev->md.bm_offset));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
s = min_t(sector_t, DRBD_MAX_SECTORS,
|
|
|
|
drbd_get_capacity(bdev->backing_bdev));
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-03-19 21:16:44 +04:00
|
|
|
* drbd_md_ss() - Return the sector number of our meta data super block
|
2009-09-26 03:07:19 +04:00
|
|
|
* @bdev: Meta data block device.
|
|
|
|
*/
|
2013-03-19 21:16:44 +04:00
|
|
|
static inline sector_t drbd_md_ss(struct drbd_backing_dev *bdev)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2013-03-19 21:16:44 +04:00
|
|
|
const int meta_dev_idx = bdev->md.meta_dev_idx;
|
2011-05-03 17:00:55 +04:00
|
|
|
|
2013-03-19 21:16:44 +04:00
|
|
|
if (meta_dev_idx == DRBD_MD_INDEX_FLEX_EXT)
|
|
|
|
return 0;
|
2011-05-03 17:00:55 +04:00
|
|
|
|
2013-03-19 21:16:44 +04:00
|
|
|
/* Since drbd08, internal meta data is always "flexible".
|
|
|
|
* position: last 4k aligned block of 4k size */
|
|
|
|
if (meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
|
|
|
|
meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)
|
2013-03-19 21:16:43 +04:00
|
|
|
return (drbd_get_capacity(bdev->backing_bdev) & ~7ULL) - 8;
|
2013-03-19 21:16:44 +04:00
|
|
|
|
|
|
|
/* external, some index; this is the old fixed size layout */
|
|
|
|
return MD_128MB_SECT * bdev->md.meta_dev_idx;
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
drbd_queue_work(struct drbd_work_queue *q, struct drbd_work *w)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&q->q_lock, flags);
|
|
|
|
list_add_tail(&w->list, &q->q);
|
|
|
|
spin_unlock_irqrestore(&q->q_lock, flags);
|
2011-10-19 13:50:57 +04:00
|
|
|
wake_up(&q->q_wait);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2014-04-28 13:43:21 +04:00
|
|
|
static inline void
|
|
|
|
drbd_queue_work_if_unqueued(struct drbd_work_queue *q, struct drbd_work *w)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&q->q_lock, flags);
|
|
|
|
if (list_empty_careful(&w->list))
|
|
|
|
list_add_tail(&w->list, &q->q);
|
|
|
|
spin_unlock_irqrestore(&q->q_lock, flags);
|
|
|
|
wake_up(&q->q_wait);
|
|
|
|
}
|
|
|
|
|
2014-02-11 12:30:49 +04:00
|
|
|
static inline void
|
|
|
|
drbd_device_post_work(struct drbd_device *device, int work_bit)
|
|
|
|
{
|
|
|
|
if (!test_and_set_bit(work_bit, &device->flags)) {
|
|
|
|
struct drbd_connection *connection =
|
|
|
|
first_peer_device(device)->connection;
|
|
|
|
struct drbd_work_queue *q = &connection->sender_work;
|
|
|
|
if (!test_and_set_bit(DEVICE_WORK_PENDING, &connection->flags))
|
|
|
|
wake_up(&q->q_wait);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-28 17:56:02 +04:00
|
|
|
extern void drbd_flush_workqueue(struct drbd_work_queue *work_queue);
|
|
|
|
|
2015-03-16 18:08:29 +03:00
|
|
|
/* To get the ack_receiver out of the blocking network stack,
|
|
|
|
* so it can change its sk_rcvtimeo from idle- to ping-timeout,
|
|
|
|
* and send a ping, we need to send a signal.
|
|
|
|
* Which signal we send is irrelevant. */
|
|
|
|
static inline void wake_ack_receiver(struct drbd_connection *connection)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2015-03-16 18:08:29 +03:00
|
|
|
struct task_struct *task = connection->ack_receiver.task;
|
|
|
|
if (task && get_t_state(&connection->ack_receiver) == RUNNING)
|
|
|
|
force_sig(SIGXCPU, task);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2011-05-30 18:32:41 +04:00
|
|
|
static inline void request_ping(struct drbd_connection *connection)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-05-30 18:32:41 +04:00
|
|
|
set_bit(SEND_PING, &connection->flags);
|
2015-03-16 18:08:29 +03:00
|
|
|
wake_ack_receiver(connection);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2011-05-30 18:32:41 +04:00
|
|
|
extern void *conn_prepare_command(struct drbd_connection *, struct drbd_socket *);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern void *drbd_prepare_command(struct drbd_peer_device *, struct drbd_socket *);
|
2011-05-30 18:32:41 +04:00
|
|
|
extern int conn_send_command(struct drbd_connection *, struct drbd_socket *,
|
2011-03-29 18:55:40 +04:00
|
|
|
enum drbd_packet, unsigned int, void *,
|
|
|
|
unsigned int);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern int drbd_send_command(struct drbd_peer_device *, struct drbd_socket *,
|
2011-03-29 18:55:40 +04:00
|
|
|
enum drbd_packet, unsigned int, void *,
|
|
|
|
unsigned int);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-05-30 18:32:41 +04:00
|
|
|
extern int drbd_send_ping(struct drbd_connection *connection);
|
|
|
|
extern int drbd_send_ping_ack(struct drbd_connection *connection);
|
drbd: Pass a peer device to a number of fuctions
These functions actually operate on a peer device, or
need a peer device.
drbd_prepare_command(), drbd_send_command(), drbd_send_sync_param()
drbd_send_uuids(), drbd_gen_and_send_sync_uuid(), drbd_send_sizes()
drbd_send_state(), drbd_send_current_state(), and drbd_send_state_req()
drbd_send_sr_reply(), drbd_send_ack(), drbd_send_drequest(),
drbd_send_drequest_csum(), drbd_send_ov_request(), drbd_send_dblock()
drbd_send_block(), drbd_send_out_of_sync(), recv_dless_read()
drbd_drain_block(), receive_bitmap_plain(), recv_resync_read()
read_in_block(), read_for_csum(), drbd_alloc_pages(), drbd_alloc_peer_req()
need_peer_seq(), update_peer_seq(), wait_for_and_update_peer_seq()
drbd_sync_handshake(), drbd_asb_recover_{0,1,2}p(), drbd_connected()
drbd_disconnected(), decode_bitmap_c() and recv_bm_rle_bits()
Signed-off-by: Andreas Gruenbacher <agruen@linbit.com>
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
2011-08-09 02:47:13 +04:00
|
|
|
extern int drbd_send_state_req(struct drbd_peer_device *, union drbd_state, union drbd_state);
|
2011-05-30 18:32:41 +04:00
|
|
|
extern int conn_send_state_req(struct drbd_connection *, union drbd_state, union drbd_state);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
static inline void drbd_thread_stop(struct drbd_thread *thi)
|
|
|
|
{
|
2010-12-09 17:03:57 +03:00
|
|
|
_drbd_thread_stop(thi, false, true);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void drbd_thread_stop_nowait(struct drbd_thread *thi)
|
|
|
|
{
|
2010-12-09 17:03:57 +03:00
|
|
|
_drbd_thread_stop(thi, false, false);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void drbd_thread_restart_nowait(struct drbd_thread *thi)
|
|
|
|
{
|
2010-12-09 17:03:57 +03:00
|
|
|
_drbd_thread_stop(thi, true, false);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* counts how many answer packets packets we expect from our peer,
|
|
|
|
* for either explicit application requests,
|
|
|
|
* or implicit barrier packets as necessary.
|
|
|
|
* increased:
|
|
|
|
* w_send_barrier
|
2011-01-25 17:37:43 +03:00
|
|
|
* _req_mod(req, QUEUE_FOR_NET_WRITE or QUEUE_FOR_NET_READ);
|
2009-09-26 03:07:19 +04:00
|
|
|
* it is much easier and equally valid to count what we queue for the
|
|
|
|
* worker, even before it actually was queued or send.
|
|
|
|
* (drbd_make_request_common; recovery path on read io-error)
|
|
|
|
* decreased:
|
|
|
|
* got_BarrierAck (respective tl_clear, tl_clear_barrier)
|
2011-01-25 17:37:43 +03:00
|
|
|
* _req_mod(req, DATA_RECEIVED)
|
2009-09-26 03:07:19 +04:00
|
|
|
* [from receive_DataReply]
|
2011-01-25 17:37:43 +03:00
|
|
|
* _req_mod(req, WRITE_ACKED_BY_PEER or RECV_ACKED_BY_PEER or NEG_ACKED)
|
2009-09-26 03:07:19 +04:00
|
|
|
* [from got_BlockAck (P_WRITE_ACK, P_RECV_ACK)]
|
|
|
|
* for some reason it is NOT decreased in got_NegAck,
|
|
|
|
* but in the resulting cleanup code from report_params.
|
|
|
|
* we should try to remember the reason for that...
|
2011-01-25 17:37:43 +03:00
|
|
|
* _req_mod(req, SEND_FAILED or SEND_CANCELED)
|
|
|
|
* _req_mod(req, CONNECTION_LOST_WHILE_PENDING)
|
2009-09-26 03:07:19 +04:00
|
|
|
* [from tl_clear_barrier]
|
|
|
|
*/
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void inc_ap_pending(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
atomic_inc(&device->ap_pending_cnt);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2011-02-21 16:19:44 +03:00
|
|
|
#define ERR_IF_CNT_IS_NEGATIVE(which, func, line) \
|
2011-07-03 15:26:43 +04:00
|
|
|
if (atomic_read(&device->which) < 0) \
|
2011-07-03 19:53:52 +04:00
|
|
|
drbd_err(device, "in %s:%d: " #which " = %d < 0 !\n", \
|
2011-02-21 16:19:44 +03:00
|
|
|
func, line, \
|
2011-07-03 15:26:43 +04:00
|
|
|
atomic_read(&device->which))
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2014-03-25 23:35:05 +04:00
|
|
|
#define dec_ap_pending(device) _dec_ap_pending(device, __func__, __LINE__)
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void _dec_ap_pending(struct drbd_device *device, const char *func, int line)
|
2011-02-21 16:19:44 +03:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
if (atomic_dec_and_test(&device->ap_pending_cnt))
|
|
|
|
wake_up(&device->misc_wait);
|
2011-02-21 16:19:44 +03:00
|
|
|
ERR_IF_CNT_IS_NEGATIVE(ap_pending_cnt, func, line);
|
|
|
|
}
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* counts how many resync-related answers we still expect from the peer
|
|
|
|
* increase decrease
|
|
|
|
* C_SYNC_TARGET sends P_RS_DATA_REQUEST (and expects P_RS_DATA_REPLY)
|
2011-03-31 05:57:33 +04:00
|
|
|
* C_SYNC_SOURCE sends P_RS_DATA_REPLY (and expects P_WRITE_ACK with ID_SYNCER)
|
2009-09-26 03:07:19 +04:00
|
|
|
* (or P_NEG_ACK with ID_SYNCER)
|
|
|
|
*/
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void inc_rs_pending(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
atomic_inc(&device->rs_pending_cnt);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2014-03-25 23:35:05 +04:00
|
|
|
#define dec_rs_pending(device) _dec_rs_pending(device, __func__, __LINE__)
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void _dec_rs_pending(struct drbd_device *device, const char *func, int line)
|
2011-02-21 16:19:44 +03:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
atomic_dec(&device->rs_pending_cnt);
|
2011-02-21 16:19:44 +03:00
|
|
|
ERR_IF_CNT_IS_NEGATIVE(rs_pending_cnt, func, line);
|
|
|
|
}
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* counts how many answers we still need to send to the peer.
|
|
|
|
* increased on
|
|
|
|
* receive_Data unless protocol A;
|
|
|
|
* we need to send a P_RECV_ACK (proto B)
|
|
|
|
* or P_WRITE_ACK (proto C)
|
|
|
|
* receive_RSDataReply (recv_resync_read) we need to send a P_WRITE_ACK
|
|
|
|
* receive_DataRequest (receive_RSDataRequest) we need to send back P_DATA
|
|
|
|
* receive_Barrier_* we need to send a P_BARRIER_ACK
|
|
|
|
*/
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void inc_unacked(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
atomic_inc(&device->unacked_cnt);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2014-03-25 23:35:05 +04:00
|
|
|
#define dec_unacked(device) _dec_unacked(device, __func__, __LINE__)
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void _dec_unacked(struct drbd_device *device, const char *func, int line)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
atomic_dec(&device->unacked_cnt);
|
2011-02-21 16:19:44 +03:00
|
|
|
ERR_IF_CNT_IS_NEGATIVE(unacked_cnt, func, line);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2014-03-25 23:35:05 +04:00
|
|
|
#define sub_unacked(device, n) _sub_unacked(device, n, __func__, __LINE__)
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void _sub_unacked(struct drbd_device *device, int n, const char *func, int line)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
atomic_sub(n, &device->unacked_cnt);
|
2011-02-21 16:19:44 +03:00
|
|
|
ERR_IF_CNT_IS_NEGATIVE(unacked_cnt, func, line);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2016-06-14 01:26:24 +03:00
|
|
|
static inline bool is_sync_target_state(enum drbd_conns connection_state)
|
|
|
|
{
|
|
|
|
return connection_state == C_SYNC_TARGET ||
|
|
|
|
connection_state == C_PAUSED_SYNC_T;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool is_sync_source_state(enum drbd_conns connection_state)
|
|
|
|
{
|
|
|
|
return connection_state == C_SYNC_SOURCE ||
|
|
|
|
connection_state == C_PAUSED_SYNC_S;
|
|
|
|
}
|
|
|
|
|
drbd: fix resync finished detection
This fixes one recent regresion,
and one long existing bug.
The bug:
drbd_try_clear_on_disk_bm() assumed that all "count" bits have to be
accounted in the resync extent corresponding to the start sector.
Since we allow application requests to cross our "extent" boundaries,
this assumption is no longer true, resulting in possible misaccounting,
scary messages
("BAD! sector=12345s enr=6 rs_left=-7 rs_failed=0 count=58 cstate=..."),
and potentially, if the last bit to be cleared during resync would
reside in previously misaccounted resync extent, the resync would never
be recognized as finished, but would be "stalled" forever, even though
all blocks are in sync again and all bits have been cleared...
The regression was introduced by
drbd: get rid of atomic update on disk bitmap works
For an "empty" resync (rs_total == 0), we must not "finish" the
resync on the SyncSource before the SyncTarget knows all relevant
information (sync uuid). We need to wait for the full round-trip,
the SyncTarget will then explicitly notify us.
Also for normal, non-empty resyncs (rs_total > 0), the resync-finished
condition needs to be tested before the schedule() in wait_for_work, or
it is likely to be missed.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2014-01-27 18:58:22 +04:00
|
|
|
static inline bool is_sync_state(enum drbd_conns connection_state)
|
|
|
|
{
|
2016-06-14 01:26:24 +03:00
|
|
|
return is_sync_source_state(connection_state) ||
|
|
|
|
is_sync_target_state(connection_state);
|
drbd: fix resync finished detection
This fixes one recent regresion,
and one long existing bug.
The bug:
drbd_try_clear_on_disk_bm() assumed that all "count" bits have to be
accounted in the resync extent corresponding to the start sector.
Since we allow application requests to cross our "extent" boundaries,
this assumption is no longer true, resulting in possible misaccounting,
scary messages
("BAD! sector=12345s enr=6 rs_left=-7 rs_failed=0 count=58 cstate=..."),
and potentially, if the last bit to be cleared during resync would
reside in previously misaccounted resync extent, the resync would never
be recognized as finished, but would be "stalled" forever, even though
all blocks are in sync again and all bits have been cleared...
The regression was introduced by
drbd: get rid of atomic update on disk bitmap works
For an "empty" resync (rs_total == 0), we must not "finish" the
resync on the SyncSource before the SyncTarget knows all relevant
information (sync uuid). We need to wait for the full round-trip,
the SyncTarget will then explicitly notify us.
Also for normal, non-empty resyncs (rs_total > 0), the resync-finished
condition needs to be tested before the schedule() in wait_for_work, or
it is likely to be missed.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2014-01-27 18:58:22 +04:00
|
|
|
}
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
/**
|
2011-07-03 15:26:43 +04:00
|
|
|
* get_ldev() - Increase the ref count on device->ldev. Returns 0 if there is no ldev
|
2014-09-11 16:29:09 +04:00
|
|
|
* @_device: DRBD device.
|
|
|
|
* @_min_state: Minimum device state required for success.
|
2009-09-26 03:07:19 +04:00
|
|
|
*
|
2011-07-03 15:26:43 +04:00
|
|
|
* You have to call put_ldev() when finished working with device->ldev.
|
2009-09-26 03:07:19 +04:00
|
|
|
*/
|
2014-09-11 16:29:09 +04:00
|
|
|
#define get_ldev_if_state(_device, _min_state) \
|
|
|
|
(_get_ldev_if_state((_device), (_min_state)) ? \
|
|
|
|
({ __acquire(x); true; }) : false)
|
|
|
|
#define get_ldev(_device) get_ldev_if_state(_device, D_INCONSISTENT)
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void put_ldev(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2014-09-11 16:29:05 +04:00
|
|
|
enum drbd_disk_state disk_state = device->state.disk;
|
2014-02-11 11:57:18 +04:00
|
|
|
/* We must check the state *before* the atomic_dec becomes visible,
|
|
|
|
* or we have a theoretical race where someone hitting zero,
|
|
|
|
* while state still D_FAILED, will then see D_DISKLESS in the
|
|
|
|
* condition below and calling into destroy, where he must not, yet. */
|
2011-07-03 15:26:43 +04:00
|
|
|
int i = atomic_dec_return(&device->local_cnt);
|
2011-05-02 13:51:31 +04:00
|
|
|
|
|
|
|
/* This may be called from some endio handler,
|
|
|
|
* so we must not sleep here. */
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
__release(local);
|
2011-06-27 18:23:33 +04:00
|
|
|
D_ASSERT(device, i >= 0);
|
2010-09-14 22:26:27 +04:00
|
|
|
if (i == 0) {
|
2014-09-11 16:29:05 +04:00
|
|
|
if (disk_state == D_DISKLESS)
|
2010-10-16 14:13:47 +04:00
|
|
|
/* even internal references gone, safe to destroy */
|
2014-02-11 12:30:49 +04:00
|
|
|
drbd_device_post_work(device, DESTROY_DISK);
|
2014-09-11 16:29:05 +04:00
|
|
|
if (disk_state == D_FAILED)
|
2010-10-16 14:13:47 +04:00
|
|
|
/* all application IO references gone. */
|
2014-02-11 12:30:49 +04:00
|
|
|
if (!test_and_set_bit(GOING_DISKLESS, &device->flags))
|
|
|
|
drbd_device_post_work(device, GO_DISKLESS);
|
2011-07-03 15:26:43 +04:00
|
|
|
wake_up(&device->misc_wait);
|
2010-09-14 22:26:27 +04:00
|
|
|
}
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef __CHECKER__
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline int _get_ldev_if_state(struct drbd_device *device, enum drbd_disk_state mins)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
|
|
|
int io_allowed;
|
|
|
|
|
2010-10-16 14:13:47 +04:00
|
|
|
/* never get a reference while D_DISKLESS */
|
2011-07-03 15:26:43 +04:00
|
|
|
if (device->state.disk == D_DISKLESS)
|
2010-10-16 14:13:47 +04:00
|
|
|
return 0;
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
atomic_inc(&device->local_cnt);
|
|
|
|
io_allowed = (device->state.disk >= mins);
|
2009-09-26 03:07:19 +04:00
|
|
|
if (!io_allowed)
|
2011-07-03 15:26:43 +04:00
|
|
|
put_ldev(device);
|
2009-09-26 03:07:19 +04:00
|
|
|
return io_allowed;
|
|
|
|
}
|
|
|
|
#else
|
2011-07-03 15:26:43 +04:00
|
|
|
extern int _get_ldev_if_state(struct drbd_device *device, enum drbd_disk_state mins);
|
2009-09-26 03:07:19 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* this throttles on-the-fly application requests
|
|
|
|
* according to max_buffers settings;
|
|
|
|
* maybe re-implement using semaphores? */
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline int drbd_get_max_buffers(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-04-19 19:10:19 +04:00
|
|
|
struct net_conf *nc;
|
|
|
|
int mxb;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2011-05-31 16:33:49 +04:00
|
|
|
nc = rcu_dereference(first_peer_device(device)->connection->net_conf);
|
2011-04-19 19:10:19 +04:00
|
|
|
mxb = nc ? nc->max_buffers : 1000000; /* arbitrary limit on open requests */
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
return mxb;
|
|
|
|
}
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline int drbd_state_is_stable(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
union drbd_dev_state s = device->state;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* DO NOT add a default clause, we want the compiler to warn us
|
|
|
|
* for any newly introduced state we may have forgotten to add here */
|
|
|
|
|
|
|
|
switch ((enum drbd_conns)s.conn) {
|
|
|
|
/* new io only accepted when there is no connection, ... */
|
|
|
|
case C_STANDALONE:
|
|
|
|
case C_WF_CONNECTION:
|
|
|
|
/* ... or there is a well established connection. */
|
|
|
|
case C_CONNECTED:
|
|
|
|
case C_SYNC_SOURCE:
|
|
|
|
case C_SYNC_TARGET:
|
|
|
|
case C_VERIFY_S:
|
|
|
|
case C_VERIFY_T:
|
|
|
|
case C_PAUSED_SYNC_S:
|
|
|
|
case C_PAUSED_SYNC_T:
|
2010-10-27 14:21:30 +04:00
|
|
|
case C_AHEAD:
|
|
|
|
case C_BEHIND:
|
2010-11-10 14:08:37 +03:00
|
|
|
/* transitional states, IO allowed */
|
2009-09-26 03:07:19 +04:00
|
|
|
case C_DISCONNECTING:
|
|
|
|
case C_UNCONNECTED:
|
|
|
|
case C_TIMEOUT:
|
|
|
|
case C_BROKEN_PIPE:
|
|
|
|
case C_NETWORK_FAILURE:
|
|
|
|
case C_PROTOCOL_ERROR:
|
|
|
|
case C_TEAR_DOWN:
|
|
|
|
case C_WF_REPORT_PARAMS:
|
|
|
|
case C_STARTING_SYNC_S:
|
|
|
|
case C_STARTING_SYNC_T:
|
2010-11-10 14:08:37 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* Allow IO in BM exchange states with new protocols */
|
2009-09-26 03:07:19 +04:00
|
|
|
case C_WF_BITMAP_S:
|
2011-05-31 16:33:49 +04:00
|
|
|
if (first_peer_device(device)->connection->agreed_pro_version < 96)
|
2010-11-10 14:08:37 +03:00
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* no new io accepted in these states */
|
2009-09-26 03:07:19 +04:00
|
|
|
case C_WF_BITMAP_T:
|
|
|
|
case C_WF_SYNC_UUID:
|
|
|
|
case C_MASK:
|
|
|
|
/* not "stable" */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch ((enum drbd_disk_state)s.disk) {
|
|
|
|
case D_DISKLESS:
|
|
|
|
case D_INCONSISTENT:
|
|
|
|
case D_OUTDATED:
|
|
|
|
case D_CONSISTENT:
|
|
|
|
case D_UP_TO_DATE:
|
2011-06-28 19:01:19 +04:00
|
|
|
case D_FAILED:
|
2009-09-26 03:07:19 +04:00
|
|
|
/* disk state is stable as well. */
|
|
|
|
break;
|
|
|
|
|
2011-05-31 15:07:24 +04:00
|
|
|
/* no new io accepted during transitional states */
|
2009-09-26 03:07:19 +04:00
|
|
|
case D_ATTACHING:
|
|
|
|
case D_NEGOTIATING:
|
|
|
|
case D_UNKNOWN:
|
|
|
|
case D_MASK:
|
|
|
|
/* not "stable" */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline int drbd_suspended(struct drbd_device *device)
|
2010-09-09 01:20:21 +04:00
|
|
|
{
|
2011-07-08 03:19:44 +04:00
|
|
|
struct drbd_resource *resource = device->resource;
|
2011-03-28 18:18:39 +04:00
|
|
|
|
2011-07-08 03:19:44 +04:00
|
|
|
return resource->susp || resource->susp_fen || resource->susp_nod;
|
2010-09-09 01:20:21 +04:00
|
|
|
}
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline bool may_inc_ap_bio(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
int mxb = drbd_get_max_buffers(device);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
if (drbd_suspended(device))
|
2010-12-13 20:03:38 +03:00
|
|
|
return false;
|
2013-02-28 13:30:19 +04:00
|
|
|
if (atomic_read(&device->suspend_cnt))
|
2010-12-13 20:03:38 +03:00
|
|
|
return false;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* to avoid potential deadlock or bitmap corruption,
|
|
|
|
* in various places, we only allow new application io
|
|
|
|
* to start during "stable" states. */
|
|
|
|
|
|
|
|
/* no new io accepted when attaching or detaching the disk */
|
2011-07-03 15:26:43 +04:00
|
|
|
if (!drbd_state_is_stable(device))
|
2010-12-13 20:03:38 +03:00
|
|
|
return false;
|
2009-09-26 03:07:19 +04:00
|
|
|
|
|
|
|
/* since some older kernels don't have atomic_add_unless,
|
|
|
|
* and we are within the spinlock anyways, we have this workaround. */
|
2011-07-03 15:26:43 +04:00
|
|
|
if (atomic_read(&device->ap_bio_cnt) > mxb)
|
2010-12-13 20:03:38 +03:00
|
|
|
return false;
|
2011-07-03 15:26:43 +04:00
|
|
|
if (test_bit(BITMAP_IO, &device->flags))
|
2010-12-13 20:03:38 +03:00
|
|
|
return false;
|
|
|
|
return true;
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline bool inc_ap_bio_cond(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2010-12-13 20:03:38 +03:00
|
|
|
bool rv = false;
|
2010-11-17 20:24:19 +03:00
|
|
|
|
2011-07-07 16:19:42 +04:00
|
|
|
spin_lock_irq(&device->resource->req_lock);
|
2011-07-03 15:26:43 +04:00
|
|
|
rv = may_inc_ap_bio(device);
|
2010-11-17 20:24:19 +03:00
|
|
|
if (rv)
|
2011-07-03 15:26:43 +04:00
|
|
|
atomic_inc(&device->ap_bio_cnt);
|
2011-07-07 16:19:42 +04:00
|
|
|
spin_unlock_irq(&device->resource->req_lock);
|
2010-11-17 20:24:19 +03:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void inc_ap_bio(struct drbd_device *device)
|
2010-11-17 20:24:19 +03:00
|
|
|
{
|
2009-09-26 03:07:19 +04:00
|
|
|
/* we wait here
|
|
|
|
* as long as the device is suspended
|
|
|
|
* until the bitmap is no longer on the fly during connection
|
2011-05-31 15:07:24 +04:00
|
|
|
* handshake as long as we would exceed the max_buffer limit.
|
2009-09-26 03:07:19 +04:00
|
|
|
*
|
|
|
|
* to avoid races with the reconnect code,
|
|
|
|
* we need to atomic_inc within the spinlock. */
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
wait_event(device->misc_wait, inc_ap_bio_cond(device));
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline void dec_ap_bio(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
int mxb = drbd_get_max_buffers(device);
|
|
|
|
int ap_bio = atomic_dec_return(&device->ap_bio_cnt);
|
2009-09-26 03:07:19 +04:00
|
|
|
|
2011-06-27 18:23:33 +04:00
|
|
|
D_ASSERT(device, ap_bio >= 0);
|
2012-06-19 12:27:58 +04:00
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
if (ap_bio == 0 && test_bit(BITMAP_IO, &device->flags)) {
|
|
|
|
if (!test_and_set_bit(BITMAP_IO_QUEUED, &device->flags))
|
2011-07-28 17:27:51 +04:00
|
|
|
drbd_queue_work(&first_peer_device(device)->
|
|
|
|
connection->sender_work,
|
|
|
|
&device->bm_io_work.w);
|
2012-06-19 12:27:58 +04:00
|
|
|
}
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
/* this currently does wake_up for every dec_ap_bio!
|
|
|
|
* maybe rather introduce some type of hysteresis?
|
|
|
|
* e.g. (ap_bio == mxb/2 || ap_bio == 0) ? */
|
|
|
|
if (ap_bio < mxb)
|
2011-07-03 15:26:43 +04:00
|
|
|
wake_up(&device->misc_wait);
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline bool verify_can_do_stop_sector(struct drbd_device *device)
|
2012-07-26 16:09:49 +04:00
|
|
|
{
|
2011-05-31 16:33:49 +04:00
|
|
|
return first_peer_device(device)->connection->agreed_pro_version >= 97 &&
|
|
|
|
first_peer_device(device)->connection->agreed_pro_version != 100;
|
2012-07-26 16:09:49 +04:00
|
|
|
}
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline int drbd_set_ed_uuid(struct drbd_device *device, u64 val)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
2011-07-03 15:26:43 +04:00
|
|
|
int changed = device->ed_uuid != val;
|
|
|
|
device->ed_uuid = val;
|
2011-01-20 15:25:21 +03:00
|
|
|
return changed;
|
2009-09-26 03:07:19 +04:00
|
|
|
}
|
|
|
|
|
2011-07-03 15:26:43 +04:00
|
|
|
static inline int drbd_queue_order_type(struct drbd_device *device)
|
2009-09-26 03:07:19 +04:00
|
|
|
{
|
|
|
|
/* sorry, we currently have no working implementation
|
|
|
|
* of distributed TCQ stuff */
|
|
|
|
#ifndef QUEUE_ORDERED_NONE
|
|
|
|
#define QUEUE_ORDERED_NONE 0
|
|
|
|
#endif
|
|
|
|
return QUEUE_ORDERED_NONE;
|
|
|
|
}
|
|
|
|
|
2011-06-09 00:17:38 +04:00
|
|
|
static inline struct drbd_connection *first_connection(struct drbd_resource *resource)
|
|
|
|
{
|
2014-04-28 20:43:35 +04:00
|
|
|
return list_first_entry_or_null(&resource->connections,
|
2011-06-09 00:17:38 +04:00
|
|
|
struct drbd_connection, connections);
|
|
|
|
}
|
|
|
|
|
2009-09-26 03:07:19 +04:00
|
|
|
#endif
|