2009-09-25 23:07:19 +00:00
|
|
|
/*
|
|
|
|
drbd.c
|
|
|
|
|
|
|
|
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>.
|
|
|
|
|
|
|
|
Thanks to Carter Burden, Bart Grantham and Gennadiy Nerubayev
|
|
|
|
from Logicworks, Inc. for making SDP replication support possible.
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2014-03-27 13:10:55 +00:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
#include <linux/module.h>
|
2013-11-22 11:32:01 +00:00
|
|
|
#include <linux/jiffies.h>
|
2009-09-25 23:07:19 +00:00
|
|
|
#include <linux/drbd.h>
|
2016-06-13 22:26:35 +00:00
|
|
|
#include <linux/uaccess.h>
|
2009-09-25 23:07:19 +00:00
|
|
|
#include <asm/types.h>
|
|
|
|
#include <net/sock.h>
|
|
|
|
#include <linux/ctype.h>
|
2010-06-02 12:28:52 +00:00
|
|
|
#include <linux/mutex.h>
|
2009-09-25 23:07:19 +00:00
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/file.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/memcontrol.h>
|
|
|
|
#include <linux/mm_inline.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/random.h>
|
|
|
|
#include <linux/reboot.h>
|
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <linux/kthread.h>
|
2013-03-23 00:14:40 +00:00
|
|
|
#include <linux/workqueue.h>
|
2009-09-25 23:07:19 +00:00
|
|
|
#define __KERNEL_SYSCALLS__
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
#include <linux/vmalloc.h>
|
|
|
|
|
|
|
|
#include <linux/drbd_limits.h>
|
|
|
|
#include "drbd_int.h"
|
2011-05-30 09:47:37 +00:00
|
|
|
#include "drbd_protocol.h"
|
2009-09-25 23:07:19 +00:00
|
|
|
#include "drbd_req.h" /* only for _req_mod in tl_release and tl_clear */
|
|
|
|
#include "drbd_vli.h"
|
2014-05-02 11:19:51 +00:00
|
|
|
#include "drbd_debugfs.h"
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2010-06-02 12:28:52 +00:00
|
|
|
static DEFINE_MUTEX(drbd_main_mutex);
|
2009-09-25 23:07:19 +00:00
|
|
|
static int drbd_open(struct block_device *bdev, fmode_t mode);
|
2013-05-06 01:52:57 +00:00
|
|
|
static void drbd_release(struct gendisk *gd, fmode_t mode);
|
2009-09-25 23:07:19 +00:00
|
|
|
static void md_sync_timer_fn(unsigned long data);
|
2011-03-16 14:31:39 +00:00
|
|
|
static int w_bitmap_io(struct drbd_work *w, int unused);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Philipp Reisner <phil@linbit.com>, "
|
|
|
|
"Lars Ellenberg <lars@linbit.com>");
|
|
|
|
MODULE_DESCRIPTION("drbd - Distributed Replicated Block Device v" REL_VERSION);
|
|
|
|
MODULE_VERSION(REL_VERSION);
|
|
|
|
MODULE_LICENSE("GPL");
|
2011-02-23 00:53:16 +00:00
|
|
|
MODULE_PARM_DESC(minor_count, "Approximate number of drbd devices ("
|
2011-01-10 10:15:17 +00:00
|
|
|
__stringify(DRBD_MINOR_COUNT_MIN) "-" __stringify(DRBD_MINOR_COUNT_MAX) ")");
|
2009-09-25 23:07:19 +00:00
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(DRBD_MAJOR);
|
|
|
|
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
/* allow_open_on_secondary */
|
|
|
|
MODULE_PARM_DESC(allow_oos, "DONT USE!");
|
|
|
|
/* thanks to these macros, if compiled into the kernel (not-module),
|
|
|
|
* this becomes the boot parameter drbd.minor_count */
|
|
|
|
module_param(minor_count, uint, 0444);
|
|
|
|
module_param(disable_sendpage, bool, 0644);
|
|
|
|
module_param(allow_oos, bool, 0);
|
|
|
|
module_param(proc_details, int, 0644);
|
|
|
|
|
|
|
|
#ifdef CONFIG_DRBD_FAULT_INJECTION
|
|
|
|
int enable_faults;
|
|
|
|
int fault_rate;
|
|
|
|
static int fault_count;
|
|
|
|
int fault_devs;
|
|
|
|
/* bitmap of enabled faults */
|
|
|
|
module_param(enable_faults, int, 0664);
|
|
|
|
/* fault rate % value - applies to all enabled faults */
|
|
|
|
module_param(fault_rate, int, 0664);
|
|
|
|
/* count of faults inserted */
|
|
|
|
module_param(fault_count, int, 0664);
|
|
|
|
/* bitmap of devices to insert faults on */
|
|
|
|
module_param(fault_devs, int, 0644);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* module parameter, defined */
|
2011-01-10 10:15:17 +00:00
|
|
|
unsigned int minor_count = DRBD_MINOR_COUNT_DEF;
|
2012-01-12 23:02:20 +00:00
|
|
|
bool disable_sendpage;
|
|
|
|
bool allow_oos;
|
2009-09-25 23:07:19 +00:00
|
|
|
int proc_details; /* Detail level in proc drbd*/
|
|
|
|
|
|
|
|
/* Module parameter for setting the user mode helper program
|
|
|
|
* to run. Default is /sbin/drbdadm */
|
|
|
|
char usermode_helper[80] = "/sbin/drbdadm";
|
|
|
|
|
|
|
|
module_param_string(usermode_helper, usermode_helper, sizeof(usermode_helper), 0644);
|
|
|
|
|
|
|
|
/* in 2.6.x, our device mapping and config info contains our virtual gendisks
|
|
|
|
* as member "struct gendisk *vdisk;"
|
|
|
|
*/
|
2011-06-07 20:54:17 +00:00
|
|
|
struct idr drbd_devices;
|
2011-06-08 20:17:38 +00:00
|
|
|
struct list_head drbd_resources;
|
2014-08-14 16:33:30 +00:00
|
|
|
struct mutex resources_mutex;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
struct kmem_cache *drbd_request_cache;
|
2011-02-04 14:38:52 +00:00
|
|
|
struct kmem_cache *drbd_ee_cache; /* peer requests */
|
2009-09-25 23:07:19 +00:00
|
|
|
struct kmem_cache *drbd_bm_ext_cache; /* bitmap extents */
|
|
|
|
struct kmem_cache *drbd_al_ext_cache; /* activity log extents */
|
|
|
|
mempool_t *drbd_request_mempool;
|
|
|
|
mempool_t *drbd_ee_mempool;
|
2011-02-23 11:39:46 +00:00
|
|
|
mempool_t *drbd_md_io_page_pool;
|
2011-02-23 16:02:01 +00:00
|
|
|
struct bio_set *drbd_md_io_bio_set;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
/* I do not use a standard mempool, because:
|
|
|
|
1) I want to hand out the pre-allocated objects first.
|
|
|
|
2) I want to be able to interrupt sleeping allocation with a signal.
|
|
|
|
Note: This is a single linked list, the next pointer is the private
|
|
|
|
member of struct page.
|
|
|
|
*/
|
|
|
|
struct page *drbd_pp_pool;
|
|
|
|
spinlock_t drbd_pp_lock;
|
|
|
|
int drbd_pp_vacant;
|
|
|
|
wait_queue_head_t drbd_pp_wait;
|
|
|
|
|
|
|
|
DEFINE_RATELIMIT_STATE(drbd_ratelimit_state, 5 * HZ, 5);
|
|
|
|
|
2009-12-13 23:59:30 +00:00
|
|
|
static const struct block_device_operations drbd_ops = {
|
2009-09-25 23:07:19 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = drbd_open,
|
|
|
|
.release = drbd_release,
|
|
|
|
};
|
2010-12-15 07:59:11 +00:00
|
|
|
|
2011-02-23 16:02:01 +00:00
|
|
|
struct bio *bio_alloc_drbd(gfp_t gfp_mask)
|
|
|
|
{
|
|
|
|
struct bio *bio;
|
2010-12-15 07:59:11 +00:00
|
|
|
|
2011-02-23 16:02:01 +00:00
|
|
|
if (!drbd_md_io_bio_set)
|
|
|
|
return bio_alloc(gfp_mask, 1);
|
2010-12-15 07:59:11 +00:00
|
|
|
|
2011-02-23 16:02:01 +00:00
|
|
|
bio = bio_alloc_bioset(gfp_mask, 1, drbd_md_io_bio_set);
|
|
|
|
if (!bio)
|
|
|
|
return NULL;
|
|
|
|
return bio;
|
2010-12-15 07:59:11 +00:00
|
|
|
}
|
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
#ifdef __CHECKER__
|
|
|
|
/* When checking with sparse, and this is an inline function, sparse will
|
|
|
|
give tons of false positives. When this is a real functions sparse works.
|
|
|
|
*/
|
2011-07-03 11:26:43 +00:00
|
|
|
int _get_ldev_if_state(struct drbd_device *device, enum drbd_disk_state mins)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
int io_allowed;
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
atomic_inc(&device->local_cnt);
|
|
|
|
io_allowed = (device->state.disk >= mins);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (!io_allowed) {
|
2011-07-03 11:26:43 +00:00
|
|
|
if (atomic_dec_and_test(&device->local_cnt))
|
|
|
|
wake_up(&device->misc_wait);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
return io_allowed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2010-05-31 08:14:17 +00:00
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
/**
|
2011-11-28 14:04:49 +00:00
|
|
|
* tl_release() - mark as BARRIER_ACKED all requests in the corresponding transfer log epoch
|
2011-05-30 14:32:41 +00:00
|
|
|
* @connection: DRBD connection.
|
2009-09-25 23:07:19 +00:00
|
|
|
* @barrier_nr: Expected identifier of the DRBD write barrier packet.
|
|
|
|
* @set_size: Expected number of requests before that barrier.
|
|
|
|
*
|
|
|
|
* In case the passed barrier_nr or set_size does not match the oldest
|
2011-11-28 14:04:49 +00:00
|
|
|
* epoch of not yet barrier-acked requests, this function will cause a
|
|
|
|
* termination of the connection.
|
2009-09-25 23:07:19 +00:00
|
|
|
*/
|
2011-05-30 14:32:41 +00:00
|
|
|
void tl_release(struct drbd_connection *connection, unsigned int barrier_nr,
|
2011-02-21 13:29:27 +00:00
|
|
|
unsigned int set_size)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
struct drbd_request *r;
|
2011-11-28 14:04:49 +00:00
|
|
|
struct drbd_request *req = NULL;
|
|
|
|
int expect_epoch = 0;
|
|
|
|
int expect_size = 0;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_lock_irq(&connection->resource->req_lock);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2012-11-09 13:18:43 +00:00
|
|
|
/* find oldest not yet barrier-acked write request,
|
2011-11-28 14:04:49 +00:00
|
|
|
* count writes in its epoch. */
|
2011-05-30 14:32:41 +00:00
|
|
|
list_for_each_entry(r, &connection->transfer_log, tl_requests) {
|
2012-01-24 16:19:42 +00:00
|
|
|
const unsigned s = r->rq_state;
|
2011-11-28 14:04:49 +00:00
|
|
|
if (!req) {
|
|
|
|
if (!(s & RQ_WRITE))
|
|
|
|
continue;
|
|
|
|
if (!(s & RQ_NET_MASK))
|
|
|
|
continue;
|
|
|
|
if (s & RQ_NET_DONE)
|
|
|
|
continue;
|
|
|
|
req = r;
|
|
|
|
expect_epoch = req->epoch;
|
|
|
|
expect_size ++;
|
|
|
|
} else {
|
|
|
|
if (r->epoch != expect_epoch)
|
|
|
|
break;
|
|
|
|
if (!(s & RQ_WRITE))
|
|
|
|
continue;
|
|
|
|
/* if (s & RQ_DONE): not expected */
|
|
|
|
/* if (!(s & RQ_NET_MASK)): not expected */
|
|
|
|
expect_size++;
|
2010-06-11 09:26:34 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2010-06-24 14:24:25 +00:00
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
/* first some paranoia code */
|
2011-11-28 14:04:49 +00:00
|
|
|
if (req == NULL) {
|
2011-07-06 09:01:44 +00:00
|
|
|
drbd_err(connection, "BAD! BarrierAck #%u received, but no epoch in tl!?\n",
|
2011-02-21 13:29:27 +00:00
|
|
|
barrier_nr);
|
2009-09-25 23:07:19 +00:00
|
|
|
goto bail;
|
|
|
|
}
|
2011-11-28 14:04:49 +00:00
|
|
|
if (expect_epoch != barrier_nr) {
|
2011-07-06 09:01:44 +00:00
|
|
|
drbd_err(connection, "BAD! BarrierAck #%u received, expected #%u!\n",
|
2011-11-28 14:04:49 +00:00
|
|
|
barrier_nr, expect_epoch);
|
2009-09-25 23:07:19 +00:00
|
|
|
goto bail;
|
2010-12-17 20:14:23 +00:00
|
|
|
}
|
|
|
|
|
2011-11-28 14:04:49 +00:00
|
|
|
if (expect_size != set_size) {
|
2011-07-06 09:01:44 +00:00
|
|
|
drbd_err(connection, "BAD! BarrierAck #%u received with n_writes=%u, expected n_writes=%u!\n",
|
2011-11-28 14:04:49 +00:00
|
|
|
barrier_nr, set_size, expect_size);
|
2009-09-25 23:07:19 +00:00
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
|
2012-11-09 13:18:43 +00:00
|
|
|
/* Clean up list of requests processed during current epoch. */
|
|
|
|
/* this extra list walk restart is paranoia,
|
|
|
|
* to catch requests being barrier-acked "unexpectedly".
|
|
|
|
* It usually should find the same req again, or some READ preceding it. */
|
2011-05-30 14:32:41 +00:00
|
|
|
list_for_each_entry(req, &connection->transfer_log, tl_requests)
|
2012-11-09 13:18:43 +00:00
|
|
|
if (req->epoch == expect_epoch)
|
|
|
|
break;
|
2011-05-30 14:32:41 +00:00
|
|
|
list_for_each_entry_safe_from(req, r, &connection->transfer_log, tl_requests) {
|
2011-11-28 14:04:49 +00:00
|
|
|
if (req->epoch != expect_epoch)
|
|
|
|
break;
|
|
|
|
_req_mod(req, BARRIER_ACKED);
|
2010-12-15 07:59:11 +00:00
|
|
|
}
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_unlock_irq(&connection->resource->req_lock);
|
2010-12-15 07:59:11 +00:00
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
bail:
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_unlock_irq(&connection->resource->req_lock);
|
2011-05-30 14:32:41 +00:00
|
|
|
conn_request_state(connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2010-05-12 15:08:26 +00:00
|
|
|
* _tl_restart() - Walks the transfer log, and applies an action to all requests
|
2013-11-22 11:32:01 +00:00
|
|
|
* @connection: DRBD connection to operate on.
|
2010-05-12 15:08:26 +00:00
|
|
|
* @what: The action/event to perform with all request objects
|
2009-09-25 23:07:19 +00:00
|
|
|
*
|
2011-01-25 14:37:43 +00:00
|
|
|
* @what might be one of CONNECTION_LOST_WHILE_PENDING, RESEND, FAIL_FROZEN_DISK_IO,
|
|
|
|
* RESTART_FROZEN_DISK_IO.
|
2009-09-25 23:07:19 +00:00
|
|
|
*/
|
2011-11-28 14:04:49 +00:00
|
|
|
/* must hold resource->req_lock */
|
2011-05-30 14:32:41 +00:00
|
|
|
void _tl_restart(struct drbd_connection *connection, enum drbd_req_event what)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-11-28 14:04:49 +00:00
|
|
|
struct drbd_request *req, *r;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
list_for_each_entry_safe(req, r, &connection->transfer_log, tl_requests)
|
2011-11-28 14:04:49 +00:00
|
|
|
_req_mod(req, what);
|
|
|
|
}
|
2011-03-02 23:21:30 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
void tl_restart(struct drbd_connection *connection, enum drbd_req_event what)
|
2011-11-28 14:04:49 +00:00
|
|
|
{
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_lock_irq(&connection->resource->req_lock);
|
2011-05-30 14:32:41 +00:00
|
|
|
_tl_restart(connection, what);
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_unlock_irq(&connection->resource->req_lock);
|
2011-07-05 13:38:59 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* tl_clear() - Clears all requests and &struct drbd_tl_epoch objects out of the TL
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: DRBD device.
|
2009-09-25 23:07:19 +00:00
|
|
|
*
|
|
|
|
* This is called after the connection to the peer was lost. The storage covered
|
|
|
|
* by the requests on the transfer gets marked as our of sync. Called from the
|
|
|
|
* receiver thread and the worker thread.
|
|
|
|
*/
|
2011-05-30 14:32:41 +00:00
|
|
|
void tl_clear(struct drbd_connection *connection)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-05-30 14:32:41 +00:00
|
|
|
tl_restart(connection, CONNECTION_LOST_WHILE_PENDING);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2012-03-26 14:47:11 +00:00
|
|
|
|
2011-07-05 13:38:59 +00:00
|
|
|
/**
|
2011-07-03 11:26:43 +00:00
|
|
|
* tl_abort_disk_io() - Abort disk I/O for all requests for a certain device in the TL
|
|
|
|
* @device: DRBD device.
|
2011-07-05 13:38:59 +00:00
|
|
|
*/
|
2011-07-03 11:26:43 +00:00
|
|
|
void tl_abort_disk_io(struct drbd_device *device)
|
2011-07-05 13:38:59 +00:00
|
|
|
{
|
2011-05-31 12:33:49 +00:00
|
|
|
struct drbd_connection *connection = first_peer_device(device)->connection;
|
2011-11-28 14:04:49 +00:00
|
|
|
struct drbd_request *req, *r;
|
2010-12-16 13:47:39 +00:00
|
|
|
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_lock_irq(&connection->resource->req_lock);
|
2011-05-30 14:32:41 +00:00
|
|
|
list_for_each_entry_safe(req, r, &connection->transfer_log, tl_requests) {
|
2011-07-15 21:52:44 +00:00
|
|
|
if (!(req->rq_state & RQ_LOCAL_PENDING))
|
|
|
|
continue;
|
2011-07-28 13:27:51 +00:00
|
|
|
if (req->device != device)
|
2011-11-28 14:04:49 +00:00
|
|
|
continue;
|
|
|
|
_req_mod(req, ABORT_DISK_IO);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_unlock_irq(&connection->resource->req_lock);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int drbd_thread_setup(void *arg)
|
|
|
|
{
|
|
|
|
struct drbd_thread *thi = (struct drbd_thread *) arg;
|
2011-07-21 11:45:21 +00:00
|
|
|
struct drbd_resource *resource = thi->resource;
|
2009-09-25 23:07:19 +00:00
|
|
|
unsigned long flags;
|
|
|
|
int retval;
|
|
|
|
|
2011-02-08 14:35:58 +00:00
|
|
|
snprintf(current->comm, sizeof(current->comm), "drbd_%c_%s",
|
2011-06-08 20:17:38 +00:00
|
|
|
thi->name[0],
|
2011-07-21 11:45:21 +00:00
|
|
|
resource->name);
|
2011-02-08 14:35:58 +00:00
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
restart:
|
|
|
|
retval = thi->function(thi);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&thi->t_lock, flags);
|
|
|
|
|
2011-01-25 14:43:39 +00:00
|
|
|
/* if the receiver has been "EXITING", the last thing it did
|
2009-09-25 23:07:19 +00:00
|
|
|
* was set the conn state to "StandAlone",
|
|
|
|
* if now a re-connect request comes in, conn state goes C_UNCONNECTED,
|
|
|
|
* and receiver thread will be "started".
|
2011-01-25 14:43:39 +00:00
|
|
|
* drbd_thread_start needs to set "RESTARTING" in that case.
|
2009-09-25 23:07:19 +00:00
|
|
|
* t_state check and assignment needs to be within the same spinlock,
|
2011-01-25 14:43:39 +00:00
|
|
|
* so either thread_start sees EXITING, and can remap to RESTARTING,
|
|
|
|
* or thread_start see NONE, and can proceed as normal.
|
2009-09-25 23:07:19 +00:00
|
|
|
*/
|
|
|
|
|
2011-01-25 14:43:39 +00:00
|
|
|
if (thi->t_state == RESTARTING) {
|
2011-07-21 11:45:21 +00:00
|
|
|
drbd_info(resource, "Restarting %s thread\n", thi->name);
|
2011-01-25 14:43:39 +00:00
|
|
|
thi->t_state = RUNNING;
|
2009-09-25 23:07:19 +00:00
|
|
|
spin_unlock_irqrestore(&thi->t_lock, flags);
|
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
|
|
|
|
thi->task = NULL;
|
2011-01-25 14:43:39 +00:00
|
|
|
thi->t_state = NONE;
|
2009-09-25 23:07:19 +00:00
|
|
|
smp_mb();
|
2011-05-02 09:47:18 +00:00
|
|
|
complete_all(&thi->stop);
|
2009-09-25 23:07:19 +00:00
|
|
|
spin_unlock_irqrestore(&thi->t_lock, flags);
|
|
|
|
|
2011-07-21 11:45:21 +00:00
|
|
|
drbd_info(resource, "Terminating %s\n", current->comm);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
/* Release mod reference taken when thread was started */
|
2011-04-22 13:23:32 +00:00
|
|
|
|
2011-07-21 11:45:21 +00:00
|
|
|
if (thi->connection)
|
|
|
|
kref_put(&thi->connection->kref, drbd_destroy_connection);
|
|
|
|
kref_put(&resource->kref, drbd_destroy_resource);
|
2009-09-25 23:07:19 +00:00
|
|
|
module_put(THIS_MODULE);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2011-07-21 11:45:21 +00:00
|
|
|
static void drbd_thread_init(struct drbd_resource *resource, struct drbd_thread *thi,
|
2011-08-10 13:05:02 +00:00
|
|
|
int (*func) (struct drbd_thread *), const char *name)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
spin_lock_init(&thi->t_lock);
|
|
|
|
thi->task = NULL;
|
2011-01-25 14:43:39 +00:00
|
|
|
thi->t_state = NONE;
|
2009-09-25 23:07:19 +00:00
|
|
|
thi->function = func;
|
2011-07-21 11:45:21 +00:00
|
|
|
thi->resource = resource;
|
|
|
|
thi->connection = NULL;
|
2011-08-10 13:05:02 +00:00
|
|
|
thi->name = name;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int drbd_thread_start(struct drbd_thread *thi)
|
|
|
|
{
|
2011-07-21 11:45:21 +00:00
|
|
|
struct drbd_resource *resource = thi->resource;
|
2009-09-25 23:07:19 +00:00
|
|
|
struct task_struct *nt;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/* is used from state engine doing drbd_thread_stop_nowait,
|
|
|
|
* while holding the req lock irqsave */
|
|
|
|
spin_lock_irqsave(&thi->t_lock, flags);
|
|
|
|
|
|
|
|
switch (thi->t_state) {
|
2011-01-25 14:43:39 +00:00
|
|
|
case NONE:
|
2011-07-21 11:45:21 +00:00
|
|
|
drbd_info(resource, "Starting %s thread (from %s [%d])\n",
|
2011-02-04 13:00:37 +00:00
|
|
|
thi->name, current->comm, current->pid);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
/* Get ref on module for thread - this is released when thread exits */
|
|
|
|
if (!try_module_get(THIS_MODULE)) {
|
2011-07-21 11:45:21 +00:00
|
|
|
drbd_err(resource, "Failed to get module reference in drbd_thread_start\n");
|
2009-09-25 23:07:19 +00:00
|
|
|
spin_unlock_irqrestore(&thi->t_lock, flags);
|
2010-12-09 14:03:57 +00:00
|
|
|
return false;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-07-21 11:45:21 +00:00
|
|
|
kref_get(&resource->kref);
|
|
|
|
if (thi->connection)
|
|
|
|
kref_get(&thi->connection->kref);
|
2011-04-22 13:23:32 +00:00
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
init_completion(&thi->stop);
|
|
|
|
thi->reset_cpu_mask = 1;
|
2011-01-25 14:43:39 +00:00
|
|
|
thi->t_state = RUNNING;
|
2009-09-25 23:07:19 +00:00
|
|
|
spin_unlock_irqrestore(&thi->t_lock, flags);
|
|
|
|
flush_signals(current); /* otherw. may get -ERESTARTNOINTR */
|
|
|
|
|
|
|
|
nt = kthread_create(drbd_thread_setup, (void *) thi,
|
2011-07-21 11:45:21 +00:00
|
|
|
"drbd_%c_%s", thi->name[0], thi->resource->name);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
if (IS_ERR(nt)) {
|
2011-07-21 11:45:21 +00:00
|
|
|
drbd_err(resource, "Couldn't start thread\n");
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-21 11:45:21 +00:00
|
|
|
if (thi->connection)
|
|
|
|
kref_put(&thi->connection->kref, drbd_destroy_connection);
|
|
|
|
kref_put(&resource->kref, drbd_destroy_resource);
|
2009-09-25 23:07:19 +00:00
|
|
|
module_put(THIS_MODULE);
|
2010-12-09 14:03:57 +00:00
|
|
|
return false;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
spin_lock_irqsave(&thi->t_lock, flags);
|
|
|
|
thi->task = nt;
|
2011-01-25 14:43:39 +00:00
|
|
|
thi->t_state = RUNNING;
|
2009-09-25 23:07:19 +00:00
|
|
|
spin_unlock_irqrestore(&thi->t_lock, flags);
|
|
|
|
wake_up_process(nt);
|
|
|
|
break;
|
2011-01-25 14:43:39 +00:00
|
|
|
case EXITING:
|
|
|
|
thi->t_state = RESTARTING;
|
2011-07-21 11:45:21 +00:00
|
|
|
drbd_info(resource, "Restarting %s thread (from %s [%d])\n",
|
2011-02-04 13:00:37 +00:00
|
|
|
thi->name, current->comm, current->pid);
|
2009-09-25 23:07:19 +00:00
|
|
|
/* fall through */
|
2011-01-25 14:43:39 +00:00
|
|
|
case RUNNING:
|
|
|
|
case RESTARTING:
|
2009-09-25 23:07:19 +00:00
|
|
|
default:
|
|
|
|
spin_unlock_irqrestore(&thi->t_lock, flags);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-12-09 14:03:57 +00:00
|
|
|
return true;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
2011-01-25 14:43:39 +00:00
|
|
|
enum drbd_thread_state ns = restart ? RESTARTING : EXITING;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
/* may be called from state engine, holding the req lock irqsave */
|
|
|
|
spin_lock_irqsave(&thi->t_lock, flags);
|
|
|
|
|
2011-01-25 14:43:39 +00:00
|
|
|
if (thi->t_state == NONE) {
|
2009-09-25 23:07:19 +00:00
|
|
|
spin_unlock_irqrestore(&thi->t_lock, flags);
|
|
|
|
if (restart)
|
|
|
|
drbd_thread_start(thi);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (thi->t_state != ns) {
|
|
|
|
if (thi->task == NULL) {
|
|
|
|
spin_unlock_irqrestore(&thi->t_lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
thi->t_state = ns;
|
|
|
|
smp_mb();
|
|
|
|
init_completion(&thi->stop);
|
|
|
|
if (thi->task != current)
|
|
|
|
force_sig(DRBD_SIGKILL, thi->task);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&thi->t_lock, flags);
|
|
|
|
|
|
|
|
if (wait)
|
|
|
|
wait_for_completion(&thi->stop);
|
|
|
|
}
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
int conn_lowest_minor(struct drbd_connection *connection)
|
2011-02-08 11:46:30 +00:00
|
|
|
{
|
2011-06-21 15:23:59 +00:00
|
|
|
struct drbd_peer_device *peer_device;
|
|
|
|
int vnr = 0, minor = -1;
|
2011-02-22 07:07:03 +00:00
|
|
|
|
2011-04-12 05:53:32 +00:00
|
|
|
rcu_read_lock();
|
2011-06-21 15:23:59 +00:00
|
|
|
peer_device = idr_get_next(&connection->peer_devices, &vnr);
|
|
|
|
if (peer_device)
|
|
|
|
minor = device_to_minor(peer_device->device);
|
2011-04-12 05:53:32 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
2011-06-21 15:23:59 +00:00
|
|
|
return minor;
|
2011-02-08 11:46:30 +00:00
|
|
|
}
|
2011-02-22 07:07:03 +00:00
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/**
|
|
|
|
* drbd_calc_cpu_mask() - Generate CPU masks, spread over all CPUs
|
|
|
|
*
|
2011-07-22 12:29:02 +00:00
|
|
|
* Forces all threads of a resource onto the same CPU. This is beneficial for
|
2009-09-25 23:07:19 +00:00
|
|
|
* DRBD's performance. May be overwritten by user's configuration.
|
|
|
|
*/
|
2011-07-22 12:29:02 +00:00
|
|
|
static void drbd_calc_cpu_mask(cpumask_var_t *cpu_mask)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-07-22 12:29:02 +00:00
|
|
|
unsigned int *resources_per_cpu, min_index = ~0;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-22 12:29:02 +00:00
|
|
|
resources_per_cpu = kzalloc(nr_cpu_ids * sizeof(*resources_per_cpu), GFP_KERNEL);
|
|
|
|
if (resources_per_cpu) {
|
|
|
|
struct drbd_resource *resource;
|
|
|
|
unsigned int cpu, min = ~0;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-22 12:29:02 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
for_each_resource_rcu(resource, &drbd_resources) {
|
|
|
|
for_each_cpu(cpu, resource->cpu_mask)
|
|
|
|
resources_per_cpu[cpu]++;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2011-07-22 12:29:02 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
if (resources_per_cpu[cpu] < min) {
|
|
|
|
min = resources_per_cpu[cpu];
|
|
|
|
min_index = cpu;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
kfree(resources_per_cpu);
|
|
|
|
}
|
|
|
|
if (min_index == ~0) {
|
|
|
|
cpumask_setall(*cpu_mask);
|
|
|
|
return;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2011-07-22 12:29:02 +00:00
|
|
|
cpumask_set_cpu(min_index, *cpu_mask);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_thread_current_set_cpu() - modifies the cpu mask of the _current_ thread
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: DRBD device.
|
2011-02-07 10:14:38 +00:00
|
|
|
* @thi: drbd_thread object
|
2009-09-25 23:07:19 +00:00
|
|
|
*
|
|
|
|
* call in the "main loop" of _all_ threads, no need for any mutex, current won't die
|
|
|
|
* prematurely.
|
|
|
|
*/
|
2011-02-08 11:46:30 +00:00
|
|
|
void drbd_thread_current_set_cpu(struct drbd_thread *thi)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-07-21 11:45:21 +00:00
|
|
|
struct drbd_resource *resource = thi->resource;
|
2009-09-25 23:07:19 +00:00
|
|
|
struct task_struct *p = current;
|
2011-02-04 13:00:37 +00:00
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
if (!thi->reset_cpu_mask)
|
|
|
|
return;
|
|
|
|
thi->reset_cpu_mask = 0;
|
2011-07-21 11:45:21 +00:00
|
|
|
set_cpus_allowed_ptr(p, resource->cpu_mask);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2011-07-22 12:29:02 +00:00
|
|
|
#else
|
|
|
|
#define drbd_calc_cpu_mask(A) ({})
|
2009-09-25 23:07:19 +00:00
|
|
|
#endif
|
|
|
|
|
2011-03-30 09:38:49 +00:00
|
|
|
/**
|
|
|
|
* drbd_header_size - size of a packet header
|
|
|
|
*
|
|
|
|
* The header size is a multiple of 8, so any payload following the header is
|
|
|
|
* word aligned on 64-bit architectures. (The bitmap send and receive code
|
|
|
|
* relies on this.)
|
|
|
|
*/
|
2011-05-30 14:32:41 +00:00
|
|
|
unsigned int drbd_header_size(struct drbd_connection *connection)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-05-30 14:32:41 +00:00
|
|
|
if (connection->agreed_pro_version >= 100) {
|
2011-03-30 14:00:17 +00:00
|
|
|
BUILD_BUG_ON(!IS_ALIGNED(sizeof(struct p_header100), 8));
|
|
|
|
return sizeof(struct p_header100);
|
|
|
|
} else {
|
|
|
|
BUILD_BUG_ON(sizeof(struct p_header80) !=
|
|
|
|
sizeof(struct p_header95));
|
|
|
|
BUILD_BUG_ON(!IS_ALIGNED(sizeof(struct p_header80), 8));
|
|
|
|
return sizeof(struct p_header80);
|
|
|
|
}
|
2011-03-30 09:38:49 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-30 10:54:42 +00:00
|
|
|
static unsigned int prepare_header80(struct p_header80 *h, enum drbd_packet cmd, int size)
|
2011-01-19 15:57:39 +00:00
|
|
|
{
|
|
|
|
h->magic = cpu_to_be32(DRBD_MAGIC);
|
|
|
|
h->command = cpu_to_be16(cmd);
|
|
|
|
h->length = cpu_to_be16(size);
|
2011-03-30 10:54:42 +00:00
|
|
|
return sizeof(struct p_header80);
|
2011-01-19 15:57:39 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-30 10:54:42 +00:00
|
|
|
static unsigned int prepare_header95(struct p_header95 *h, enum drbd_packet cmd, int size)
|
2011-01-19 15:57:39 +00:00
|
|
|
{
|
|
|
|
h->magic = cpu_to_be16(DRBD_MAGIC_BIG);
|
2009-09-25 23:07:19 +00:00
|
|
|
h->command = cpu_to_be16(cmd);
|
2011-03-22 12:17:47 +00:00
|
|
|
h->length = cpu_to_be32(size);
|
2011-03-30 10:54:42 +00:00
|
|
|
return sizeof(struct p_header95);
|
2011-01-19 15:57:39 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-30 14:00:17 +00:00
|
|
|
static unsigned int prepare_header100(struct p_header100 *h, enum drbd_packet cmd,
|
|
|
|
int size, int vnr)
|
|
|
|
{
|
|
|
|
h->magic = cpu_to_be32(DRBD_MAGIC_100);
|
|
|
|
h->volume = cpu_to_be16(vnr);
|
|
|
|
h->command = cpu_to_be16(cmd);
|
|
|
|
h->length = cpu_to_be32(size);
|
|
|
|
h->pad = 0;
|
|
|
|
return sizeof(struct p_header100);
|
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
static unsigned int prepare_header(struct drbd_connection *connection, int vnr,
|
2011-03-30 14:00:17 +00:00
|
|
|
void *buffer, enum drbd_packet cmd, int size)
|
2011-02-07 14:32:04 +00:00
|
|
|
{
|
2011-05-30 14:32:41 +00:00
|
|
|
if (connection->agreed_pro_version >= 100)
|
2011-03-30 14:00:17 +00:00
|
|
|
return prepare_header100(buffer, cmd, size, vnr);
|
2011-05-30 14:32:41 +00:00
|
|
|
else if (connection->agreed_pro_version >= 95 &&
|
2011-03-30 14:00:17 +00:00
|
|
|
size > DRBD_MAX_SIZE_H80_PACKET)
|
2011-03-30 10:54:42 +00:00
|
|
|
return prepare_header95(buffer, cmd, size);
|
2011-02-07 14:32:04 +00:00
|
|
|
else
|
2011-03-30 10:54:42 +00:00
|
|
|
return prepare_header80(buffer, cmd, size);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
static void *__conn_prepare_command(struct drbd_connection *connection,
|
2011-04-29 11:19:58 +00:00
|
|
|
struct drbd_socket *sock)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-04-29 11:19:58 +00:00
|
|
|
if (!sock->socket)
|
|
|
|
return NULL;
|
2011-05-30 14:32:41 +00:00
|
|
|
return sock->sbuf + drbd_header_size(connection);
|
2011-04-29 11:19:58 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
void *conn_prepare_command(struct drbd_connection *connection, struct drbd_socket *sock)
|
2011-03-29 14:55:40 +00:00
|
|
|
{
|
2011-04-29 11:19:58 +00:00
|
|
|
void *p;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-29 14:55:40 +00:00
|
|
|
mutex_lock(&sock->mutex);
|
2011-05-30 14:32:41 +00:00
|
|
|
p = __conn_prepare_command(connection, sock);
|
2011-04-29 11:19:58 +00:00
|
|
|
if (!p)
|
2011-03-29 14:55:40 +00:00
|
|
|
mutex_unlock(&sock->mutex);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-04-29 11:19:58 +00:00
|
|
|
return p;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
void *drbd_prepare_command(struct drbd_peer_device *peer_device, struct drbd_socket *sock)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
return conn_prepare_command(peer_device->connection, sock);
|
2011-03-29 14:55:40 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
static int __send_command(struct drbd_connection *connection, int vnr,
|
2011-03-29 14:55:40 +00:00
|
|
|
struct drbd_socket *sock, enum drbd_packet cmd,
|
|
|
|
unsigned int header_size, void *data,
|
|
|
|
unsigned int size)
|
|
|
|
{
|
|
|
|
int msg_flags;
|
|
|
|
int err;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-29 14:55:40 +00:00
|
|
|
/*
|
|
|
|
* Called with @data == NULL and the size of the data blocks in @size
|
|
|
|
* for commands that send data blocks. For those commands, omit the
|
|
|
|
* MSG_MORE flag: this will increase the likelihood that data blocks
|
|
|
|
* which are page aligned on the sender will end up page aligned on the
|
|
|
|
* receiver.
|
|
|
|
*/
|
|
|
|
msg_flags = data ? MSG_MORE : 0;
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
header_size += prepare_header(connection, vnr, sock->sbuf, cmd,
|
2011-03-30 10:54:42 +00:00
|
|
|
header_size + size);
|
2011-05-30 14:32:41 +00:00
|
|
|
err = drbd_send_all(connection, sock->socket, sock->sbuf, header_size,
|
2011-03-29 14:55:40 +00:00
|
|
|
msg_flags);
|
|
|
|
if (data && !err)
|
2011-05-30 14:32:41 +00:00
|
|
|
err = drbd_send_all(connection, sock->socket, data, size, 0);
|
2014-02-05 05:13:53 +00:00
|
|
|
/* DRBD protocol "pings" are latency critical.
|
|
|
|
* This is supposed to trigger tcp_push_pending_frames() */
|
|
|
|
if (!err && (cmd == P_PING || cmd == P_PING_ACK))
|
|
|
|
drbd_tcp_nodelay(sock->socket);
|
|
|
|
|
2011-03-29 14:55:40 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
static int __conn_send_command(struct drbd_connection *connection, struct drbd_socket *sock,
|
2011-04-29 11:19:58 +00:00
|
|
|
enum drbd_packet cmd, unsigned int header_size,
|
|
|
|
void *data, unsigned int size)
|
|
|
|
{
|
2011-05-30 14:32:41 +00:00
|
|
|
return __send_command(connection, 0, sock, cmd, header_size, data, size);
|
2011-04-29 11:19:58 +00:00
|
|
|
}
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
int conn_send_command(struct drbd_connection *connection, struct drbd_socket *sock,
|
2011-03-29 14:55:40 +00:00
|
|
|
enum drbd_packet cmd, unsigned int header_size,
|
|
|
|
void *data, unsigned int size)
|
|
|
|
{
|
|
|
|
int err;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
err = __conn_send_command(connection, sock, cmd, header_size, data, size);
|
2011-03-29 14:55:40 +00:00
|
|
|
mutex_unlock(&sock->mutex);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_command(struct drbd_peer_device *peer_device, struct drbd_socket *sock,
|
2011-03-29 14:55:40 +00:00
|
|
|
enum drbd_packet cmd, unsigned int header_size,
|
|
|
|
void *data, unsigned int size)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
err = __send_command(peer_device->connection, peer_device->device->vnr,
|
|
|
|
sock, cmd, header_size, data, size);
|
2011-03-29 14:55:40 +00:00
|
|
|
mutex_unlock(&sock->mutex);
|
|
|
|
return err;
|
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
int drbd_send_ping(struct drbd_connection *connection)
|
2011-03-22 09:55:48 +00:00
|
|
|
{
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
sock = &connection->meta;
|
|
|
|
if (!conn_prepare_command(connection, sock))
|
2011-03-28 12:23:08 +00:00
|
|
|
return -EIO;
|
2011-05-30 14:32:41 +00:00
|
|
|
return conn_send_command(connection, sock, P_PING, 0, NULL, 0);
|
2011-03-22 09:55:48 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
int drbd_send_ping_ack(struct drbd_connection *connection)
|
2011-03-22 09:55:48 +00:00
|
|
|
{
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
sock = &connection->meta;
|
|
|
|
if (!conn_prepare_command(connection, sock))
|
2011-03-28 12:23:08 +00:00
|
|
|
return -EIO;
|
2011-05-30 14:32:41 +00:00
|
|
|
return conn_send_command(connection, sock, P_PING_ACK, 0, NULL, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_sync_param(struct drbd_peer_device *peer_device)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-03-21 23:49:36 +00:00
|
|
|
struct drbd_socket *sock;
|
2010-07-06 15:25:54 +00:00
|
|
|
struct p_rs_param_95 *p;
|
2011-03-28 12:23:08 +00:00
|
|
|
int 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-08 22:47:13 +00:00
|
|
|
const int apv = peer_device->connection->agreed_pro_version;
|
2011-03-28 12:23:08 +00:00
|
|
|
enum drbd_packet cmd;
|
2011-04-19 15:10:19 +00:00
|
|
|
struct net_conf *nc;
|
2011-05-03 13:00:55 +00:00
|
|
|
struct disk_conf *dc;
|
2011-03-28 12:23:08 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-04-19 15:10:19 +00:00
|
|
|
rcu_read_lock();
|
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-08 22:47:13 +00:00
|
|
|
nc = rcu_dereference(peer_device->connection->net_conf);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
size = apv <= 87 ? sizeof(struct p_rs_param)
|
|
|
|
: apv == 88 ? sizeof(struct p_rs_param)
|
2011-04-19 15:10:19 +00:00
|
|
|
+ strlen(nc->verify_alg) + 1
|
2010-07-06 15:25:54 +00:00
|
|
|
: apv <= 94 ? sizeof(struct p_rs_param_89)
|
|
|
|
: /* apv >= 95 */ sizeof(struct p_rs_param_95);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-28 12:23:08 +00:00
|
|
|
cmd = apv >= 89 ? P_SYNC_PARAM89 : P_SYNC_PARAM;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-28 12:23:08 +00:00
|
|
|
/* initialize verify_alg and csums_alg */
|
|
|
|
memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
if (get_ldev(peer_device->device)) {
|
|
|
|
dc = rcu_dereference(peer_device->device->ldev->disk_conf);
|
2011-05-11 12:29:52 +00:00
|
|
|
p->resync_rate = cpu_to_be32(dc->resync_rate);
|
2011-05-03 13:00:55 +00:00
|
|
|
p->c_plan_ahead = cpu_to_be32(dc->c_plan_ahead);
|
|
|
|
p->c_delay_target = cpu_to_be32(dc->c_delay_target);
|
|
|
|
p->c_fill_target = cpu_to_be32(dc->c_fill_target);
|
|
|
|
p->c_max_rate = cpu_to_be32(dc->c_max_rate);
|
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-08 22:47:13 +00:00
|
|
|
put_ldev(peer_device->device);
|
2011-03-28 12:23:08 +00:00
|
|
|
} else {
|
2011-05-11 12:29:52 +00:00
|
|
|
p->resync_rate = cpu_to_be32(DRBD_RESYNC_RATE_DEF);
|
2011-03-28 12:23:08 +00:00
|
|
|
p->c_plan_ahead = cpu_to_be32(DRBD_C_PLAN_AHEAD_DEF);
|
|
|
|
p->c_delay_target = cpu_to_be32(DRBD_C_DELAY_TARGET_DEF);
|
|
|
|
p->c_fill_target = cpu_to_be32(DRBD_C_FILL_TARGET_DEF);
|
|
|
|
p->c_max_rate = cpu_to_be32(DRBD_C_MAX_RATE_DEF);
|
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-28 12:23:08 +00:00
|
|
|
if (apv >= 88)
|
2011-04-19 15:10:19 +00:00
|
|
|
strcpy(p->verify_alg, nc->verify_alg);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (apv >= 89)
|
2011-04-19 15:10:19 +00:00
|
|
|
strcpy(p->csums_alg, nc->csums_alg);
|
|
|
|
rcu_read_unlock();
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
return drbd_send_command(peer_device, sock, cmd, size, NULL, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
int __drbd_send_protocol(struct drbd_connection *connection, enum drbd_packet cmd)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
2009-09-25 23:07:19 +00:00
|
|
|
struct p_protocol *p;
|
2011-04-19 15:10:19 +00:00
|
|
|
struct net_conf *nc;
|
2011-03-28 12:23:08 +00:00
|
|
|
int size, cf;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
sock = &connection->data;
|
|
|
|
p = __conn_prepare_command(connection, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-04-19 15:10:19 +00:00
|
|
|
rcu_read_lock();
|
2011-05-30 14:32:41 +00:00
|
|
|
nc = rcu_dereference(connection->net_conf);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
if (nc->tentative && connection->agreed_pro_version < 92) {
|
2011-04-19 15:10:19 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
mutex_unlock(&sock->mutex);
|
2011-07-06 09:01:44 +00:00
|
|
|
drbd_err(connection, "--dry-run is not supported by peer");
|
2011-04-19 15:10:19 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-28 12:23:08 +00:00
|
|
|
size = sizeof(*p);
|
2011-05-30 14:32:41 +00:00
|
|
|
if (connection->agreed_pro_version >= 87)
|
2011-04-19 15:10:19 +00:00
|
|
|
size += strlen(nc->integrity_alg) + 1;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-04-19 15:10:19 +00:00
|
|
|
p->protocol = cpu_to_be32(nc->wire_protocol);
|
|
|
|
p->after_sb_0p = cpu_to_be32(nc->after_sb_0p);
|
|
|
|
p->after_sb_1p = cpu_to_be32(nc->after_sb_1p);
|
|
|
|
p->after_sb_2p = cpu_to_be32(nc->after_sb_2p);
|
|
|
|
p->two_primaries = cpu_to_be32(nc->two_primaries);
|
2010-02-02 20:03:50 +00:00
|
|
|
cf = 0;
|
2011-05-06 18:00:02 +00:00
|
|
|
if (nc->discard_my_data)
|
|
|
|
cf |= CF_DISCARD_MY_DATA;
|
2011-06-28 12:18:12 +00:00
|
|
|
if (nc->tentative)
|
2011-03-28 12:23:08 +00:00
|
|
|
cf |= CF_DRY_RUN;
|
2010-02-02 20:03:50 +00:00
|
|
|
p->conn_flags = cpu_to_be32(cf);
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
if (connection->agreed_pro_version >= 87)
|
2011-04-19 15:10:19 +00:00
|
|
|
strcpy(p->integrity_alg, nc->integrity_alg);
|
|
|
|
rcu_read_unlock();
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
return __conn_send_command(connection, sock, cmd, size, NULL, 0);
|
2011-04-29 11:19:58 +00:00
|
|
|
}
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
int drbd_send_protocol(struct drbd_connection *connection)
|
2011-04-29 11:19:58 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
mutex_lock(&connection->data.mutex);
|
|
|
|
err = __drbd_send_protocol(connection, P_PROTOCOL);
|
|
|
|
mutex_unlock(&connection->data.mutex);
|
2011-04-29 11:19:58 +00:00
|
|
|
|
|
|
|
return err;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
static int _drbd_send_uuids(struct drbd_peer_device *peer_device, u64 uuid_flags)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
struct drbd_device *device = peer_device->device;
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_uuids *p;
|
2009-09-25 23:07:19 +00:00
|
|
|
int i;
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (!get_ldev_if_state(device, D_NEGOTIATING))
|
2011-03-16 00:07:20 +00:00
|
|
|
return 0;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p) {
|
2011-07-03 11:26:43 +00:00
|
|
|
put_ldev(device);
|
2011-03-28 12:23:08 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
2011-07-03 11:26:43 +00:00
|
|
|
spin_lock_irq(&device->ldev->md.uuid_lock);
|
2009-09-25 23:07:19 +00:00
|
|
|
for (i = UI_CURRENT; i < UI_SIZE; i++)
|
2011-07-03 11:26:43 +00:00
|
|
|
p->uuid[i] = cpu_to_be64(device->ldev->md.uuid[i]);
|
|
|
|
spin_unlock_irq(&device->ldev->md.uuid_lock);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
device->comm_bm_set = drbd_bm_total_weight(device);
|
|
|
|
p->uuid[UI_SIZE] = cpu_to_be64(device->comm_bm_set);
|
2011-04-19 15:10:19 +00:00
|
|
|
rcu_read_lock();
|
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-08 22:47:13 +00:00
|
|
|
uuid_flags |= rcu_dereference(peer_device->connection->net_conf)->discard_my_data ? 1 : 0;
|
2011-04-19 15:10:19 +00:00
|
|
|
rcu_read_unlock();
|
2011-07-03 11:26:43 +00:00
|
|
|
uuid_flags |= test_bit(CRASHED_PRIMARY, &device->flags) ? 2 : 0;
|
|
|
|
uuid_flags |= device->new_state_tmp.disk == D_INCONSISTENT ? 4 : 0;
|
2011-03-28 12:23:08 +00:00
|
|
|
p->uuid[UI_FLAGS] = cpu_to_be64(uuid_flags);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
put_ldev(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-08 22:47:13 +00:00
|
|
|
return drbd_send_command(peer_device, sock, P_UUIDS, sizeof(*p), NULL, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_uuids(struct drbd_peer_device *peer_device)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
return _drbd_send_uuids(peer_device, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_uuids_skip_initial_sync(struct drbd_peer_device *peer_device)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
return _drbd_send_uuids(peer_device, 8);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_print_uuids(struct drbd_device *device, const char *text)
|
2011-01-20 12:25:21 +00:00
|
|
|
{
|
2011-07-03 11:26:43 +00:00
|
|
|
if (get_ldev_if_state(device, D_NEGOTIATING)) {
|
|
|
|
u64 *uuid = device->ldev->md.uuid;
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_info(device, "%s %016llX:%016llX:%016llX:%016llX\n",
|
2011-01-20 12:25:21 +00:00
|
|
|
text,
|
|
|
|
(unsigned long long)uuid[UI_CURRENT],
|
|
|
|
(unsigned long long)uuid[UI_BITMAP],
|
|
|
|
(unsigned long long)uuid[UI_HISTORY_START],
|
|
|
|
(unsigned long long)uuid[UI_HISTORY_END]);
|
2011-07-03 11:26:43 +00:00
|
|
|
put_ldev(device);
|
2011-01-20 12:25:21 +00:00
|
|
|
} else {
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_info(device, "%s effective data uuid: %016llX\n",
|
2011-01-20 12:25:21 +00:00
|
|
|
text,
|
2011-07-03 11:26:43 +00:00
|
|
|
(unsigned long long)device->ed_uuid);
|
2011-01-20 12:25:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
void drbd_gen_and_send_sync_uuid(struct drbd_peer_device *peer_device)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
struct drbd_device *device = peer_device->device;
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_rs_uuid *p;
|
2010-12-17 20:14:23 +00:00
|
|
|
u64 uuid;
|
|
|
|
|
2011-06-27 14:23:33 +00:00
|
|
|
D_ASSERT(device, device->state.disk == D_UP_TO_DATE);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
uuid = device->ldev->md.uuid[UI_BITMAP];
|
2011-10-05 13:54:18 +00:00
|
|
|
if (uuid && uuid != UUID_JUST_CREATED)
|
|
|
|
uuid = uuid + UUID_NEW_BM_OFFSET;
|
|
|
|
else
|
|
|
|
get_random_bytes(&uuid, sizeof(u64));
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_uuid_set(device, UI_BITMAP, uuid);
|
|
|
|
drbd_print_uuids(device, "updated sync UUID");
|
|
|
|
drbd_md_sync(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (p) {
|
|
|
|
p->uuid = cpu_to_be64(uuid);
|
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-08 22:47:13 +00:00
|
|
|
drbd_send_command(peer_device, sock, P_SYNC_UUID, sizeof(*p), NULL, 0);
|
2011-03-28 12:23:08 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2016-06-13 22:26:31 +00:00
|
|
|
/* communicated if (agreed_features & DRBD_FF_WSAME) */
|
|
|
|
void assign_p_sizes_qlim(struct drbd_device *device, struct p_sizes *p, struct request_queue *q)
|
|
|
|
{
|
|
|
|
if (q) {
|
|
|
|
p->qlim->physical_block_size = cpu_to_be32(queue_physical_block_size(q));
|
|
|
|
p->qlim->logical_block_size = cpu_to_be32(queue_logical_block_size(q));
|
|
|
|
p->qlim->alignment_offset = cpu_to_be32(queue_alignment_offset(q));
|
|
|
|
p->qlim->io_min = cpu_to_be32(queue_io_min(q));
|
|
|
|
p->qlim->io_opt = cpu_to_be32(queue_io_opt(q));
|
|
|
|
p->qlim->discard_enabled = blk_queue_discard(q);
|
|
|
|
p->qlim->discard_zeroes_data = queue_discard_zeroes_data(q);
|
|
|
|
p->qlim->write_same_capable = !!q->limits.max_write_same_sectors;
|
|
|
|
} else {
|
|
|
|
q = device->rq_queue;
|
|
|
|
p->qlim->physical_block_size = cpu_to_be32(queue_physical_block_size(q));
|
|
|
|
p->qlim->logical_block_size = cpu_to_be32(queue_logical_block_size(q));
|
|
|
|
p->qlim->alignment_offset = 0;
|
|
|
|
p->qlim->io_min = cpu_to_be32(queue_io_min(q));
|
|
|
|
p->qlim->io_opt = cpu_to_be32(queue_io_opt(q));
|
|
|
|
p->qlim->discard_enabled = 0;
|
|
|
|
p->qlim->discard_zeroes_data = 0;
|
|
|
|
p->qlim->write_same_capable = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_sizes(struct drbd_peer_device *peer_device, int trigger_reply, enum dds_flags flags)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
struct drbd_device *device = peer_device->device;
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_sizes *p;
|
2009-09-25 23:07:19 +00:00
|
|
|
sector_t d_size, u_size;
|
2012-06-25 17:15:58 +00:00
|
|
|
int q_order_type;
|
|
|
|
unsigned int max_bio_size;
|
2016-06-13 22:26:31 +00:00
|
|
|
unsigned int packet_size;
|
|
|
|
|
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2016-06-13 22:26:31 +00:00
|
|
|
packet_size = sizeof(*p);
|
|
|
|
if (peer_device->connection->agreed_features & DRBD_FF_WSAME)
|
|
|
|
packet_size += sizeof(p->qlim[0]);
|
|
|
|
|
|
|
|
memset(p, 0, packet_size);
|
2011-07-03 11:26:43 +00:00
|
|
|
if (get_ldev_if_state(device, D_NEGOTIATING)) {
|
2016-06-13 22:26:31 +00:00
|
|
|
struct request_queue *q = bdev_get_queue(device->ldev->backing_bdev);
|
2011-07-03 11:26:43 +00:00
|
|
|
d_size = drbd_get_max_capacity(device->ldev);
|
2011-05-03 13:00:55 +00:00
|
|
|
rcu_read_lock();
|
2011-07-03 11:26:43 +00:00
|
|
|
u_size = rcu_dereference(device->ldev->disk_conf)->disk_size;
|
2011-05-03 13:00:55 +00:00
|
|
|
rcu_read_unlock();
|
2011-07-03 11:26:43 +00:00
|
|
|
q_order_type = drbd_queue_order_type(device);
|
2016-06-13 22:26:31 +00:00
|
|
|
max_bio_size = queue_max_hw_sectors(q) << 9;
|
2012-06-25 17:15:58 +00:00
|
|
|
max_bio_size = min(max_bio_size, DRBD_MAX_BIO_SIZE);
|
2016-06-13 22:26:31 +00:00
|
|
|
assign_p_sizes_qlim(device, p, q);
|
2011-07-03 11:26:43 +00:00
|
|
|
put_ldev(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
} else {
|
|
|
|
d_size = 0;
|
|
|
|
u_size = 0;
|
|
|
|
q_order_type = QUEUE_ORDERED_NONE;
|
2011-05-20 14:39:13 +00:00
|
|
|
max_bio_size = DRBD_MAX_BIO_SIZE; /* ... multiple BIOs per peer_request */
|
2016-06-13 22:26:31 +00:00
|
|
|
assign_p_sizes_qlim(device, p, NULL);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
if (peer_device->connection->agreed_pro_version <= 94)
|
2012-11-09 13:18:43 +00:00
|
|
|
max_bio_size = min(max_bio_size, DRBD_MAX_SIZE_H80_PACKET);
|
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-08 22:47:13 +00:00
|
|
|
else if (peer_device->connection->agreed_pro_version < 100)
|
2012-11-09 13:18:43 +00:00
|
|
|
max_bio_size = min(max_bio_size, DRBD_MAX_BIO_SIZE_P95);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-28 12:23:08 +00:00
|
|
|
p->d_size = cpu_to_be64(d_size);
|
|
|
|
p->u_size = cpu_to_be64(u_size);
|
2011-07-03 11:26:43 +00:00
|
|
|
p->c_size = cpu_to_be64(trigger_reply ? 0 : drbd_get_capacity(device->this_bdev));
|
2011-03-28 12:23:08 +00:00
|
|
|
p->max_bio_size = cpu_to_be32(max_bio_size);
|
|
|
|
p->queue_order_type = cpu_to_be16(q_order_type);
|
|
|
|
p->dds_flags = cpu_to_be16(flags);
|
2016-06-13 22:26:31 +00:00
|
|
|
|
|
|
|
return drbd_send_command(peer_device, sock, P_SIZES, packet_size, NULL, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-10-27 14:52:30 +00:00
|
|
|
* drbd_send_current_state() - Sends the drbd state to the peer
|
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-08 22:47:13 +00:00
|
|
|
* @peer_device: DRBD peer device.
|
2009-09-25 23:07:19 +00:00
|
|
|
*/
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_current_state(struct drbd_peer_device *peer_device)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-03-21 23:49:36 +00:00
|
|
|
struct drbd_socket *sock;
|
2011-03-28 12:23:08 +00:00
|
|
|
struct p_state *p;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
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-08 22:47:13 +00:00
|
|
|
p->state = cpu_to_be32(peer_device->device->state.i); /* Within the send mutex */
|
|
|
|
return drbd_send_command(peer_device, sock, P_STATE, sizeof(*p), NULL, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-10-27 14:52:30 +00:00
|
|
|
/**
|
|
|
|
* drbd_send_state() - After a state change, sends the new state to the peer
|
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-08 22:47:13 +00:00
|
|
|
* @peer_device: DRBD peer device.
|
2011-11-10 12:16:13 +00:00
|
|
|
* @state: the state to send, not necessarily the current state.
|
2011-10-27 14:52:30 +00:00
|
|
|
*
|
|
|
|
* Each state change queues an "after_state_ch" work, which will eventually
|
|
|
|
* send the resulting new state to the peer. If more state changes happen
|
|
|
|
* between queuing and processing of the after_state_ch work, we still
|
|
|
|
* want to send each intermediary state in the order it occurred.
|
|
|
|
*/
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_state(struct drbd_peer_device *peer_device, union drbd_state state)
|
2011-10-27 14:52:30 +00:00
|
|
|
{
|
2011-11-10 12:16:13 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_state *p;
|
2011-10-27 14:52:30 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2011-11-10 12:16:13 +00:00
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
|
|
|
p->state = cpu_to_be32(state.i); /* Within the send mutex */
|
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-08 22:47:13 +00:00
|
|
|
return drbd_send_command(peer_device, sock, P_STATE, sizeof(*p), NULL, 0);
|
2011-11-10 12:16:13 +00:00
|
|
|
}
|
2011-10-27 14:52:30 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_state_req(struct drbd_peer_device *peer_device, union drbd_state mask, union drbd_state val)
|
2011-03-28 12:23:08 +00:00
|
|
|
{
|
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_req_state *p;
|
2011-10-27 14:52:30 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
|
|
|
p->mask = cpu_to_be32(mask.i);
|
|
|
|
p->val = cpu_to_be32(val.i);
|
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-08 22:47:13 +00:00
|
|
|
return drbd_send_command(peer_device, sock, P_STATE_CHG_REQ, sizeof(*p), NULL, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2011-10-27 14:52:30 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
int conn_send_state_req(struct drbd_connection *connection, union drbd_state mask, union drbd_state val)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-03-28 12:23:08 +00:00
|
|
|
enum drbd_packet cmd;
|
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_req_state *p;
|
2011-10-27 14:52:30 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
cmd = connection->agreed_pro_version < 100 ? P_STATE_CHG_REQ : P_CONN_ST_CHG_REQ;
|
|
|
|
sock = &connection->data;
|
|
|
|
p = conn_prepare_command(connection, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
|
|
|
p->mask = cpu_to_be32(mask.i);
|
|
|
|
p->val = cpu_to_be32(val.i);
|
2011-05-30 14:32:41 +00:00
|
|
|
return conn_send_command(connection, sock, cmd, sizeof(*p), NULL, 0);
|
2011-10-27 14:52:30 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
void drbd_send_sr_reply(struct drbd_peer_device *peer_device, enum drbd_state_rv retcode)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_req_state_reply *p;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->meta;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (p) {
|
|
|
|
p->retcode = cpu_to_be32(retcode);
|
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-08 22:47:13 +00:00
|
|
|
drbd_send_command(peer_device, sock, P_STATE_CHG_REPLY, sizeof(*p), NULL, 0);
|
2011-03-28 12:23:08 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
void conn_send_sr_reply(struct drbd_connection *connection, enum drbd_state_rv retcode)
|
2011-02-15 10:09:33 +00:00
|
|
|
{
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_req_state_reply *p;
|
2011-05-30 14:32:41 +00:00
|
|
|
enum drbd_packet cmd = connection->agreed_pro_version < 100 ? P_STATE_CHG_REPLY : P_CONN_ST_CHG_REPLY;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
sock = &connection->meta;
|
|
|
|
p = conn_prepare_command(connection, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (p) {
|
|
|
|
p->retcode = cpu_to_be32(retcode);
|
2011-05-30 14:32:41 +00:00
|
|
|
conn_send_command(connection, sock, cmd, sizeof(*p), NULL, 0);
|
2011-03-28 12:23:08 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-03-22 16:20:45 +00:00
|
|
|
static void dcbp_set_code(struct p_compressed_bm *p, enum drbd_bitmap_code code)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-03-22 16:20:45 +00:00
|
|
|
BUG_ON(code & ~0xf);
|
|
|
|
p->encoding = (p->encoding & ~0xf) | code;
|
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-22 16:20:45 +00:00
|
|
|
static void dcbp_set_start(struct p_compressed_bm *p, int set)
|
|
|
|
{
|
|
|
|
p->encoding = (p->encoding & ~0x80) | (set ? 0x80 : 0);
|
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-22 16:20:45 +00:00
|
|
|
static void dcbp_set_pad_bits(struct p_compressed_bm *p, int n)
|
|
|
|
{
|
|
|
|
BUG_ON(n & ~0x7);
|
|
|
|
p->encoding = (p->encoding & (~0x7 << 4)) | (n << 4);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
static int fill_bitmap_rle_bits(struct drbd_device *device,
|
2011-03-30 09:53:51 +00:00
|
|
|
struct p_compressed_bm *p,
|
|
|
|
unsigned int size,
|
|
|
|
struct bm_xfer_ctx *c)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
struct bitstream bs;
|
|
|
|
unsigned long plain_bits;
|
|
|
|
unsigned long tmp;
|
|
|
|
unsigned long rl;
|
|
|
|
unsigned len;
|
|
|
|
unsigned toggle;
|
2011-04-19 15:10:19 +00:00
|
|
|
int bits, use_rle;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
/* may we use this feature? */
|
2011-04-19 15:10:19 +00:00
|
|
|
rcu_read_lock();
|
2011-05-31 12:33:49 +00:00
|
|
|
use_rle = rcu_dereference(first_peer_device(device)->connection->net_conf)->use_rle;
|
2011-04-19 15:10:19 +00:00
|
|
|
rcu_read_unlock();
|
2011-05-31 12:33:49 +00:00
|
|
|
if (!use_rle || first_peer_device(device)->connection->agreed_pro_version < 90)
|
2011-04-19 15:10:19 +00:00
|
|
|
return 0;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
if (c->bit_offset >= c->bm_bits)
|
|
|
|
return 0; /* nothing to do. */
|
|
|
|
|
|
|
|
/* use at most thus many bytes */
|
2011-03-30 09:53:51 +00:00
|
|
|
bitstream_init(&bs, p->code, size, 0);
|
|
|
|
memset(p->code, 0, size);
|
2009-09-25 23:07:19 +00:00
|
|
|
/* plain bits covered in this code string */
|
|
|
|
plain_bits = 0;
|
|
|
|
|
|
|
|
/* p->encoding & 0x80 stores whether the first run length is set.
|
|
|
|
* bit offset is implicit.
|
|
|
|
* start with toggle == 2 to be able to tell the first iteration */
|
|
|
|
toggle = 2;
|
|
|
|
|
|
|
|
/* see how much plain bits we can stuff into one packet
|
|
|
|
* using RLE and VLI. */
|
|
|
|
do {
|
2011-07-03 11:26:43 +00:00
|
|
|
tmp = (toggle == 0) ? _drbd_bm_find_next_zero(device, c->bit_offset)
|
|
|
|
: _drbd_bm_find_next(device, c->bit_offset);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (tmp == -1UL)
|
|
|
|
tmp = c->bm_bits;
|
|
|
|
rl = tmp - c->bit_offset;
|
|
|
|
|
|
|
|
if (toggle == 2) { /* first iteration */
|
|
|
|
if (rl == 0) {
|
|
|
|
/* the first checked bit was set,
|
|
|
|
* store start value, */
|
2011-03-22 16:20:45 +00:00
|
|
|
dcbp_set_start(p, 1);
|
2009-09-25 23:07:19 +00:00
|
|
|
/* but skip encoding of zero run length */
|
|
|
|
toggle = !toggle;
|
|
|
|
continue;
|
|
|
|
}
|
2011-03-22 16:20:45 +00:00
|
|
|
dcbp_set_start(p, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* paranoia: catch zero runlength.
|
|
|
|
* can only happen if bitmap is modified while we scan it. */
|
|
|
|
if (rl == 0) {
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "unexpected zero runlength while encoding bitmap "
|
2009-09-25 23:07:19 +00:00
|
|
|
"t:%u bo:%lu\n", toggle, c->bit_offset);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
bits = vli_encode_bits(&bs, rl);
|
|
|
|
if (bits == -ENOBUFS) /* buffer full */
|
|
|
|
break;
|
|
|
|
if (bits <= 0) {
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "error while encoding bitmap: %d\n", bits);
|
2009-09-25 23:07:19 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
toggle = !toggle;
|
|
|
|
plain_bits += rl;
|
|
|
|
c->bit_offset = tmp;
|
|
|
|
} while (c->bit_offset < c->bm_bits);
|
|
|
|
|
|
|
|
len = bs.cur.b - p->code + !!bs.cur.bit;
|
|
|
|
|
|
|
|
if (plain_bits < (len << 3)) {
|
|
|
|
/* incompressible with this method.
|
|
|
|
* we need to rewind both word and bit position. */
|
|
|
|
c->bit_offset -= plain_bits;
|
|
|
|
bm_xfer_ctx_bit_to_word_offset(c);
|
|
|
|
c->bit_offset = c->word_offset * BITS_PER_LONG;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* RLE + VLI was able to compress it just fine.
|
|
|
|
* update c->word_offset. */
|
|
|
|
bm_xfer_ctx_bit_to_word_offset(c);
|
|
|
|
|
|
|
|
/* store pad_bits */
|
2011-03-22 16:20:45 +00:00
|
|
|
dcbp_set_pad_bits(p, (8 - bs.cur.bit) & 0x7);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2010-12-11 17:51:50 +00:00
|
|
|
/**
|
|
|
|
* send_bitmap_rle_or_plain
|
|
|
|
*
|
|
|
|
* Return 0 when done, 1 when another iteration is needed, and a negative error
|
|
|
|
* code upon failure.
|
|
|
|
*/
|
|
|
|
static int
|
2011-07-03 11:26:43 +00:00
|
|
|
send_bitmap_rle_or_plain(struct drbd_device *device, struct bm_xfer_ctx *c)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-05-31 12:33:49 +00:00
|
|
|
struct drbd_socket *sock = &first_peer_device(device)->connection->data;
|
|
|
|
unsigned int header_size = drbd_header_size(first_peer_device(device)->connection);
|
2011-03-30 10:54:42 +00:00
|
|
|
struct p_compressed_bm *p = sock->sbuf + header_size;
|
2010-12-09 23:45:25 +00:00
|
|
|
int len, err;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
len = fill_bitmap_rle_bits(device, p,
|
2011-03-30 10:54:42 +00:00
|
|
|
DRBD_SOCKET_BUFFER_SIZE - header_size - sizeof(*p), c);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (len < 0)
|
2010-12-11 17:51:50 +00:00
|
|
|
return -EIO;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
if (len) {
|
2011-03-22 16:20:45 +00:00
|
|
|
dcbp_set_code(p, RLE_VLI_Bits);
|
2011-05-31 12:33:49 +00:00
|
|
|
err = __send_command(first_peer_device(device)->connection, device->vnr, sock,
|
2011-03-28 12:23:08 +00:00
|
|
|
P_COMPRESSED_BITMAP, sizeof(*p) + len,
|
|
|
|
NULL, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
c->packets[0]++;
|
2011-03-30 10:54:42 +00:00
|
|
|
c->bytes[0] += header_size + sizeof(*p) + len;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
if (c->bit_offset >= c->bm_bits)
|
|
|
|
len = 0; /* DONE */
|
|
|
|
} else {
|
|
|
|
/* was not compressible.
|
|
|
|
* send a buffer full of plain text bits instead. */
|
2011-03-30 09:53:51 +00:00
|
|
|
unsigned int data_size;
|
|
|
|
unsigned long num_words;
|
2011-03-30 10:54:42 +00:00
|
|
|
unsigned long *p = sock->sbuf + header_size;
|
2011-03-30 09:53:51 +00:00
|
|
|
|
|
|
|
data_size = DRBD_SOCKET_BUFFER_SIZE - header_size;
|
2011-03-30 10:54:42 +00:00
|
|
|
num_words = min_t(size_t, data_size / sizeof(*p),
|
2011-03-30 09:53:51 +00:00
|
|
|
c->bm_words - c->word_offset);
|
2011-03-30 10:54:42 +00:00
|
|
|
len = num_words * sizeof(*p);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (len)
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_bm_get_lel(device, c->word_offset, num_words, p);
|
2011-05-31 12:33:49 +00:00
|
|
|
err = __send_command(first_peer_device(device)->connection, device->vnr, sock, P_BITMAP, len, NULL, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
c->word_offset += num_words;
|
|
|
|
c->bit_offset = c->word_offset * BITS_PER_LONG;
|
|
|
|
|
|
|
|
c->packets[1]++;
|
2011-03-30 09:53:51 +00:00
|
|
|
c->bytes[1] += header_size + len;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
if (c->bit_offset > c->bm_bits)
|
|
|
|
c->bit_offset = c->bm_bits;
|
|
|
|
}
|
2010-12-09 23:45:25 +00:00
|
|
|
if (!err) {
|
2010-12-11 17:51:50 +00:00
|
|
|
if (len == 0) {
|
2011-07-03 11:26:43 +00:00
|
|
|
INFO_bm_xfer_stats(device, "send", c);
|
2010-12-11 17:51:50 +00:00
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return -EIO;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* See the comment at receive_bitmap() */
|
2011-07-03 11:26:43 +00:00
|
|
|
static int _drbd_send_bitmap(struct drbd_device *device)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
struct bm_xfer_ctx c;
|
2010-12-11 17:51:50 +00:00
|
|
|
int err;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (!expect(device->bitmap))
|
2010-12-09 14:03:57 +00:00
|
|
|
return false;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (get_ldev(device)) {
|
|
|
|
if (drbd_md_test_flag(device->ldev, MDF_FULL_SYNC)) {
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_info(device, "Writing the whole bitmap, MDF_FullSync was set.\n");
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_bm_set_all(device);
|
|
|
|
if (drbd_bm_write(device)) {
|
2009-09-25 23:07:19 +00:00
|
|
|
/* write_bm did fail! Leave full sync flag set in Meta P_DATA
|
|
|
|
* but otherwise process as per normal - need to tell other
|
|
|
|
* side that a full resync is required! */
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "Failed to write bitmap to disk!\n");
|
2009-09-25 23:07:19 +00:00
|
|
|
} else {
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_md_clear_flag(device, MDF_FULL_SYNC);
|
|
|
|
drbd_md_sync(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
}
|
2011-07-03 11:26:43 +00:00
|
|
|
put_ldev(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
c = (struct bm_xfer_ctx) {
|
2011-07-03 11:26:43 +00:00
|
|
|
.bm_bits = drbd_bm_bits(device),
|
|
|
|
.bm_words = drbd_bm_words(device),
|
2009-09-25 23:07:19 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
do {
|
2011-07-03 11:26:43 +00:00
|
|
|
err = send_bitmap_rle_or_plain(device, &c);
|
2010-12-11 17:51:50 +00:00
|
|
|
} while (err > 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2010-12-11 17:51:50 +00:00
|
|
|
return err == 0;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
int drbd_send_bitmap(struct drbd_device *device)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-05-31 12:33:49 +00:00
|
|
|
struct drbd_socket *sock = &first_peer_device(device)->connection->data;
|
2011-03-28 12:23:08 +00:00
|
|
|
int err = -1;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-28 12:23:08 +00:00
|
|
|
mutex_lock(&sock->mutex);
|
|
|
|
if (sock->socket)
|
2011-07-03 11:26:43 +00:00
|
|
|
err = !_drbd_send_bitmap(device);
|
2011-03-28 12:23:08 +00:00
|
|
|
mutex_unlock(&sock->mutex);
|
2009-09-25 23:07:19 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
void drbd_send_b_ack(struct drbd_connection *connection, u32 barrier_nr, u32 set_size)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_barrier_ack *p;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
if (connection->cstate < C_WF_REPORT_PARAMS)
|
2011-03-28 12:23:08 +00:00
|
|
|
return;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
sock = &connection->meta;
|
|
|
|
p = conn_prepare_command(connection, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
|
|
|
return;
|
|
|
|
p->barrier = barrier_nr;
|
|
|
|
p->set_size = cpu_to_be32(set_size);
|
2011-05-30 14:32:41 +00:00
|
|
|
conn_send_command(connection, sock, P_BARRIER_ACK, sizeof(*p), NULL, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* _drbd_send_ack() - Sends an ack packet
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: DRBD device.
|
2009-09-25 23:07:19 +00:00
|
|
|
* @cmd: Packet command code.
|
|
|
|
* @sector: sector, needs to be in big endian byte order
|
|
|
|
* @blksize: size in byte, needs to be in big endian byte order
|
|
|
|
* @block_id: Id, big endian byte order
|
|
|
|
*/
|
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-08 22:47:13 +00:00
|
|
|
static int _drbd_send_ack(struct drbd_peer_device *peer_device, enum drbd_packet cmd,
|
2011-01-26 16:39:41 +00:00
|
|
|
u64 sector, u32 blksize, u64 block_id)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_block_ack *p;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
if (peer_device->device->state.conn < C_CONNECTED)
|
2011-03-28 12:23:08 +00:00
|
|
|
return -EIO;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->meta;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
2011-03-16 00:27:22 +00:00
|
|
|
return -EIO;
|
2011-03-28 12:23:08 +00:00
|
|
|
p->sector = sector;
|
|
|
|
p->block_id = block_id;
|
|
|
|
p->blksize = blksize;
|
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-08 22:47:13 +00:00
|
|
|
p->seq_num = cpu_to_be32(atomic_inc_return(&peer_device->device->packet_seq));
|
|
|
|
return drbd_send_command(peer_device, sock, cmd, sizeof(*p), NULL, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2010-10-06 09:46:55 +00:00
|
|
|
/* dp->sector and dp->block_id already/still in network byte order,
|
|
|
|
* data_size is payload size according to dp->head,
|
|
|
|
* and may need to be corrected for digest 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-08 22:47:13 +00:00
|
|
|
void drbd_send_ack_dp(struct drbd_peer_device *peer_device, enum drbd_packet cmd,
|
2011-03-16 00:30:14 +00:00
|
|
|
struct p_data *dp, int data_size)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
if (peer_device->connection->peer_integrity_tfm)
|
2016-01-24 13:19:21 +00:00
|
|
|
data_size -= crypto_ahash_digestsize(peer_device->connection->peer_integrity_tfm);
|
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-08 22:47:13 +00:00
|
|
|
_drbd_send_ack(peer_device, cmd, dp->sector, cpu_to_be32(data_size),
|
2011-03-16 00:30:14 +00:00
|
|
|
dp->block_id);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
void drbd_send_ack_rp(struct drbd_peer_device *peer_device, enum drbd_packet cmd,
|
2011-03-16 00:30:14 +00:00
|
|
|
struct p_block_req *rp)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
_drbd_send_ack(peer_device, cmd, rp->sector, rp->blksize, rp->block_id);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_send_ack() - Sends an ack packet
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: DRBD device
|
2011-02-04 14:57:48 +00:00
|
|
|
* @cmd: packet command code
|
|
|
|
* @peer_req: peer request
|
2009-09-25 23:07:19 +00:00
|
|
|
*/
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_ack(struct drbd_peer_device *peer_device, enum drbd_packet cmd,
|
2011-02-04 14:57:48 +00:00
|
|
|
struct drbd_peer_request *peer_req)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
return _drbd_send_ack(peer_device, cmd,
|
2011-03-16 14:39:08 +00:00
|
|
|
cpu_to_be64(peer_req->i.sector),
|
|
|
|
cpu_to_be32(peer_req->i.size),
|
|
|
|
peer_req->block_id);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This function misuses the block_id field to signal if the blocks
|
|
|
|
* are is sync or not. */
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_ack_ex(struct drbd_peer_device *peer_device, enum drbd_packet cmd,
|
2009-09-25 23:07:19 +00: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-08 22:47:13 +00:00
|
|
|
return _drbd_send_ack(peer_device, cmd,
|
2009-09-25 23:07:19 +00:00
|
|
|
cpu_to_be64(sector),
|
|
|
|
cpu_to_be32(blksize),
|
|
|
|
cpu_to_be64(block_id));
|
|
|
|
}
|
|
|
|
|
2016-06-13 22:26:13 +00:00
|
|
|
int drbd_send_rs_deallocated(struct drbd_peer_device *peer_device,
|
|
|
|
struct drbd_peer_request *peer_req)
|
|
|
|
{
|
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_block_desc *p;
|
|
|
|
|
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
|
|
|
p->sector = cpu_to_be64(peer_req->i.sector);
|
|
|
|
p->blksize = cpu_to_be32(peer_req->i.size);
|
|
|
|
p->pad = 0;
|
|
|
|
return drbd_send_command(peer_device, sock, P_RS_DEALLOCATED, sizeof(*p), NULL, 0);
|
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_drequest(struct drbd_peer_device *peer_device, int cmd,
|
2009-09-25 23:07:19 +00:00
|
|
|
sector_t sector, int size, u64 block_id)
|
|
|
|
{
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_block_req *p;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
|
|
|
p->sector = cpu_to_be64(sector);
|
|
|
|
p->block_id = block_id;
|
|
|
|
p->blksize = cpu_to_be32(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-08 22:47:13 +00:00
|
|
|
return drbd_send_command(peer_device, sock, cmd, sizeof(*p), NULL, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_drequest_csum(struct drbd_peer_device *peer_device, sector_t sector, int size,
|
2011-01-26 16:39:41 +00:00
|
|
|
void *digest, int digest_size, enum drbd_packet cmd)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_block_req *p;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-28 12:23:08 +00:00
|
|
|
/* FIXME: Put the digest into the preallocated socket buffer. */
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
|
|
|
p->sector = cpu_to_be64(sector);
|
|
|
|
p->block_id = ID_SYNCER /* unused */;
|
|
|
|
p->blksize = cpu_to_be32(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-08 22:47:13 +00:00
|
|
|
return drbd_send_command(peer_device, sock, cmd, sizeof(*p), digest, digest_size);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_ov_request(struct drbd_peer_device *peer_device, sector_t sector, int size)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_block_req *p;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
|
|
|
p->sector = cpu_to_be64(sector);
|
|
|
|
p->block_id = ID_SYNCER /* unused */;
|
|
|
|
p->blksize = cpu_to_be32(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-08 22:47:13 +00:00
|
|
|
return drbd_send_command(peer_device, sock, P_OV_REQUEST, sizeof(*p), NULL, 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* called on sndtimeo
|
2010-12-09 14:03:57 +00:00
|
|
|
* returns false if we should retry,
|
|
|
|
* true if we think connection is dead
|
2009-09-25 23:07:19 +00:00
|
|
|
*/
|
2011-05-30 14:32:41 +00:00
|
|
|
static int we_should_drop_the_connection(struct drbd_connection *connection, struct socket *sock)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
int drop_it;
|
2011-07-03 11:26:43 +00:00
|
|
|
/* long elapsed = (long)(jiffies - device->last_received); */
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
drop_it = connection->meta.socket == sock
|
2015-03-16 14:01:00 +00:00
|
|
|
|| !connection->ack_receiver.task
|
|
|
|
|| get_t_state(&connection->ack_receiver) != RUNNING
|
2011-05-30 14:32:41 +00:00
|
|
|
|| connection->cstate < C_WF_REPORT_PARAMS;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
if (drop_it)
|
2010-12-09 14:03:57 +00:00
|
|
|
return true;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
drop_it = !--connection->ko_count;
|
2009-09-25 23:07:19 +00:00
|
|
|
if (!drop_it) {
|
2011-07-06 09:01:44 +00:00
|
|
|
drbd_err(connection, "[%s/%d] sock_sendmsg time expired, ko = %u\n",
|
2011-05-30 14:32:41 +00:00
|
|
|
current->comm, current->pid, connection->ko_count);
|
|
|
|
request_ping(connection);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
return drop_it; /* && (device->state == R_PRIMARY) */;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
static void drbd_update_congested(struct drbd_connection *connection)
|
2011-01-26 17:45:11 +00:00
|
|
|
{
|
2011-05-30 14:32:41 +00:00
|
|
|
struct sock *sk = connection->data.socket->sk;
|
2011-01-26 17:45:11 +00:00
|
|
|
if (sk->sk_wmem_queued > sk->sk_sndbuf * 4 / 5)
|
2011-05-30 14:32:41 +00:00
|
|
|
set_bit(NET_CONGESTED, &connection->flags);
|
2011-01-26 17:45:11 +00:00
|
|
|
}
|
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
/* The idea of sendpage seems to be to put some kind of reference
|
|
|
|
* to the page into the skb, and to hand it over to the NIC. In
|
|
|
|
* this process get_page() gets called.
|
|
|
|
*
|
|
|
|
* As soon as the page was really sent over the network put_page()
|
|
|
|
* gets called by some part of the network layer. [ NIC driver? ]
|
|
|
|
*
|
|
|
|
* [ get_page() / put_page() increment/decrement the count. If count
|
|
|
|
* reaches 0 the page will be freed. ]
|
|
|
|
*
|
|
|
|
* This works nicely with pages from FSs.
|
|
|
|
* But this means that in protocol A we might signal IO completion too early!
|
|
|
|
*
|
|
|
|
* In order not to corrupt data during a resync we must make sure
|
|
|
|
* that we do not reuse our own buffer pages (EEs) to early, therefore
|
|
|
|
* we have the net_ee list.
|
|
|
|
*
|
|
|
|
* XFS seems to have problems, still, it submits pages with page_count == 0!
|
|
|
|
* As a workaround, we disable sendpage on pages
|
|
|
|
* with page_count == 0 or PageSlab.
|
|
|
|
*/
|
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-08 22:47:13 +00:00
|
|
|
static int _drbd_no_send_page(struct drbd_peer_device *peer_device, struct page *page,
|
2011-03-16 08:41:10 +00:00
|
|
|
int offset, size_t size, unsigned msg_flags)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-03-16 08:41:10 +00:00
|
|
|
struct socket *socket;
|
|
|
|
void *addr;
|
|
|
|
int err;
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
socket = peer_device->connection->data.socket;
|
2011-03-16 08:41:10 +00:00
|
|
|
addr = kmap(page) + offset;
|
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-08 22:47:13 +00:00
|
|
|
err = drbd_send_all(peer_device->connection, socket, addr, size, msg_flags);
|
2009-09-25 23:07:19 +00:00
|
|
|
kunmap(page);
|
2011-03-16 08:41:10 +00:00
|
|
|
if (!err)
|
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-08 22:47:13 +00:00
|
|
|
peer_device->device->send_cnt += size >> 9;
|
2011-03-16 08:41:10 +00:00
|
|
|
return err;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
static int _drbd_send_page(struct drbd_peer_device *peer_device, struct page *page,
|
2010-05-25 14:26:16 +00:00
|
|
|
int offset, size_t size, unsigned msg_flags)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
struct socket *socket = peer_device->connection->data.socket;
|
2009-09-25 23:07:19 +00:00
|
|
|
mm_segment_t oldfs = get_fs();
|
|
|
|
int len = size;
|
2011-03-16 09:44:16 +00:00
|
|
|
int err = -EIO;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
/* e.g. XFS meta- & log-data is in slab pages, which have a
|
|
|
|
* page_count of 0 and/or have PageSlab() set.
|
|
|
|
* we cannot use send_page for those, as that does get_page();
|
|
|
|
* put_page(); and would cause either a VM_BUG directly, or
|
|
|
|
* __page_cache_release a page that would actually still be referenced
|
|
|
|
* by someone, leading to some obscure delayed Oops somewhere else. */
|
|
|
|
if (disable_sendpage || (page_count(page) < 1) || PageSlab(page))
|
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-08 22:47:13 +00:00
|
|
|
return _drbd_no_send_page(peer_device, page, offset, size, msg_flags);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2010-05-25 14:26:16 +00:00
|
|
|
msg_flags |= MSG_NOSIGNAL;
|
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-08 22:47:13 +00:00
|
|
|
drbd_update_congested(peer_device->connection);
|
2009-09-25 23:07:19 +00:00
|
|
|
set_fs(KERNEL_DS);
|
|
|
|
do {
|
2011-03-16 09:44:16 +00:00
|
|
|
int sent;
|
|
|
|
|
|
|
|
sent = socket->ops->sendpage(socket, page, offset, len, msg_flags);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (sent <= 0) {
|
2011-03-16 09:44:16 +00:00
|
|
|
if (sent == -EAGAIN) {
|
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-08 22:47:13 +00:00
|
|
|
if (we_should_drop_the_connection(peer_device->connection, socket))
|
2011-03-16 09:44:16 +00:00
|
|
|
break;
|
|
|
|
continue;
|
|
|
|
}
|
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-08 22:47:13 +00:00
|
|
|
drbd_warn(peer_device->device, "%s: size=%d len=%d sent=%d\n",
|
2009-09-25 23:07:19 +00:00
|
|
|
__func__, (int)size, len, sent);
|
2011-03-16 09:44:16 +00:00
|
|
|
if (sent < 0)
|
|
|
|
err = sent;
|
2009-09-25 23:07:19 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
len -= sent;
|
|
|
|
offset += sent;
|
2011-07-03 11:26:43 +00:00
|
|
|
} while (len > 0 /* THINK && device->cstate >= C_CONNECTED*/);
|
2009-09-25 23:07:19 +00:00
|
|
|
set_fs(oldfs);
|
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-08 22:47:13 +00:00
|
|
|
clear_bit(NET_CONGESTED, &peer_device->connection->flags);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-16 09:44:16 +00:00
|
|
|
if (len == 0) {
|
|
|
|
err = 0;
|
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-08 22:47:13 +00:00
|
|
|
peer_device->device->send_cnt += size >> 9;
|
2011-03-16 09:44:16 +00:00
|
|
|
}
|
|
|
|
return err;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
static int _drbd_send_bio(struct drbd_peer_device *peer_device, struct bio *bio)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2013-11-24 01:19:00 +00:00
|
|
|
struct bio_vec bvec;
|
|
|
|
struct bvec_iter iter;
|
|
|
|
|
2010-05-25 14:26:16 +00:00
|
|
|
/* hint all but last page with MSG_MORE */
|
2013-11-24 01:19:00 +00:00
|
|
|
bio_for_each_segment(bvec, bio, iter) {
|
2011-03-16 10:46:33 +00:00
|
|
|
int err;
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
err = _drbd_no_send_page(peer_device, bvec.bv_page,
|
2013-11-24 01:19:00 +00:00
|
|
|
bvec.bv_offset, bvec.bv_len,
|
2013-08-07 21:26:21 +00:00
|
|
|
bio_iter_last(bvec, iter)
|
2013-11-24 01:19:00 +00:00
|
|
|
? 0 : MSG_MORE);
|
2011-03-16 10:46:33 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
2016-06-13 22:26:31 +00:00
|
|
|
/* REQ_OP_WRITE_SAME has only one segment */
|
|
|
|
if (bio_op(bio) == REQ_OP_WRITE_SAME)
|
|
|
|
break;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2011-03-16 10:46:33 +00:00
|
|
|
return 0;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
static int _drbd_send_zc_bio(struct drbd_peer_device *peer_device, struct bio *bio)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2013-11-24 01:19:00 +00:00
|
|
|
struct bio_vec bvec;
|
|
|
|
struct bvec_iter iter;
|
|
|
|
|
2010-05-25 14:26:16 +00:00
|
|
|
/* hint all but last page with MSG_MORE */
|
2013-11-24 01:19:00 +00:00
|
|
|
bio_for_each_segment(bvec, bio, iter) {
|
2011-03-16 10:46:33 +00:00
|
|
|
int err;
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
err = _drbd_send_page(peer_device, bvec.bv_page,
|
2013-11-24 01:19:00 +00:00
|
|
|
bvec.bv_offset, bvec.bv_len,
|
2013-08-07 21:26:21 +00:00
|
|
|
bio_iter_last(bvec, iter) ? 0 : MSG_MORE);
|
2011-03-16 10:46:33 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
2016-06-13 22:26:31 +00:00
|
|
|
/* REQ_OP_WRITE_SAME has only one segment */
|
|
|
|
if (bio_op(bio) == REQ_OP_WRITE_SAME)
|
|
|
|
break;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2011-03-16 10:46:33 +00:00
|
|
|
return 0;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
static int _drbd_send_zc_ee(struct drbd_peer_device *peer_device,
|
2011-02-04 14:57:48 +00:00
|
|
|
struct drbd_peer_request *peer_req)
|
2010-05-14 15:10:48 +00:00
|
|
|
{
|
2011-02-04 14:57:48 +00:00
|
|
|
struct page *page = peer_req->pages;
|
|
|
|
unsigned len = peer_req->i.size;
|
2011-03-16 09:49:09 +00:00
|
|
|
int err;
|
2011-02-04 14:57:48 +00:00
|
|
|
|
2010-05-25 14:26:16 +00:00
|
|
|
/* hint all but last page with MSG_MORE */
|
2010-05-14 15:10:48 +00:00
|
|
|
page_chain_for_each(page) {
|
|
|
|
unsigned l = min_t(unsigned, len, PAGE_SIZE);
|
2011-03-16 09:49:09 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
err = _drbd_send_page(peer_device, page, 0, l,
|
2011-03-16 09:49:09 +00:00
|
|
|
page_chain_next(page) ? MSG_MORE : 0);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2010-05-14 15:10:48 +00:00
|
|
|
len -= l;
|
|
|
|
}
|
2011-03-16 09:49:09 +00:00
|
|
|
return 0;
|
2010-05-14 15:10:48 +00:00
|
|
|
}
|
|
|
|
|
2016-06-05 19:32:06 +00:00
|
|
|
static u32 bio_flags_to_wire(struct drbd_connection *connection,
|
|
|
|
struct bio *bio)
|
2010-08-25 09:58:05 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
if (connection->agreed_pro_version >= 95)
|
2016-06-05 19:32:06 +00:00
|
|
|
return (bio->bi_rw & REQ_SYNC ? DP_RW_SYNC : 0) |
|
|
|
|
(bio->bi_rw & REQ_FUA ? DP_FUA : 0) |
|
2016-06-05 19:32:25 +00:00
|
|
|
(bio->bi_rw & REQ_PREFLUSH ? DP_FLUSH : 0) |
|
2016-06-13 22:26:31 +00:00
|
|
|
(bio_op(bio) == REQ_OP_WRITE_SAME ? DP_WSAME : 0) |
|
2016-06-05 19:32:06 +00:00
|
|
|
(bio_op(bio) == REQ_OP_DISCARD ? DP_DISCARD : 0);
|
2010-08-25 09:58:05 +00:00
|
|
|
else
|
2016-06-05 19:32:06 +00:00
|
|
|
return bio->bi_rw & REQ_SYNC ? DP_RW_SYNC : 0;
|
2010-08-25 09:58:05 +00:00
|
|
|
}
|
|
|
|
|
2014-04-28 16:43:24 +00:00
|
|
|
/* Used to send write or TRIM aka REQ_DISCARD requests
|
|
|
|
* R_PRIMARY -> Peer (P_DATA, P_TRIM)
|
2009-09-25 23:07:19 +00:00
|
|
|
*/
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_dblock(struct drbd_peer_device *peer_device, struct drbd_request *req)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
struct drbd_device *device = peer_device->device;
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_data *p;
|
2016-06-13 22:26:31 +00:00
|
|
|
struct p_wsame *wsame = NULL;
|
|
|
|
void *digest_out;
|
2009-09-25 23:07:19 +00:00
|
|
|
unsigned int dp_flags = 0;
|
2014-09-11 12:29:05 +00:00
|
|
|
int digest_size;
|
2011-03-28 12:23:08 +00:00
|
|
|
int err;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2014-09-11 12:29:05 +00:00
|
|
|
digest_size = peer_device->connection->integrity_tfm ?
|
2016-01-24 13:19:21 +00:00
|
|
|
crypto_ahash_digestsize(peer_device->connection->integrity_tfm) : 0;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
|
|
|
p->sector = cpu_to_be64(req->i.sector);
|
|
|
|
p->block_id = (unsigned long)req;
|
2011-07-03 11:26:43 +00:00
|
|
|
p->seq_num = cpu_to_be32(atomic_inc_return(&device->packet_seq));
|
2016-06-05 19:32:06 +00:00
|
|
|
dp_flags = bio_flags_to_wire(peer_device->connection, req->master_bio);
|
2011-07-03 11:26:43 +00:00
|
|
|
if (device->state.conn >= C_SYNC_SOURCE &&
|
|
|
|
device->state.conn <= C_PAUSED_SYNC_T)
|
2009-09-25 23:07:19 +00:00
|
|
|
dp_flags |= DP_MAY_SET_IN_SYNC;
|
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-08 22:47:13 +00:00
|
|
|
if (peer_device->connection->agreed_pro_version >= 100) {
|
2011-04-13 23:24:47 +00:00
|
|
|
if (req->rq_state & RQ_EXP_RECEIVE_ACK)
|
|
|
|
dp_flags |= DP_SEND_RECEIVE_ACK;
|
2014-03-20 10:19:22 +00:00
|
|
|
/* During resync, request an explicit write ack,
|
|
|
|
* even in protocol != C */
|
|
|
|
if (req->rq_state & RQ_EXP_WRITE_ACK
|
|
|
|
|| (dp_flags & DP_MAY_SET_IN_SYNC))
|
2011-04-13 23:24:47 +00:00
|
|
|
dp_flags |= DP_SEND_WRITE_ACK;
|
|
|
|
}
|
2011-03-28 12:23:08 +00:00
|
|
|
p->dp_flags = cpu_to_be32(dp_flags);
|
2014-04-28 16:43:24 +00:00
|
|
|
|
|
|
|
if (dp_flags & DP_DISCARD) {
|
|
|
|
struct p_trim *t = (struct p_trim*)p;
|
|
|
|
t->size = cpu_to_be32(req->i.size);
|
|
|
|
err = __send_command(peer_device->connection, device->vnr, sock, P_TRIM, sizeof(*t), NULL, 0);
|
|
|
|
goto out;
|
|
|
|
}
|
2016-06-13 22:26:31 +00:00
|
|
|
if (dp_flags & DP_WSAME) {
|
|
|
|
/* this will only work if DRBD_FF_WSAME is set AND the
|
|
|
|
* handshake agreed that all nodes and backend devices are
|
|
|
|
* WRITE_SAME capable and agree on logical_block_size */
|
|
|
|
wsame = (struct p_wsame*)p;
|
|
|
|
digest_out = wsame + 1;
|
|
|
|
wsame->size = cpu_to_be32(req->i.size);
|
|
|
|
} else
|
|
|
|
digest_out = p + 1;
|
2014-04-28 16:43:24 +00:00
|
|
|
|
|
|
|
/* our digest is still only over the payload.
|
|
|
|
* TRIM does not carry any payload. */
|
2014-09-11 12:29:05 +00:00
|
|
|
if (digest_size)
|
2016-06-13 22:26:31 +00:00
|
|
|
drbd_csum_bio(peer_device->connection->integrity_tfm, req->master_bio, digest_out);
|
|
|
|
if (wsame) {
|
|
|
|
err =
|
|
|
|
__send_command(peer_device->connection, device->vnr, sock, P_WSAME,
|
|
|
|
sizeof(*wsame) + digest_size, NULL,
|
|
|
|
bio_iovec(req->master_bio).bv_len);
|
|
|
|
} else
|
|
|
|
err =
|
|
|
|
__send_command(peer_device->connection, device->vnr, sock, P_DATA,
|
|
|
|
sizeof(*p) + digest_size, NULL, req->i.size);
|
2011-03-16 10:52:58 +00:00
|
|
|
if (!err) {
|
2010-11-10 09:36:52 +00:00
|
|
|
/* For protocol A, we have to memcpy the payload into
|
|
|
|
* socket buffers, as we may complete right away
|
|
|
|
* as soon as we handed it over to tcp, at which point the data
|
|
|
|
* pages may become invalid.
|
|
|
|
*
|
|
|
|
* For data-integrity enabled, we copy it as well, so we can be
|
|
|
|
* sure that even if the bio pages may still be modified, it
|
|
|
|
* won't change the data on the wire, thus if the digest checks
|
|
|
|
* out ok after sending on this side, but does not fit on the
|
|
|
|
* receiving side, we sure have detected corruption elsewhere.
|
|
|
|
*/
|
2014-09-11 12:29:05 +00:00
|
|
|
if (!(req->rq_state & (RQ_EXP_RECEIVE_ACK | RQ_EXP_WRITE_ACK)) || digest_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-08 22:47:13 +00:00
|
|
|
err = _drbd_send_bio(peer_device, req->master_bio);
|
2009-09-25 23:07:19 +00:00
|
|
|
else
|
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-08 22:47:13 +00:00
|
|
|
err = _drbd_send_zc_bio(peer_device, req->master_bio);
|
2010-11-10 09:36:52 +00:00
|
|
|
|
|
|
|
/* double check digest, sometimes buffers have been modified in flight. */
|
2014-09-11 12:29:05 +00:00
|
|
|
if (digest_size > 0 && digest_size <= 64) {
|
2011-05-21 16:32:29 +00:00
|
|
|
/* 64 byte, 512 bit, is the largest digest size
|
2010-11-10 09:36:52 +00:00
|
|
|
* currently supported in kernel crypto. */
|
|
|
|
unsigned char digest[64];
|
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-08 22:47:13 +00:00
|
|
|
drbd_csum_bio(peer_device->connection->integrity_tfm, req->master_bio, digest);
|
2014-09-11 12:29:05 +00:00
|
|
|
if (memcmp(p + 1, digest, digest_size)) {
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_warn(device,
|
2010-11-10 09:36:52 +00:00
|
|
|
"Digest mismatch, buffer modified by upper layers during write: %llus +%u\n",
|
2011-01-03 16:09:58 +00:00
|
|
|
(unsigned long long)req->i.sector, req->i.size);
|
2010-11-10 09:36:52 +00:00
|
|
|
}
|
2014-09-11 12:29:05 +00:00
|
|
|
} /* else if (digest_size > 64) {
|
2010-11-10 09:36:52 +00:00
|
|
|
... Be noisy about digest too large ...
|
|
|
|
} */
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2014-04-28 16:43:24 +00:00
|
|
|
out:
|
2011-03-28 12:23:08 +00:00
|
|
|
mutex_unlock(&sock->mutex); /* locked by drbd_prepare_command() */
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-16 10:52:58 +00:00
|
|
|
return err;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* answer packet, used to send data back for read requests:
|
|
|
|
* Peer -> (diskless) R_PRIMARY (P_DATA_REPLY)
|
|
|
|
* C_SYNC_SOURCE -> C_SYNC_TARGET (P_RS_DATA_REPLY)
|
|
|
|
*/
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_block(struct drbd_peer_device *peer_device, enum drbd_packet cmd,
|
2011-02-04 14:57:48 +00:00
|
|
|
struct drbd_peer_request *peer_req)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
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-08 22:47:13 +00:00
|
|
|
struct drbd_device *device = peer_device->device;
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_data *p;
|
2011-03-16 10:35:20 +00:00
|
|
|
int err;
|
2014-09-11 12:29:05 +00:00
|
|
|
int digest_size;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2014-09-11 12:29:05 +00:00
|
|
|
digest_size = peer_device->connection->integrity_tfm ?
|
2016-01-24 13:19:21 +00:00
|
|
|
crypto_ahash_digestsize(peer_device->connection->integrity_tfm) : 0;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
|
|
|
p->sector = cpu_to_be64(peer_req->i.sector);
|
|
|
|
p->block_id = peer_req->block_id;
|
|
|
|
p->seq_num = 0; /* unused */
|
2012-02-08 14:32:51 +00:00
|
|
|
p->dp_flags = 0;
|
2014-09-11 12:29:05 +00:00
|
|
|
if (digest_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-08 22:47:13 +00:00
|
|
|
drbd_csum_ee(peer_device->connection->integrity_tfm, peer_req, p + 1);
|
2014-09-11 12:29:05 +00:00
|
|
|
err = __send_command(peer_device->connection, device->vnr, sock, cmd, sizeof(*p) + digest_size, NULL, peer_req->i.size);
|
2011-03-16 10:35:20 +00:00
|
|
|
if (!err)
|
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-08 22:47:13 +00:00
|
|
|
err = _drbd_send_zc_ee(peer_device, peer_req);
|
2011-03-28 12:23:08 +00:00
|
|
|
mutex_unlock(&sock->mutex); /* locked by drbd_prepare_command() */
|
2010-05-04 10:33:58 +00:00
|
|
|
|
2011-03-16 10:35:20 +00:00
|
|
|
return err;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
int drbd_send_out_of_sync(struct drbd_peer_device *peer_device, struct drbd_request *req)
|
2010-10-27 12:33:00 +00:00
|
|
|
{
|
2011-03-28 12:23:08 +00:00
|
|
|
struct drbd_socket *sock;
|
|
|
|
struct p_block_desc *p;
|
2010-10-27 12:33:00 +00:00
|
|
|
|
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-08 22:47:13 +00:00
|
|
|
sock = &peer_device->connection->data;
|
|
|
|
p = drbd_prepare_command(peer_device, sock);
|
2011-03-28 12:23:08 +00:00
|
|
|
if (!p)
|
|
|
|
return -EIO;
|
|
|
|
p->sector = cpu_to_be64(req->i.sector);
|
|
|
|
p->blksize = cpu_to_be32(req->i.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-08 22:47:13 +00:00
|
|
|
return drbd_send_command(peer_device, sock, P_OUT_OF_SYNC, sizeof(*p), NULL, 0);
|
2010-10-27 12:33:00 +00:00
|
|
|
}
|
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
/*
|
|
|
|
drbd_send distinguishes two cases:
|
|
|
|
|
|
|
|
Packets sent via the data socket "sock"
|
|
|
|
and packets sent via the meta data socket "msock"
|
|
|
|
|
|
|
|
sock msock
|
|
|
|
-----------------+-------------------------+------------------------------
|
|
|
|
timeout conf.timeout / 2 conf.timeout / 2
|
|
|
|
timeout action send a ping via msock Abort communication
|
|
|
|
and close all sockets
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* you must have down()ed the appropriate [m]sock_mutex elsewhere!
|
|
|
|
*/
|
2011-05-30 14:32:41 +00:00
|
|
|
int drbd_send(struct drbd_connection *connection, struct socket *sock,
|
2009-09-25 23:07:19 +00:00
|
|
|
void *buf, size_t size, unsigned msg_flags)
|
|
|
|
{
|
|
|
|
struct kvec iov;
|
|
|
|
struct msghdr msg;
|
|
|
|
int rv, sent = 0;
|
|
|
|
|
|
|
|
if (!sock)
|
2010-12-09 22:52:22 +00:00
|
|
|
return -EBADR;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
/* THINK if (signal_pending) return ... ? */
|
|
|
|
|
|
|
|
iov.iov_base = buf;
|
|
|
|
iov.iov_len = size;
|
|
|
|
|
|
|
|
msg.msg_name = NULL;
|
|
|
|
msg.msg_namelen = 0;
|
|
|
|
msg.msg_control = NULL;
|
|
|
|
msg.msg_controllen = 0;
|
|
|
|
msg.msg_flags = msg_flags | MSG_NOSIGNAL;
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
if (sock == connection->data.socket) {
|
2011-04-19 15:10:19 +00:00
|
|
|
rcu_read_lock();
|
2011-05-30 14:32:41 +00:00
|
|
|
connection->ko_count = rcu_dereference(connection->net_conf)->ko_count;
|
2011-04-19 15:10:19 +00:00
|
|
|
rcu_read_unlock();
|
2011-05-30 14:32:41 +00:00
|
|
|
drbd_update_congested(connection);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
do {
|
|
|
|
rv = kernel_sendmsg(sock, &msg, &iov, 1, size);
|
|
|
|
if (rv == -EAGAIN) {
|
2011-05-30 14:32:41 +00:00
|
|
|
if (we_should_drop_the_connection(connection, sock))
|
2009-09-25 23:07:19 +00:00
|
|
|
break;
|
|
|
|
else
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (rv == -EINTR) {
|
|
|
|
flush_signals(current);
|
|
|
|
rv = 0;
|
|
|
|
}
|
|
|
|
if (rv < 0)
|
|
|
|
break;
|
|
|
|
sent += rv;
|
|
|
|
iov.iov_base += rv;
|
|
|
|
iov.iov_len -= rv;
|
|
|
|
} while (sent < size);
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
if (sock == connection->data.socket)
|
|
|
|
clear_bit(NET_CONGESTED, &connection->flags);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
if (rv <= 0) {
|
|
|
|
if (rv != -EAGAIN) {
|
2011-07-06 09:01:44 +00:00
|
|
|
drbd_err(connection, "%s_sendmsg returned %d\n",
|
2011-05-30 14:32:41 +00:00
|
|
|
sock == connection->meta.socket ? "msock" : "sock",
|
2011-02-07 14:08:48 +00:00
|
|
|
rv);
|
2011-05-30 14:32:41 +00:00
|
|
|
conn_request_state(connection, NS(conn, C_BROKEN_PIPE), CS_HARD);
|
2009-09-25 23:07:19 +00:00
|
|
|
} else
|
2011-05-30 14:32:41 +00:00
|
|
|
conn_request_state(connection, NS(conn, C_TIMEOUT), CS_HARD);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return sent;
|
|
|
|
}
|
|
|
|
|
2010-12-15 16:04:36 +00:00
|
|
|
/**
|
|
|
|
* drbd_send_all - Send an entire buffer
|
|
|
|
*
|
|
|
|
* Returns 0 upon success and a negative error value otherwise.
|
|
|
|
*/
|
2011-05-30 14:32:41 +00:00
|
|
|
int drbd_send_all(struct drbd_connection *connection, struct socket *sock, void *buffer,
|
2010-12-15 16:04:36 +00:00
|
|
|
size_t size, unsigned msg_flags)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
err = drbd_send(connection, sock, buffer, size, msg_flags);
|
2010-12-15 16:04:36 +00:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
if (err != size)
|
|
|
|
return -EIO;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
static int drbd_open(struct block_device *bdev, fmode_t mode)
|
|
|
|
{
|
2011-07-03 11:26:43 +00:00
|
|
|
struct drbd_device *device = bdev->bd_disk->private_data;
|
2009-09-25 23:07:19 +00:00
|
|
|
unsigned long flags;
|
|
|
|
int rv = 0;
|
|
|
|
|
2010-06-02 12:28:52 +00:00
|
|
|
mutex_lock(&drbd_main_mutex);
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_lock_irqsave(&device->resource->req_lock, flags);
|
2011-07-03 11:26:43 +00:00
|
|
|
/* to have a stable device->state.role
|
2009-09-25 23:07:19 +00:00
|
|
|
* and no race with updating open_cnt */
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (device->state.role != R_PRIMARY) {
|
2009-09-25 23:07:19 +00:00
|
|
|
if (mode & FMODE_WRITE)
|
|
|
|
rv = -EROFS;
|
|
|
|
else if (!allow_oos)
|
|
|
|
rv = -EMEDIUMTYPE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!rv)
|
2011-07-03 11:26:43 +00:00
|
|
|
device->open_cnt++;
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_unlock_irqrestore(&device->resource->req_lock, flags);
|
2010-06-02 12:28:52 +00:00
|
|
|
mutex_unlock(&drbd_main_mutex);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2013-05-06 01:52:57 +00:00
|
|
|
static void drbd_release(struct gendisk *gd, fmode_t mode)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-07-03 11:26:43 +00:00
|
|
|
struct drbd_device *device = gd->private_data;
|
2010-06-02 12:28:52 +00:00
|
|
|
mutex_lock(&drbd_main_mutex);
|
2011-07-03 11:26:43 +00:00
|
|
|
device->open_cnt--;
|
2010-06-02 12:28:52 +00:00
|
|
|
mutex_unlock(&drbd_main_mutex);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
static void drbd_set_defaults(struct drbd_device *device)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-03-23 13:31:09 +00:00
|
|
|
/* Beware! The actual layout differs
|
|
|
|
* between big endian and little endian */
|
2011-07-03 11:26:43 +00:00
|
|
|
device->state = (union drbd_dev_state) {
|
2009-09-25 23:07:19 +00:00
|
|
|
{ .role = R_SECONDARY,
|
|
|
|
.peer = R_UNKNOWN,
|
|
|
|
.conn = C_STANDALONE,
|
|
|
|
.disk = D_DISKLESS,
|
|
|
|
.pdsk = D_UNKNOWN,
|
|
|
|
} };
|
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_init_set_defaults(struct drbd_device *device)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
/* the memset(,0,) did most of this.
|
|
|
|
* note: only assignments, no allocation in here */
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_set_defaults(device);
|
|
|
|
|
|
|
|
atomic_set(&device->ap_bio_cnt, 0);
|
2013-12-20 10:22:13 +00:00
|
|
|
atomic_set(&device->ap_actlog_cnt, 0);
|
2011-07-03 11:26:43 +00:00
|
|
|
atomic_set(&device->ap_pending_cnt, 0);
|
|
|
|
atomic_set(&device->rs_pending_cnt, 0);
|
|
|
|
atomic_set(&device->unacked_cnt, 0);
|
|
|
|
atomic_set(&device->local_cnt, 0);
|
|
|
|
atomic_set(&device->pp_in_use_by_net, 0);
|
|
|
|
atomic_set(&device->rs_sect_in, 0);
|
|
|
|
atomic_set(&device->rs_sect_ev, 0);
|
|
|
|
atomic_set(&device->ap_in_flight, 0);
|
2014-04-01 21:53:30 +00:00
|
|
|
atomic_set(&device->md_io.in_use, 0);
|
2011-07-03 11:26:43 +00:00
|
|
|
|
|
|
|
mutex_init(&device->own_state_mutex);
|
|
|
|
device->state_mutex = &device->own_state_mutex;
|
|
|
|
|
|
|
|
spin_lock_init(&device->al_lock);
|
|
|
|
spin_lock_init(&device->peer_seq_lock);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&device->active_ee);
|
|
|
|
INIT_LIST_HEAD(&device->sync_ee);
|
|
|
|
INIT_LIST_HEAD(&device->done_ee);
|
|
|
|
INIT_LIST_HEAD(&device->read_ee);
|
|
|
|
INIT_LIST_HEAD(&device->net_ee);
|
|
|
|
INIT_LIST_HEAD(&device->resync_reads);
|
|
|
|
INIT_LIST_HEAD(&device->resync_work.list);
|
|
|
|
INIT_LIST_HEAD(&device->unplug_work.list);
|
|
|
|
INIT_LIST_HEAD(&device->bm_io_work.w.list);
|
2013-11-22 11:52:03 +00:00
|
|
|
INIT_LIST_HEAD(&device->pending_master_completion[0]);
|
|
|
|
INIT_LIST_HEAD(&device->pending_master_completion[1]);
|
|
|
|
INIT_LIST_HEAD(&device->pending_completion[0]);
|
|
|
|
INIT_LIST_HEAD(&device->pending_completion[1]);
|
2011-07-03 11:26:43 +00:00
|
|
|
|
|
|
|
device->resync_work.cb = w_resync_timer;
|
|
|
|
device->unplug_work.cb = w_send_write_hint;
|
|
|
|
device->bm_io_work.w.cb = w_bitmap_io;
|
|
|
|
|
|
|
|
init_timer(&device->resync_timer);
|
|
|
|
init_timer(&device->md_sync_timer);
|
|
|
|
init_timer(&device->start_resync_timer);
|
|
|
|
init_timer(&device->request_timer);
|
|
|
|
device->resync_timer.function = resync_timer_fn;
|
|
|
|
device->resync_timer.data = (unsigned long) device;
|
|
|
|
device->md_sync_timer.function = md_sync_timer_fn;
|
|
|
|
device->md_sync_timer.data = (unsigned long) device;
|
|
|
|
device->start_resync_timer.function = start_resync_timer_fn;
|
|
|
|
device->start_resync_timer.data = (unsigned long) device;
|
|
|
|
device->request_timer.function = request_timer_fn;
|
|
|
|
device->request_timer.data = (unsigned long) device;
|
|
|
|
|
|
|
|
init_waitqueue_head(&device->misc_wait);
|
|
|
|
init_waitqueue_head(&device->state_wait);
|
|
|
|
init_waitqueue_head(&device->ee_wait);
|
|
|
|
init_waitqueue_head(&device->al_wait);
|
|
|
|
init_waitqueue_head(&device->seq_wait);
|
|
|
|
|
|
|
|
device->resync_wenr = LC_FREE;
|
|
|
|
device->peer_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;
|
|
|
|
device->local_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void drbd_device_cleanup(struct drbd_device *device)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2010-08-11 19:21:50 +00:00
|
|
|
int i;
|
2011-05-31 12:33:49 +00:00
|
|
|
if (first_peer_device(device)->connection->receiver.t_state != NONE)
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "ASSERT FAILED: receiver t_state == %d expected 0.\n",
|
2011-05-31 12:33:49 +00:00
|
|
|
first_peer_device(device)->connection->receiver.t_state);
|
2011-07-03 11:26:43 +00:00
|
|
|
|
|
|
|
device->al_writ_cnt =
|
|
|
|
device->bm_writ_cnt =
|
|
|
|
device->read_cnt =
|
|
|
|
device->recv_cnt =
|
|
|
|
device->send_cnt =
|
|
|
|
device->writ_cnt =
|
|
|
|
device->p_size =
|
|
|
|
device->rs_start =
|
|
|
|
device->rs_total =
|
|
|
|
device->rs_failed = 0;
|
|
|
|
device->rs_last_events = 0;
|
|
|
|
device->rs_last_sect_ev = 0;
|
2010-08-11 19:21:50 +00:00
|
|
|
for (i = 0; i < DRBD_SYNC_MARKS; i++) {
|
2011-07-03 11:26:43 +00:00
|
|
|
device->rs_mark_left[i] = 0;
|
|
|
|
device->rs_mark_time[i] = 0;
|
2010-08-11 19:21:50 +00:00
|
|
|
}
|
2011-06-27 14:23:33 +00:00
|
|
|
D_ASSERT(device, first_peer_device(device)->connection->net_conf == NULL);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_set_my_capacity(device, 0);
|
|
|
|
if (device->bitmap) {
|
2009-09-25 23:07:19 +00:00
|
|
|
/* maybe never allocated. */
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_bm_resize(device, 0, 1);
|
|
|
|
drbd_bm_cleanup(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2015-03-26 19:53:55 +00:00
|
|
|
drbd_backing_dev_free(device, device->ldev);
|
2011-07-03 11:26:43 +00:00
|
|
|
device->ldev = NULL;
|
2011-04-22 13:20:23 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
clear_bit(AL_SUSPENDED, &device->flags);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-06-27 14:23:33 +00:00
|
|
|
D_ASSERT(device, list_empty(&device->active_ee));
|
|
|
|
D_ASSERT(device, list_empty(&device->sync_ee));
|
|
|
|
D_ASSERT(device, list_empty(&device->done_ee));
|
|
|
|
D_ASSERT(device, list_empty(&device->read_ee));
|
|
|
|
D_ASSERT(device, list_empty(&device->net_ee));
|
|
|
|
D_ASSERT(device, list_empty(&device->resync_reads));
|
|
|
|
D_ASSERT(device, list_empty(&first_peer_device(device)->connection->sender_work.q));
|
|
|
|
D_ASSERT(device, list_empty(&device->resync_work.list));
|
|
|
|
D_ASSERT(device, list_empty(&device->unplug_work.list));
|
2010-12-16 14:41:26 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_set_defaults(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void drbd_destroy_mempools(void)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
while (drbd_pp_pool) {
|
|
|
|
page = drbd_pp_pool;
|
|
|
|
drbd_pp_pool = (struct page *)page_private(page);
|
|
|
|
__free_page(page);
|
|
|
|
drbd_pp_vacant--;
|
|
|
|
}
|
|
|
|
|
2011-06-27 14:23:33 +00:00
|
|
|
/* D_ASSERT(device, atomic_read(&drbd_pp_vacant)==0); */
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-02-23 16:02:01 +00:00
|
|
|
if (drbd_md_io_bio_set)
|
|
|
|
bioset_free(drbd_md_io_bio_set);
|
2011-02-23 11:39:46 +00:00
|
|
|
if (drbd_md_io_page_pool)
|
|
|
|
mempool_destroy(drbd_md_io_page_pool);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (drbd_ee_mempool)
|
|
|
|
mempool_destroy(drbd_ee_mempool);
|
|
|
|
if (drbd_request_mempool)
|
|
|
|
mempool_destroy(drbd_request_mempool);
|
|
|
|
if (drbd_ee_cache)
|
|
|
|
kmem_cache_destroy(drbd_ee_cache);
|
|
|
|
if (drbd_request_cache)
|
|
|
|
kmem_cache_destroy(drbd_request_cache);
|
|
|
|
if (drbd_bm_ext_cache)
|
|
|
|
kmem_cache_destroy(drbd_bm_ext_cache);
|
|
|
|
if (drbd_al_ext_cache)
|
|
|
|
kmem_cache_destroy(drbd_al_ext_cache);
|
|
|
|
|
2011-02-23 16:02:01 +00:00
|
|
|
drbd_md_io_bio_set = NULL;
|
2011-02-23 11:39:46 +00:00
|
|
|
drbd_md_io_page_pool = NULL;
|
2009-09-25 23:07:19 +00:00
|
|
|
drbd_ee_mempool = NULL;
|
|
|
|
drbd_request_mempool = NULL;
|
|
|
|
drbd_ee_cache = NULL;
|
|
|
|
drbd_request_cache = NULL;
|
|
|
|
drbd_bm_ext_cache = NULL;
|
|
|
|
drbd_al_ext_cache = NULL;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int drbd_create_mempools(void)
|
|
|
|
{
|
|
|
|
struct page *page;
|
2010-11-11 14:19:07 +00:00
|
|
|
const int number = (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count;
|
2009-09-25 23:07:19 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
/* prepare our caches and mempools */
|
|
|
|
drbd_request_mempool = NULL;
|
|
|
|
drbd_ee_cache = NULL;
|
|
|
|
drbd_request_cache = NULL;
|
|
|
|
drbd_bm_ext_cache = NULL;
|
|
|
|
drbd_al_ext_cache = NULL;
|
|
|
|
drbd_pp_pool = NULL;
|
2011-02-23 11:39:46 +00:00
|
|
|
drbd_md_io_page_pool = NULL;
|
2011-02-23 16:02:01 +00:00
|
|
|
drbd_md_io_bio_set = NULL;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
/* caches */
|
|
|
|
drbd_request_cache = kmem_cache_create(
|
|
|
|
"drbd_req", sizeof(struct drbd_request), 0, 0, NULL);
|
|
|
|
if (drbd_request_cache == NULL)
|
|
|
|
goto Enomem;
|
|
|
|
|
|
|
|
drbd_ee_cache = kmem_cache_create(
|
2011-02-04 14:30:34 +00:00
|
|
|
"drbd_ee", sizeof(struct drbd_peer_request), 0, 0, NULL);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (drbd_ee_cache == NULL)
|
|
|
|
goto Enomem;
|
|
|
|
|
|
|
|
drbd_bm_ext_cache = kmem_cache_create(
|
|
|
|
"drbd_bm", sizeof(struct bm_extent), 0, 0, NULL);
|
|
|
|
if (drbd_bm_ext_cache == NULL)
|
|
|
|
goto Enomem;
|
|
|
|
|
|
|
|
drbd_al_ext_cache = kmem_cache_create(
|
|
|
|
"drbd_al", sizeof(struct lc_element), 0, 0, NULL);
|
|
|
|
if (drbd_al_ext_cache == NULL)
|
|
|
|
goto Enomem;
|
|
|
|
|
|
|
|
/* mempools */
|
2011-02-23 16:02:01 +00:00
|
|
|
drbd_md_io_bio_set = bioset_create(DRBD_MIN_POOL_PAGES, 0);
|
|
|
|
if (drbd_md_io_bio_set == NULL)
|
|
|
|
goto Enomem;
|
|
|
|
|
2011-02-23 11:39:46 +00:00
|
|
|
drbd_md_io_page_pool = mempool_create_page_pool(DRBD_MIN_POOL_PAGES, 0);
|
|
|
|
if (drbd_md_io_page_pool == NULL)
|
|
|
|
goto Enomem;
|
|
|
|
|
2015-03-24 23:22:54 +00:00
|
|
|
drbd_request_mempool = mempool_create_slab_pool(number,
|
|
|
|
drbd_request_cache);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (drbd_request_mempool == NULL)
|
|
|
|
goto Enomem;
|
|
|
|
|
2015-03-24 23:22:54 +00:00
|
|
|
drbd_ee_mempool = mempool_create_slab_pool(number, drbd_ee_cache);
|
2010-10-28 12:15:26 +00:00
|
|
|
if (drbd_ee_mempool == NULL)
|
2009-09-25 23:07:19 +00:00
|
|
|
goto Enomem;
|
|
|
|
|
|
|
|
/* drbd's page pool */
|
|
|
|
spin_lock_init(&drbd_pp_lock);
|
|
|
|
|
|
|
|
for (i = 0; i < number; i++) {
|
|
|
|
page = alloc_page(GFP_HIGHUSER);
|
|
|
|
if (!page)
|
|
|
|
goto Enomem;
|
|
|
|
set_page_private(page, (unsigned long)drbd_pp_pool);
|
|
|
|
drbd_pp_pool = page;
|
|
|
|
}
|
|
|
|
drbd_pp_vacant = number;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
Enomem:
|
|
|
|
drbd_destroy_mempools(); /* in case we allocated some */
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
static void drbd_release_all_peer_reqs(struct drbd_device *device)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
int rr;
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
rr = drbd_free_peer_reqs(device, &device->active_ee);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (rr)
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "%d EEs in active list found!\n", rr);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
rr = drbd_free_peer_reqs(device, &device->sync_ee);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (rr)
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "%d EEs in sync list found!\n", rr);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
rr = drbd_free_peer_reqs(device, &device->read_ee);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (rr)
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "%d EEs in read list found!\n", rr);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
rr = drbd_free_peer_reqs(device, &device->done_ee);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (rr)
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "%d EEs in done list found!\n", rr);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
rr = drbd_free_peer_reqs(device, &device->net_ee);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (rr)
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "%d EEs in net list found!\n", rr);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-02-22 07:07:03 +00:00
|
|
|
/* caution. no locking. */
|
2011-06-07 20:54:17 +00:00
|
|
|
void drbd_destroy_device(struct kref *kref)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-07-03 11:26:43 +00:00
|
|
|
struct drbd_device *device = container_of(kref, struct drbd_device, kref);
|
2011-06-08 23:40:48 +00:00
|
|
|
struct drbd_resource *resource = device->resource;
|
2014-05-14 19:34:47 +00:00
|
|
|
struct drbd_peer_device *peer_device, *tmp_peer_device;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
del_timer_sync(&device->request_timer);
|
2011-06-29 12:06:08 +00:00
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
/* paranoia asserts */
|
2011-06-27 14:23:33 +00:00
|
|
|
D_ASSERT(device, device->open_cnt == 0);
|
2009-09-25 23:07:19 +00:00
|
|
|
/* end paranoia asserts */
|
|
|
|
|
|
|
|
/* cleanup stuff that may have been allocated during
|
|
|
|
* device (re-)configuration or state changes */
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (device->this_bdev)
|
|
|
|
bdput(device->this_bdev);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2015-03-26 19:53:55 +00:00
|
|
|
drbd_backing_dev_free(device, device->ldev);
|
2011-07-03 11:26:43 +00:00
|
|
|
device->ldev = NULL;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_release_all_peer_reqs(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
lc_destroy(device->act_log);
|
|
|
|
lc_destroy(device->resync);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
kfree(device->p_uuid);
|
|
|
|
/* device->p_uuid = NULL; */
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (device->bitmap) /* should no longer be there. */
|
|
|
|
drbd_bm_cleanup(device);
|
2014-04-01 21:53:30 +00:00
|
|
|
__free_page(device->md_io.page);
|
2011-07-03 11:26:43 +00:00
|
|
|
put_disk(device->vdisk);
|
|
|
|
blk_cleanup_queue(device->rq_queue);
|
|
|
|
kfree(device->rs_plan_s);
|
2014-05-14 19:34:47 +00:00
|
|
|
|
|
|
|
/* not for_each_connection(connection, resource):
|
|
|
|
* those may have been cleaned up and disassociated already.
|
|
|
|
*/
|
|
|
|
for_each_peer_device_safe(peer_device, tmp_peer_device, device) {
|
|
|
|
kref_put(&peer_device->connection->kref, drbd_destroy_connection);
|
|
|
|
kfree(peer_device);
|
|
|
|
}
|
2014-05-14 19:35:21 +00:00
|
|
|
memset(device, 0xfd, sizeof(*device));
|
2011-07-03 11:26:43 +00:00
|
|
|
kfree(device);
|
2011-06-08 23:40:48 +00:00
|
|
|
kref_put(&resource->kref, drbd_destroy_resource);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
drbd: fix potential deadlock during "restart" of conflicting writes
w_restart_write(), run from worker context, calls __drbd_make_request()
and further drbd_al_begin_io(, delegate=true), which then
potentially deadlocks. The previous patch moved a BUG_ON to expose
such call paths, which would now be triggered.
Also, if we call __drbd_make_request() from resource worker context,
like w_restart_write() did, and that should block for whatever reason
(!drbd_state_is_stable(), resource suspended, ...),
we potentially deadlock the whole resource, as the worker
is needed for state changes and other things.
Create a dedicated retry workqueue for this instead.
Also make sure that inc_ap_bio()/dec_ap_bio() are properly paired,
even if do_retry() needs to retry itself,
in case __drbd_make_request() returns != 0.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-11-24 09:36:25 +00:00
|
|
|
/* One global retry thread, if we need to push back some bio and have it
|
|
|
|
* reinserted through our make request function.
|
|
|
|
*/
|
|
|
|
static struct retry_worker {
|
|
|
|
struct workqueue_struct *wq;
|
|
|
|
struct work_struct worker;
|
|
|
|
|
|
|
|
spinlock_t lock;
|
|
|
|
struct list_head writes;
|
|
|
|
} retry;
|
|
|
|
|
|
|
|
static void do_retry(struct work_struct *ws)
|
|
|
|
{
|
|
|
|
struct retry_worker *retry = container_of(ws, struct retry_worker, worker);
|
|
|
|
LIST_HEAD(writes);
|
|
|
|
struct drbd_request *req, *tmp;
|
|
|
|
|
|
|
|
spin_lock_irq(&retry->lock);
|
|
|
|
list_splice_init(&retry->writes, &writes);
|
|
|
|
spin_unlock_irq(&retry->lock);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(req, tmp, &writes, tl_requests) {
|
2011-07-28 13:27:51 +00:00
|
|
|
struct drbd_device *device = req->device;
|
drbd: fix potential deadlock during "restart" of conflicting writes
w_restart_write(), run from worker context, calls __drbd_make_request()
and further drbd_al_begin_io(, delegate=true), which then
potentially deadlocks. The previous patch moved a BUG_ON to expose
such call paths, which would now be triggered.
Also, if we call __drbd_make_request() from resource worker context,
like w_restart_write() did, and that should block for whatever reason
(!drbd_state_is_stable(), resource suspended, ...),
we potentially deadlock the whole resource, as the worker
is needed for state changes and other things.
Create a dedicated retry workqueue for this instead.
Also make sure that inc_ap_bio()/dec_ap_bio() are properly paired,
even if do_retry() needs to retry itself,
in case __drbd_make_request() returns != 0.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-11-24 09:36:25 +00:00
|
|
|
struct bio *bio = req->master_bio;
|
2013-11-22 11:32:01 +00:00
|
|
|
unsigned long start_jif = req->start_jif;
|
2012-07-24 08:12:36 +00:00
|
|
|
bool expected;
|
|
|
|
|
2011-07-28 13:27:51 +00:00
|
|
|
expected =
|
2012-07-24 08:12:36 +00:00
|
|
|
expect(atomic_read(&req->completion_ref) == 0) &&
|
|
|
|
expect(req->rq_state & RQ_POSTPONED) &&
|
|
|
|
expect((req->rq_state & RQ_LOCAL_PENDING) == 0 ||
|
|
|
|
(req->rq_state & RQ_LOCAL_ABORTED) != 0);
|
|
|
|
|
|
|
|
if (!expected)
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "req=%p completion_ref=%d rq_state=%x\n",
|
2012-07-24 08:12:36 +00:00
|
|
|
req, atomic_read(&req->completion_ref),
|
|
|
|
req->rq_state);
|
|
|
|
|
|
|
|
/* We still need to put one kref associated with the
|
|
|
|
* "completion_ref" going zero in the code path that queued it
|
|
|
|
* here. The request object may still be referenced by a
|
|
|
|
* frozen local req->private_bio, in case we force-detached.
|
drbd: fix potential deadlock during "restart" of conflicting writes
w_restart_write(), run from worker context, calls __drbd_make_request()
and further drbd_al_begin_io(, delegate=true), which then
potentially deadlocks. The previous patch moved a BUG_ON to expose
such call paths, which would now be triggered.
Also, if we call __drbd_make_request() from resource worker context,
like w_restart_write() did, and that should block for whatever reason
(!drbd_state_is_stable(), resource suspended, ...),
we potentially deadlock the whole resource, as the worker
is needed for state changes and other things.
Create a dedicated retry workqueue for this instead.
Also make sure that inc_ap_bio()/dec_ap_bio() are properly paired,
even if do_retry() needs to retry itself,
in case __drbd_make_request() returns != 0.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-11-24 09:36:25 +00:00
|
|
|
*/
|
2012-07-24 08:12:36 +00:00
|
|
|
kref_put(&req->kref, drbd_req_destroy);
|
drbd: fix potential deadlock during "restart" of conflicting writes
w_restart_write(), run from worker context, calls __drbd_make_request()
and further drbd_al_begin_io(, delegate=true), which then
potentially deadlocks. The previous patch moved a BUG_ON to expose
such call paths, which would now be triggered.
Also, if we call __drbd_make_request() from resource worker context,
like w_restart_write() did, and that should block for whatever reason
(!drbd_state_is_stable(), resource suspended, ...),
we potentially deadlock the whole resource, as the worker
is needed for state changes and other things.
Create a dedicated retry workqueue for this instead.
Also make sure that inc_ap_bio()/dec_ap_bio() are properly paired,
even if do_retry() needs to retry itself,
in case __drbd_make_request() returns != 0.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-11-24 09:36:25 +00:00
|
|
|
|
|
|
|
/* A single suspended or otherwise blocking device may stall
|
|
|
|
* all others as well. Fortunately, this code path is to
|
|
|
|
* recover from a situation that "should not happen":
|
|
|
|
* concurrent writes in multi-primary setup.
|
|
|
|
* In a "normal" lifecycle, this workqueue is supposed to be
|
|
|
|
* destroyed without ever doing anything.
|
|
|
|
* If it turns out to be an issue anyways, we can do per
|
|
|
|
* resource (replication group) or per device (minor) retry
|
|
|
|
* workqueues instead.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* We are not just doing generic_make_request(),
|
|
|
|
* as we want to keep the start_time information. */
|
2011-07-03 11:26:43 +00:00
|
|
|
inc_ap_bio(device);
|
2013-11-22 11:32:01 +00:00
|
|
|
__drbd_make_request(device, bio, start_jif);
|
drbd: fix potential deadlock during "restart" of conflicting writes
w_restart_write(), run from worker context, calls __drbd_make_request()
and further drbd_al_begin_io(, delegate=true), which then
potentially deadlocks. The previous patch moved a BUG_ON to expose
such call paths, which would now be triggered.
Also, if we call __drbd_make_request() from resource worker context,
like w_restart_write() did, and that should block for whatever reason
(!drbd_state_is_stable(), resource suspended, ...),
we potentially deadlock the whole resource, as the worker
is needed for state changes and other things.
Create a dedicated retry workqueue for this instead.
Also make sure that inc_ap_bio()/dec_ap_bio() are properly paired,
even if do_retry() needs to retry itself,
in case __drbd_make_request() returns != 0.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-11-24 09:36:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-22 11:52:03 +00:00
|
|
|
/* called via drbd_req_put_completion_ref(),
|
|
|
|
* holds resource->req_lock */
|
2012-07-17 08:05:04 +00:00
|
|
|
void drbd_restart_request(struct drbd_request *req)
|
drbd: fix potential deadlock during "restart" of conflicting writes
w_restart_write(), run from worker context, calls __drbd_make_request()
and further drbd_al_begin_io(, delegate=true), which then
potentially deadlocks. The previous patch moved a BUG_ON to expose
such call paths, which would now be triggered.
Also, if we call __drbd_make_request() from resource worker context,
like w_restart_write() did, and that should block for whatever reason
(!drbd_state_is_stable(), resource suspended, ...),
we potentially deadlock the whole resource, as the worker
is needed for state changes and other things.
Create a dedicated retry workqueue for this instead.
Also make sure that inc_ap_bio()/dec_ap_bio() are properly paired,
even if do_retry() needs to retry itself,
in case __drbd_make_request() returns != 0.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-11-24 09:36:25 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&retry.lock, flags);
|
|
|
|
list_move_tail(&req->tl_requests, &retry.writes);
|
|
|
|
spin_unlock_irqrestore(&retry.lock, flags);
|
|
|
|
|
|
|
|
/* Drop the extra reference that would otherwise
|
|
|
|
* have been dropped by complete_master_bio.
|
|
|
|
* do_retry() needs to grab a new one. */
|
2011-07-28 13:27:51 +00:00
|
|
|
dec_ap_bio(req->device);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
drbd: fix potential deadlock during "restart" of conflicting writes
w_restart_write(), run from worker context, calls __drbd_make_request()
and further drbd_al_begin_io(, delegate=true), which then
potentially deadlocks. The previous patch moved a BUG_ON to expose
such call paths, which would now be triggered.
Also, if we call __drbd_make_request() from resource worker context,
like w_restart_write() did, and that should block for whatever reason
(!drbd_state_is_stable(), resource suspended, ...),
we potentially deadlock the whole resource, as the worker
is needed for state changes and other things.
Create a dedicated retry workqueue for this instead.
Also make sure that inc_ap_bio()/dec_ap_bio() are properly paired,
even if do_retry() needs to retry itself,
in case __drbd_make_request() returns != 0.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-11-24 09:36:25 +00:00
|
|
|
queue_work(retry.wq, &retry.worker);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-06-08 20:17:38 +00:00
|
|
|
void drbd_destroy_resource(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct drbd_resource *resource =
|
|
|
|
container_of(kref, struct drbd_resource, kref);
|
|
|
|
|
2011-06-08 23:40:48 +00:00
|
|
|
idr_destroy(&resource->devices);
|
2011-07-22 12:29:02 +00:00
|
|
|
free_cpumask_var(resource->cpu_mask);
|
2011-06-08 20:17:38 +00:00
|
|
|
kfree(resource->name);
|
2014-05-14 19:35:21 +00:00
|
|
|
memset(resource, 0xf2, sizeof(*resource));
|
2011-06-08 20:17:38 +00:00
|
|
|
kfree(resource);
|
|
|
|
}
|
|
|
|
|
|
|
|
void drbd_free_resource(struct drbd_resource *resource)
|
|
|
|
{
|
|
|
|
struct drbd_connection *connection, *tmp;
|
|
|
|
|
|
|
|
for_each_connection_safe(connection, tmp, resource) {
|
|
|
|
list_del(&connection->connections);
|
2014-05-02 11:19:51 +00:00
|
|
|
drbd_debugfs_connection_cleanup(connection);
|
2011-06-08 20:17:38 +00:00
|
|
|
kref_put(&connection->kref, drbd_destroy_connection);
|
|
|
|
}
|
2014-05-02 11:19:51 +00:00
|
|
|
drbd_debugfs_resource_cleanup(resource);
|
2011-06-08 20:17:38 +00:00
|
|
|
kref_put(&resource->kref, drbd_destroy_resource);
|
|
|
|
}
|
drbd: fix potential deadlock during "restart" of conflicting writes
w_restart_write(), run from worker context, calls __drbd_make_request()
and further drbd_al_begin_io(, delegate=true), which then
potentially deadlocks. The previous patch moved a BUG_ON to expose
such call paths, which would now be triggered.
Also, if we call __drbd_make_request() from resource worker context,
like w_restart_write() did, and that should block for whatever reason
(!drbd_state_is_stable(), resource suspended, ...),
we potentially deadlock the whole resource, as the worker
is needed for state changes and other things.
Create a dedicated retry workqueue for this instead.
Also make sure that inc_ap_bio()/dec_ap_bio() are properly paired,
even if do_retry() needs to retry itself,
in case __drbd_make_request() returns != 0.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-11-24 09:36:25 +00:00
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
static void drbd_cleanup(void)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
2011-07-03 11:26:43 +00:00
|
|
|
struct drbd_device *device;
|
2011-06-08 20:17:38 +00:00
|
|
|
struct drbd_resource *resource, *tmp;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2010-11-24 09:37:35 +00:00
|
|
|
/* first remove proc,
|
|
|
|
* drbdsetup uses it's presence to detect
|
|
|
|
* whether DRBD is loaded.
|
|
|
|
* If we would get stuck in proc removal,
|
|
|
|
* but have netlink already deregistered,
|
|
|
|
* some drbdsetup commands may wait forever
|
|
|
|
* for an answer.
|
|
|
|
*/
|
|
|
|
if (drbd_proc)
|
|
|
|
remove_proc_entry("drbd", NULL);
|
|
|
|
|
drbd: fix potential deadlock during "restart" of conflicting writes
w_restart_write(), run from worker context, calls __drbd_make_request()
and further drbd_al_begin_io(, delegate=true), which then
potentially deadlocks. The previous patch moved a BUG_ON to expose
such call paths, which would now be triggered.
Also, if we call __drbd_make_request() from resource worker context,
like w_restart_write() did, and that should block for whatever reason
(!drbd_state_is_stable(), resource suspended, ...),
we potentially deadlock the whole resource, as the worker
is needed for state changes and other things.
Create a dedicated retry workqueue for this instead.
Also make sure that inc_ap_bio()/dec_ap_bio() are properly paired,
even if do_retry() needs to retry itself,
in case __drbd_make_request() returns != 0.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-11-24 09:36:25 +00:00
|
|
|
if (retry.wq)
|
|
|
|
destroy_workqueue(retry.wq);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-07 11:49:34 +00:00
|
|
|
drbd_genl_unregister();
|
2014-05-02 11:19:51 +00:00
|
|
|
drbd_debugfs_cleanup();
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-06-08 23:40:48 +00:00
|
|
|
idr_for_each_entry(&drbd_devices, device, i)
|
2011-07-03 21:32:26 +00:00
|
|
|
drbd_delete_device(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-05-05 14:13:10 +00:00
|
|
|
/* not _rcu since, no other updater anymore. Genl already unregistered */
|
2011-06-08 20:17:38 +00:00
|
|
|
for_each_resource_safe(resource, tmp, &drbd_resources) {
|
|
|
|
list_del(&resource->resources);
|
|
|
|
drbd_free_resource(resource);
|
2011-05-04 13:10:30 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-02-23 00:53:16 +00:00
|
|
|
drbd_destroy_mempools();
|
2009-09-25 23:07:19 +00:00
|
|
|
unregister_blkdev(DRBD_MAJOR, "drbd");
|
|
|
|
|
2011-06-07 20:54:17 +00:00
|
|
|
idr_destroy(&drbd_devices);
|
2011-02-23 00:53:16 +00:00
|
|
|
|
2014-03-27 13:10:55 +00:00
|
|
|
pr_info("module cleanup done.\n");
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-07-25 15:12:12 +00:00
|
|
|
* drbd_congested() - Callback for the flusher thread
|
2009-09-25 23:07:19 +00:00
|
|
|
* @congested_data: User data
|
2012-07-25 15:12:12 +00:00
|
|
|
* @bdi_bits: Bits the BDI flusher thread is currently interested in
|
2009-09-25 23:07:19 +00:00
|
|
|
*
|
2015-05-22 21:13:26 +00:00
|
|
|
* Returns 1<<WB_async_congested and/or 1<<WB_sync_congested if we are congested.
|
2009-09-25 23:07:19 +00:00
|
|
|
*/
|
|
|
|
static int drbd_congested(void *congested_data, int bdi_bits)
|
|
|
|
{
|
2011-07-03 11:26:43 +00:00
|
|
|
struct drbd_device *device = congested_data;
|
2009-09-25 23:07:19 +00:00
|
|
|
struct request_queue *q;
|
|
|
|
char reason = '-';
|
|
|
|
int r = 0;
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (!may_inc_ap_bio(device)) {
|
2009-09-25 23:07:19 +00:00
|
|
|
/* DRBD has frozen IO */
|
|
|
|
r = bdi_bits;
|
|
|
|
reason = 'd';
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-05-31 12:33:49 +00:00
|
|
|
if (test_bit(CALLBACK_PENDING, &first_peer_device(device)->connection->flags)) {
|
2015-05-22 21:13:26 +00:00
|
|
|
r |= (1 << WB_async_congested);
|
2012-06-14 13:14:06 +00:00
|
|
|
/* Without good local data, we would need to read from remote,
|
|
|
|
* and that would need the worker thread as well, which is
|
|
|
|
* currently blocked waiting for that usermode helper to
|
|
|
|
* finish.
|
|
|
|
*/
|
2011-07-03 11:26:43 +00:00
|
|
|
if (!get_ldev_if_state(device, D_UP_TO_DATE))
|
2015-05-22 21:13:26 +00:00
|
|
|
r |= (1 << WB_sync_congested);
|
2012-06-14 13:14:06 +00:00
|
|
|
else
|
2011-07-03 11:26:43 +00:00
|
|
|
put_ldev(device);
|
2012-06-14 13:14:06 +00:00
|
|
|
r &= bdi_bits;
|
|
|
|
reason = 'c';
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (get_ldev(device)) {
|
|
|
|
q = bdev_get_queue(device->ldev->backing_bdev);
|
2009-09-25 23:07:19 +00:00
|
|
|
r = bdi_congested(&q->backing_dev_info, bdi_bits);
|
2011-07-03 11:26:43 +00:00
|
|
|
put_ldev(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (r)
|
|
|
|
reason = 'b';
|
|
|
|
}
|
|
|
|
|
2015-05-22 21:13:26 +00:00
|
|
|
if (bdi_bits & (1 << WB_async_congested) &&
|
2011-05-31 12:33:49 +00:00
|
|
|
test_bit(NET_CONGESTED, &first_peer_device(device)->connection->flags)) {
|
2015-05-22 21:13:26 +00:00
|
|
|
r |= (1 << WB_async_congested);
|
2009-09-25 23:07:19 +00:00
|
|
|
reason = reason == 'b' ? 'a' : 'n';
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2011-07-03 11:26:43 +00:00
|
|
|
device->congestion_reason = reason;
|
2009-09-25 23:07:19 +00:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2011-02-09 10:10:24 +00:00
|
|
|
static void drbd_init_workqueue(struct drbd_work_queue* wq)
|
|
|
|
{
|
|
|
|
spin_lock_init(&wq->q_lock);
|
|
|
|
INIT_LIST_HEAD(&wq->q);
|
2011-10-19 09:50:57 +00:00
|
|
|
init_waitqueue_head(&wq->q_wait);
|
2011-02-09 10:10:24 +00:00
|
|
|
}
|
|
|
|
|
2011-07-28 13:56:02 +00:00
|
|
|
struct completion_work {
|
|
|
|
struct drbd_work w;
|
|
|
|
struct completion done;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int w_complete(struct drbd_work *w, int cancel)
|
|
|
|
{
|
|
|
|
struct completion_work *completion_work =
|
|
|
|
container_of(w, struct completion_work, w);
|
|
|
|
|
|
|
|
complete(&completion_work->done);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void drbd_flush_workqueue(struct drbd_work_queue *work_queue)
|
|
|
|
{
|
|
|
|
struct completion_work completion_work;
|
|
|
|
|
|
|
|
completion_work.w.cb = w_complete;
|
|
|
|
init_completion(&completion_work.done);
|
|
|
|
drbd_queue_work(work_queue, &completion_work.w);
|
|
|
|
wait_for_completion(&completion_work.done);
|
|
|
|
}
|
|
|
|
|
2011-06-13 12:27:45 +00:00
|
|
|
struct drbd_resource *drbd_find_resource(const char *name)
|
2011-02-21 14:38:08 +00:00
|
|
|
{
|
2011-06-08 20:17:38 +00:00
|
|
|
struct drbd_resource *resource;
|
2011-02-21 14:38:08 +00:00
|
|
|
|
2011-03-07 11:49:34 +00:00
|
|
|
if (!name || !name[0])
|
|
|
|
return NULL;
|
|
|
|
|
2011-05-05 14:13:10 +00:00
|
|
|
rcu_read_lock();
|
2011-06-08 20:17:38 +00:00
|
|
|
for_each_resource_rcu(resource, &drbd_resources) {
|
|
|
|
if (!strcmp(resource->name, name)) {
|
2011-06-13 12:27:45 +00:00
|
|
|
kref_get(&resource->kref);
|
2011-02-21 14:38:08 +00:00
|
|
|
goto found;
|
2011-04-24 08:53:19 +00:00
|
|
|
}
|
2011-02-21 14:38:08 +00:00
|
|
|
}
|
2011-06-13 12:27:45 +00:00
|
|
|
resource = NULL;
|
2011-02-21 14:38:08 +00:00
|
|
|
found:
|
2011-05-05 14:13:10 +00:00
|
|
|
rcu_read_unlock();
|
2011-06-13 12:27:45 +00:00
|
|
|
return resource;
|
2011-02-21 14:38:08 +00:00
|
|
|
}
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
struct drbd_connection *conn_get_by_addrs(void *my_addr, int my_addr_len,
|
2011-06-14 16:28:09 +00:00
|
|
|
void *peer_addr, int peer_addr_len)
|
|
|
|
{
|
2011-06-08 20:17:38 +00:00
|
|
|
struct drbd_resource *resource;
|
2011-05-30 14:32:41 +00:00
|
|
|
struct drbd_connection *connection;
|
2011-06-14 16:28:09 +00:00
|
|
|
|
|
|
|
rcu_read_lock();
|
2011-06-08 20:17:38 +00:00
|
|
|
for_each_resource_rcu(resource, &drbd_resources) {
|
|
|
|
for_each_connection_rcu(connection, resource) {
|
|
|
|
if (connection->my_addr_len == my_addr_len &&
|
|
|
|
connection->peer_addr_len == peer_addr_len &&
|
|
|
|
!memcmp(&connection->my_addr, my_addr, my_addr_len) &&
|
|
|
|
!memcmp(&connection->peer_addr, peer_addr, peer_addr_len)) {
|
|
|
|
kref_get(&connection->kref);
|
|
|
|
goto found;
|
|
|
|
}
|
2011-06-14 16:28:09 +00:00
|
|
|
}
|
|
|
|
}
|
2011-05-30 14:32:41 +00:00
|
|
|
connection = NULL;
|
2011-06-14 16:28:09 +00:00
|
|
|
found:
|
|
|
|
rcu_read_unlock();
|
2011-05-30 14:32:41 +00:00
|
|
|
return connection;
|
2011-06-14 16:28:09 +00:00
|
|
|
}
|
|
|
|
|
2011-03-24 17:07:54 +00:00
|
|
|
static int drbd_alloc_socket(struct drbd_socket *socket)
|
|
|
|
{
|
|
|
|
socket->rbuf = (void *) __get_free_page(GFP_KERNEL);
|
|
|
|
if (!socket->rbuf)
|
|
|
|
return -ENOMEM;
|
2011-03-24 20:17:52 +00:00
|
|
|
socket->sbuf = (void *) __get_free_page(GFP_KERNEL);
|
|
|
|
if (!socket->sbuf)
|
|
|
|
return -ENOMEM;
|
2011-03-24 17:07:54 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void drbd_free_socket(struct drbd_socket *socket)
|
|
|
|
{
|
2011-03-24 20:17:52 +00:00
|
|
|
free_page((unsigned long) socket->sbuf);
|
2011-03-24 17:07:54 +00:00
|
|
|
free_page((unsigned long) socket->rbuf);
|
|
|
|
}
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
void conn_free_crypto(struct drbd_connection *connection)
|
2011-04-20 15:47:29 +00:00
|
|
|
{
|
2011-05-30 14:32:41 +00:00
|
|
|
drbd_free_sock(connection);
|
2011-04-22 13:20:23 +00:00
|
|
|
|
2016-01-24 13:19:21 +00:00
|
|
|
crypto_free_ahash(connection->csums_tfm);
|
|
|
|
crypto_free_ahash(connection->verify_tfm);
|
|
|
|
crypto_free_shash(connection->cram_hmac_tfm);
|
|
|
|
crypto_free_ahash(connection->integrity_tfm);
|
|
|
|
crypto_free_ahash(connection->peer_integrity_tfm);
|
2011-05-30 14:32:41 +00:00
|
|
|
kfree(connection->int_dig_in);
|
|
|
|
kfree(connection->int_dig_vv);
|
2011-04-22 13:20:23 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
connection->csums_tfm = NULL;
|
|
|
|
connection->verify_tfm = NULL;
|
|
|
|
connection->cram_hmac_tfm = NULL;
|
|
|
|
connection->integrity_tfm = NULL;
|
|
|
|
connection->peer_integrity_tfm = NULL;
|
|
|
|
connection->int_dig_in = NULL;
|
|
|
|
connection->int_dig_vv = NULL;
|
2011-04-20 15:47:29 +00:00
|
|
|
}
|
|
|
|
|
2011-06-21 14:11:28 +00:00
|
|
|
int set_resource_options(struct drbd_resource *resource, struct res_opts *res_opts)
|
2011-06-16 15:58:02 +00:00
|
|
|
{
|
2011-06-21 14:11:28 +00:00
|
|
|
struct drbd_connection *connection;
|
2011-06-16 15:58:02 +00:00
|
|
|
cpumask_var_t new_cpu_mask;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!zalloc_cpumask_var(&new_cpu_mask, GFP_KERNEL))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* silently ignore cpu mask on UP kernel */
|
|
|
|
if (nr_cpu_ids > 1 && res_opts->cpu_mask[0] != 0) {
|
2011-07-22 11:53:19 +00:00
|
|
|
err = bitmap_parse(res_opts->cpu_mask, DRBD_CPU_MASK_SIZE,
|
2012-04-30 10:53:52 +00:00
|
|
|
cpumask_bits(new_cpu_mask), nr_cpu_ids);
|
2014-05-19 07:52:02 +00:00
|
|
|
if (err == -EOVERFLOW) {
|
|
|
|
/* So what. mask it out. */
|
|
|
|
cpumask_var_t tmp_cpu_mask;
|
|
|
|
if (zalloc_cpumask_var(&tmp_cpu_mask, GFP_KERNEL)) {
|
|
|
|
cpumask_setall(tmp_cpu_mask);
|
|
|
|
cpumask_and(new_cpu_mask, new_cpu_mask, tmp_cpu_mask);
|
|
|
|
drbd_warn(resource, "Overflow in bitmap_parse(%.12s%s), truncating to %u bits\n",
|
|
|
|
res_opts->cpu_mask,
|
|
|
|
strlen(res_opts->cpu_mask) > 12 ? "..." : "",
|
|
|
|
nr_cpu_ids);
|
|
|
|
free_cpumask_var(tmp_cpu_mask);
|
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
}
|
2011-06-16 15:58:02 +00:00
|
|
|
if (err) {
|
2011-07-06 09:01:44 +00:00
|
|
|
drbd_warn(resource, "bitmap_parse() failed with %d\n", err);
|
2011-06-16 15:58:02 +00:00
|
|
|
/* retcode = ERR_CPU_MASK_PARSE; */
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
2011-06-21 14:11:28 +00:00
|
|
|
resource->res_opts = *res_opts;
|
2011-07-22 12:29:02 +00:00
|
|
|
if (cpumask_empty(new_cpu_mask))
|
|
|
|
drbd_calc_cpu_mask(&new_cpu_mask);
|
|
|
|
if (!cpumask_equal(resource->cpu_mask, new_cpu_mask)) {
|
|
|
|
cpumask_copy(resource->cpu_mask, new_cpu_mask);
|
|
|
|
for_each_connection_rcu(connection, resource) {
|
2011-06-21 14:11:28 +00:00
|
|
|
connection->receiver.reset_cpu_mask = 1;
|
2015-03-16 14:01:00 +00:00
|
|
|
connection->ack_receiver.reset_cpu_mask = 1;
|
2011-06-21 14:11:28 +00:00
|
|
|
connection->worker.reset_cpu_mask = 1;
|
|
|
|
}
|
2011-06-16 15:58:02 +00:00
|
|
|
}
|
|
|
|
err = 0;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
free_cpumask_var(new_cpu_mask);
|
|
|
|
return err;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2011-06-08 20:17:38 +00:00
|
|
|
struct drbd_resource *drbd_create_resource(const char *name)
|
|
|
|
{
|
|
|
|
struct drbd_resource *resource;
|
|
|
|
|
2011-07-07 23:19:44 +00:00
|
|
|
resource = kzalloc(sizeof(struct drbd_resource), GFP_KERNEL);
|
2011-06-08 20:17:38 +00:00
|
|
|
if (!resource)
|
2011-07-22 12:29:02 +00:00
|
|
|
goto fail;
|
2011-06-08 20:17:38 +00:00
|
|
|
resource->name = kstrdup(name, GFP_KERNEL);
|
2011-07-22 12:29:02 +00:00
|
|
|
if (!resource->name)
|
|
|
|
goto fail_free_resource;
|
|
|
|
if (!zalloc_cpumask_var(&resource->cpu_mask, GFP_KERNEL))
|
|
|
|
goto fail_free_name;
|
2011-06-08 20:17:38 +00:00
|
|
|
kref_init(&resource->kref);
|
2011-06-08 23:40:48 +00:00
|
|
|
idr_init(&resource->devices);
|
2011-06-08 20:17:38 +00:00
|
|
|
INIT_LIST_HEAD(&resource->connections);
|
2014-08-13 16:33:55 +00:00
|
|
|
resource->write_ordering = WO_BDEV_FLUSH;
|
2011-06-08 20:17:38 +00:00
|
|
|
list_add_tail_rcu(&resource->resources, &drbd_resources);
|
2011-07-07 12:19:42 +00:00
|
|
|
mutex_init(&resource->conf_update);
|
2014-04-28 16:43:22 +00:00
|
|
|
mutex_init(&resource->adm_mutex);
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_lock_init(&resource->req_lock);
|
2014-05-02 11:19:51 +00:00
|
|
|
drbd_debugfs_resource_add(resource);
|
2011-06-08 20:17:38 +00:00
|
|
|
return resource;
|
2011-07-22 12:29:02 +00:00
|
|
|
|
|
|
|
fail_free_name:
|
|
|
|
kfree(resource->name);
|
|
|
|
fail_free_resource:
|
|
|
|
kfree(resource);
|
|
|
|
fail:
|
|
|
|
return NULL;
|
2011-06-08 20:17:38 +00:00
|
|
|
}
|
|
|
|
|
2014-05-02 11:19:51 +00:00
|
|
|
/* caller must be under adm_mutex */
|
2011-05-30 14:32:41 +00:00
|
|
|
struct drbd_connection *conn_create(const char *name, struct res_opts *res_opts)
|
2011-01-19 11:26:59 +00:00
|
|
|
{
|
2011-06-08 20:17:38 +00:00
|
|
|
struct drbd_resource *resource;
|
2011-05-30 14:32:41 +00:00
|
|
|
struct drbd_connection *connection;
|
2011-01-19 11:26:59 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
connection = kzalloc(sizeof(struct drbd_connection), GFP_KERNEL);
|
|
|
|
if (!connection)
|
2011-01-19 11:26:59 +00:00
|
|
|
return NULL;
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
if (drbd_alloc_socket(&connection->data))
|
2011-03-24 17:07:54 +00:00
|
|
|
goto fail;
|
2011-05-30 14:32:41 +00:00
|
|
|
if (drbd_alloc_socket(&connection->meta))
|
2011-03-24 17:07:54 +00:00
|
|
|
goto fail;
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
connection->current_epoch = kzalloc(sizeof(struct drbd_epoch), GFP_KERNEL);
|
|
|
|
if (!connection->current_epoch)
|
2011-11-09 18:18:00 +00:00
|
|
|
goto fail;
|
2011-11-28 14:04:49 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
INIT_LIST_HEAD(&connection->transfer_log);
|
2011-11-28 14:04:49 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
INIT_LIST_HEAD(&connection->current_epoch->list);
|
|
|
|
connection->epochs = 1;
|
|
|
|
spin_lock_init(&connection->epoch_lock);
|
2011-11-09 19:12:34 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
connection->send.seen_any_write_yet = false;
|
|
|
|
connection->send.current_epoch_nr = 0;
|
|
|
|
connection->send.current_epoch_writes = 0;
|
2011-11-28 14:04:49 +00:00
|
|
|
|
2011-06-08 20:17:38 +00:00
|
|
|
resource = drbd_create_resource(name);
|
|
|
|
if (!resource)
|
|
|
|
goto fail;
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
connection->cstate = C_STANDALONE;
|
|
|
|
mutex_init(&connection->cstate_mutex);
|
|
|
|
init_waitqueue_head(&connection->ping_wait);
|
2011-06-21 15:23:59 +00:00
|
|
|
idr_init(&connection->peer_devices);
|
2011-01-19 12:48:44 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
drbd_init_workqueue(&connection->sender_work);
|
|
|
|
mutex_init(&connection->data.mutex);
|
|
|
|
mutex_init(&connection->meta.mutex);
|
2011-02-09 10:10:24 +00:00
|
|
|
|
2011-07-21 11:45:21 +00:00
|
|
|
drbd_thread_init(resource, &connection->receiver, drbd_receiver, "receiver");
|
|
|
|
connection->receiver.connection = connection;
|
|
|
|
drbd_thread_init(resource, &connection->worker, drbd_worker, "worker");
|
|
|
|
connection->worker.connection = connection;
|
2015-03-16 14:01:00 +00:00
|
|
|
drbd_thread_init(resource, &connection->ack_receiver, drbd_ack_receiver, "ack_recv");
|
|
|
|
connection->ack_receiver.connection = connection;
|
2011-02-09 09:33:31 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
kref_init(&connection->kref);
|
2011-06-08 20:17:38 +00:00
|
|
|
|
|
|
|
connection->resource = resource;
|
2011-01-19 11:26:59 +00:00
|
|
|
|
2011-06-21 14:11:28 +00:00
|
|
|
if (set_resource_options(resource, res_opts))
|
|
|
|
goto fail_resource;
|
|
|
|
|
|
|
|
kref_get(&resource->kref);
|
|
|
|
list_add_tail_rcu(&connection->connections, &resource->connections);
|
2014-05-02 11:19:51 +00:00
|
|
|
drbd_debugfs_connection_add(connection);
|
2011-05-30 14:32:41 +00:00
|
|
|
return connection;
|
2011-01-19 11:26:59 +00:00
|
|
|
|
2011-06-21 14:11:28 +00:00
|
|
|
fail_resource:
|
|
|
|
list_del(&resource->resources);
|
|
|
|
drbd_free_resource(resource);
|
2011-01-19 11:26:59 +00:00
|
|
|
fail:
|
2011-05-30 14:32:41 +00:00
|
|
|
kfree(connection->current_epoch);
|
|
|
|
drbd_free_socket(&connection->meta);
|
|
|
|
drbd_free_socket(&connection->data);
|
|
|
|
kfree(connection);
|
2011-01-19 11:26:59 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-06-07 20:54:17 +00:00
|
|
|
void drbd_destroy_connection(struct kref *kref)
|
2011-01-19 11:26:59 +00:00
|
|
|
{
|
2011-05-30 14:32:41 +00:00
|
|
|
struct drbd_connection *connection = container_of(kref, struct drbd_connection, kref);
|
2011-06-08 20:17:38 +00:00
|
|
|
struct drbd_resource *resource = connection->resource;
|
2011-04-22 13:23:32 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
if (atomic_read(&connection->current_epoch->epoch_size) != 0)
|
2011-07-06 09:01:44 +00:00
|
|
|
drbd_err(connection, "epoch_size:%d\n", atomic_read(&connection->current_epoch->epoch_size));
|
2011-05-30 14:32:41 +00:00
|
|
|
kfree(connection->current_epoch);
|
2011-11-09 18:18:00 +00:00
|
|
|
|
2011-06-21 15:23:59 +00:00
|
|
|
idr_destroy(&connection->peer_devices);
|
2011-01-19 11:26:59 +00:00
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
drbd_free_socket(&connection->meta);
|
|
|
|
drbd_free_socket(&connection->data);
|
|
|
|
kfree(connection->int_dig_in);
|
|
|
|
kfree(connection->int_dig_vv);
|
2014-05-14 19:35:21 +00:00
|
|
|
memset(connection, 0xfc, sizeof(*connection));
|
2011-05-30 14:32:41 +00:00
|
|
|
kfree(connection);
|
2011-06-08 20:17:38 +00:00
|
|
|
kref_put(&resource->kref, drbd_destroy_resource);
|
2011-01-19 11:26:59 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
static int init_submitter(struct drbd_device *device)
|
2013-03-23 00:14:40 +00:00
|
|
|
{
|
|
|
|
/* opencoded create_singlethread_workqueue(),
|
|
|
|
* to be able to say "drbd%d", ..., minor */
|
2015-03-24 09:40:26 +00:00
|
|
|
device->submit.wq =
|
|
|
|
alloc_ordered_workqueue("drbd%u_submit", WQ_MEM_RECLAIM, device->minor);
|
2011-07-03 11:26:43 +00:00
|
|
|
if (!device->submit.wq)
|
2013-03-23 00:14:40 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
INIT_WORK(&device->submit.worker, do_submit);
|
|
|
|
INIT_LIST_HEAD(&device->submit.writes);
|
2013-03-23 00:14:40 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-04-28 16:43:21 +00:00
|
|
|
enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsigned int minor)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2014-04-28 16:43:21 +00:00
|
|
|
struct drbd_resource *resource = adm_ctx->resource;
|
2011-07-06 13:03:31 +00:00
|
|
|
struct drbd_connection *connection;
|
2011-07-03 11:26:43 +00:00
|
|
|
struct drbd_device *device;
|
2011-07-06 13:03:31 +00:00
|
|
|
struct drbd_peer_device *peer_device, *tmp_peer_device;
|
2009-09-25 23:07:19 +00:00
|
|
|
struct gendisk *disk;
|
|
|
|
struct request_queue *q;
|
2013-05-23 12:57:17 +00:00
|
|
|
int id;
|
2014-04-28 16:43:21 +00:00
|
|
|
int vnr = adm_ctx->volume;
|
2011-03-08 15:11:16 +00:00
|
|
|
enum drbd_ret_code err = ERR_NOMEM;
|
2011-02-22 07:07:03 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
device = minor_to_device(minor);
|
|
|
|
if (device)
|
2014-11-10 16:21:09 +00:00
|
|
|
return ERR_MINOR_OR_VOLUME_EXISTS;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
/* GFP_KERNEL, we are outside of all write-out paths */
|
2011-07-03 11:26:43 +00:00
|
|
|
device = kzalloc(sizeof(struct drbd_device), GFP_KERNEL);
|
|
|
|
if (!device)
|
2011-02-22 07:07:03 +00:00
|
|
|
return ERR_NOMEM;
|
2011-06-08 23:40:48 +00:00
|
|
|
kref_init(&device->kref);
|
|
|
|
|
|
|
|
kref_get(&resource->kref);
|
|
|
|
device->resource = resource;
|
2011-07-03 11:26:43 +00:00
|
|
|
device->minor = minor;
|
|
|
|
device->vnr = vnr;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_init_set_defaults(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
q = blk_alloc_queue(GFP_KERNEL);
|
|
|
|
if (!q)
|
|
|
|
goto out_no_q;
|
2011-07-03 11:26:43 +00:00
|
|
|
device->rq_queue = q;
|
|
|
|
q->queuedata = device;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
disk = alloc_disk(1);
|
|
|
|
if (!disk)
|
|
|
|
goto out_no_disk;
|
2011-07-03 11:26:43 +00:00
|
|
|
device->vdisk = disk;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2010-12-09 14:03:57 +00:00
|
|
|
set_disk_ro(disk, true);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
disk->queue = q;
|
|
|
|
disk->major = DRBD_MAJOR;
|
|
|
|
disk->first_minor = minor;
|
|
|
|
disk->fops = &drbd_ops;
|
|
|
|
sprintf(disk->disk_name, "drbd%d", minor);
|
2011-07-03 11:26:43 +00:00
|
|
|
disk->private_data = device;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
device->this_bdev = bdget(MKDEV(DRBD_MAJOR, minor));
|
2009-09-25 23:07:19 +00:00
|
|
|
/* we have no partitions. we contain only ourselves. */
|
2011-07-03 11:26:43 +00:00
|
|
|
device->this_bdev->bd_contains = device->this_bdev;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
q->backing_dev_info.congested_fn = drbd_congested;
|
2011-07-03 11:26:43 +00:00
|
|
|
q->backing_dev_info.congested_data = device;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2010-12-13 16:48:19 +00:00
|
|
|
blk_queue_make_request(q, drbd_make_request);
|
2016-03-30 16:09:01 +00:00
|
|
|
blk_queue_write_cache(q, true, true);
|
2011-05-20 14:39:13 +00:00
|
|
|
/* Setting the max_hw_sectors to an odd value of 8kibyte here
|
|
|
|
This triggers a max_bio_size message upon first attach or connect */
|
|
|
|
blk_queue_max_hw_sectors(q, DRBD_MAX_BIO_SIZE_SAFE >> 8);
|
2009-09-25 23:07:19 +00:00
|
|
|
blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
|
2011-07-07 12:19:42 +00:00
|
|
|
q->queue_lock = &resource->req_lock;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2014-04-01 21:53:30 +00:00
|
|
|
device->md_io.page = alloc_page(GFP_KERNEL);
|
|
|
|
if (!device->md_io.page)
|
2009-09-25 23:07:19 +00:00
|
|
|
goto out_no_io_page;
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (drbd_bm_init(device))
|
2009-09-25 23:07:19 +00:00
|
|
|
goto out_no_bitmap;
|
2011-07-03 11:26:43 +00:00
|
|
|
device->read_requests = RB_ROOT;
|
|
|
|
device->write_requests = RB_ROOT;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2013-05-23 12:57:17 +00:00
|
|
|
id = idr_alloc(&drbd_devices, device, minor, minor + 1, GFP_KERNEL);
|
|
|
|
if (id < 0) {
|
2014-11-10 16:21:10 +00:00
|
|
|
if (id == -ENOSPC)
|
2014-11-10 16:21:09 +00:00
|
|
|
err = ERR_MINOR_OR_VOLUME_EXISTS;
|
2011-03-08 15:11:16 +00:00
|
|
|
goto out_no_minor_idr;
|
2011-02-23 00:53:16 +00:00
|
|
|
}
|
2011-06-08 23:40:48 +00:00
|
|
|
kref_get(&device->kref);
|
|
|
|
|
|
|
|
id = idr_alloc(&resource->devices, device, vnr, vnr + 1, GFP_KERNEL);
|
|
|
|
if (id < 0) {
|
2014-11-10 16:21:10 +00:00
|
|
|
if (id == -ENOSPC)
|
2014-11-10 16:21:09 +00:00
|
|
|
err = ERR_MINOR_OR_VOLUME_EXISTS;
|
2011-06-08 23:40:48 +00:00
|
|
|
goto out_idr_remove_minor;
|
|
|
|
}
|
|
|
|
kref_get(&device->kref);
|
2011-03-08 15:11:16 +00:00
|
|
|
|
2011-07-06 13:03:31 +00:00
|
|
|
INIT_LIST_HEAD(&device->peer_devices);
|
2014-05-05 22:44:59 +00:00
|
|
|
INIT_LIST_HEAD(&device->pending_bitmap_io);
|
2011-07-06 13:03:31 +00:00
|
|
|
for_each_connection(connection, resource) {
|
|
|
|
peer_device = kzalloc(sizeof(struct drbd_peer_device), GFP_KERNEL);
|
|
|
|
if (!peer_device)
|
|
|
|
goto out_idr_remove_from_resource;
|
|
|
|
peer_device->connection = connection;
|
|
|
|
peer_device->device = device;
|
|
|
|
|
|
|
|
list_add(&peer_device->peer_devices, &device->peer_devices);
|
|
|
|
kref_get(&device->kref);
|
|
|
|
|
|
|
|
id = idr_alloc(&connection->peer_devices, peer_device, vnr, vnr + 1, GFP_KERNEL);
|
|
|
|
if (id < 0) {
|
2014-11-10 16:21:10 +00:00
|
|
|
if (id == -ENOSPC)
|
2011-07-06 13:03:31 +00:00
|
|
|
err = ERR_INVALID_REQUEST;
|
|
|
|
goto out_idr_remove_from_resource;
|
2013-02-28 01:04:01 +00:00
|
|
|
}
|
2011-07-06 13:03:31 +00:00
|
|
|
kref_get(&connection->kref);
|
2015-03-16 15:08:29 +00:00
|
|
|
INIT_WORK(&peer_device->send_acks_work, drbd_send_acks_wf);
|
2011-03-08 15:11:16 +00:00
|
|
|
}
|
2013-02-28 01:04:01 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (init_submitter(device)) {
|
2013-03-23 00:14:40 +00:00
|
|
|
err = ERR_NOMEM;
|
|
|
|
goto out_idr_remove_vol;
|
|
|
|
}
|
|
|
|
|
2011-02-22 07:07:03 +00:00
|
|
|
add_disk(disk);
|
|
|
|
|
2011-03-15 15:56:18 +00:00
|
|
|
/* inherit the connection state */
|
2011-07-06 13:03:31 +00:00
|
|
|
device->state.conn = first_connection(resource)->cstate;
|
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-08 22:47:13 +00:00
|
|
|
if (device->state.conn == C_WF_REPORT_PARAMS) {
|
|
|
|
for_each_peer_device(peer_device, device)
|
|
|
|
drbd_connected(peer_device);
|
|
|
|
}
|
2014-05-02 11:19:51 +00:00
|
|
|
/* move to create_peer_device() */
|
|
|
|
for_each_peer_device(peer_device, device)
|
|
|
|
drbd_debugfs_peer_device_add(peer_device);
|
|
|
|
drbd_debugfs_device_add(device);
|
2011-02-22 07:07:03 +00:00
|
|
|
return NO_ERROR;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2013-03-23 00:14:40 +00:00
|
|
|
out_idr_remove_vol:
|
2011-06-21 15:23:59 +00:00
|
|
|
idr_remove(&connection->peer_devices, vnr);
|
2011-06-08 23:40:48 +00:00
|
|
|
out_idr_remove_from_resource:
|
2011-07-06 13:03:31 +00:00
|
|
|
for_each_connection(connection, resource) {
|
|
|
|
peer_device = idr_find(&connection->peer_devices, vnr);
|
|
|
|
if (peer_device) {
|
|
|
|
idr_remove(&connection->peer_devices, vnr);
|
|
|
|
kref_put(&connection->kref, drbd_destroy_connection);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for_each_peer_device_safe(peer_device, tmp_peer_device, device) {
|
|
|
|
list_del(&peer_device->peer_devices);
|
|
|
|
kfree(peer_device);
|
|
|
|
}
|
2011-06-08 23:40:48 +00:00
|
|
|
idr_remove(&resource->devices, vnr);
|
2011-03-08 15:11:16 +00:00
|
|
|
out_idr_remove_minor:
|
2013-05-23 12:57:17 +00:00
|
|
|
idr_remove(&drbd_devices, minor);
|
2011-03-07 08:49:02 +00:00
|
|
|
synchronize_rcu();
|
2011-03-08 15:11:16 +00:00
|
|
|
out_no_minor_idr:
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_bm_cleanup(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
out_no_bitmap:
|
2014-04-01 21:53:30 +00:00
|
|
|
__free_page(device->md_io.page);
|
2009-09-25 23:07:19 +00:00
|
|
|
out_no_io_page:
|
|
|
|
put_disk(disk);
|
|
|
|
out_no_disk:
|
|
|
|
blk_cleanup_queue(q);
|
|
|
|
out_no_q:
|
2011-06-08 23:40:48 +00:00
|
|
|
kref_put(&resource->kref, drbd_destroy_resource);
|
2011-05-31 12:33:49 +00:00
|
|
|
kfree(device);
|
2011-03-08 15:11:16 +00:00
|
|
|
return err;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 21:32:26 +00:00
|
|
|
void drbd_delete_device(struct drbd_device *device)
|
2011-06-08 23:40:48 +00:00
|
|
|
{
|
|
|
|
struct drbd_resource *resource = device->resource;
|
|
|
|
struct drbd_connection *connection;
|
2014-05-02 11:19:51 +00:00
|
|
|
struct drbd_peer_device *peer_device;
|
2011-06-08 23:40:48 +00:00
|
|
|
int refs = 3;
|
|
|
|
|
2014-05-02 11:19:51 +00:00
|
|
|
/* move to free_peer_device() */
|
|
|
|
for_each_peer_device(peer_device, device)
|
|
|
|
drbd_debugfs_peer_device_cleanup(peer_device);
|
|
|
|
drbd_debugfs_device_cleanup(device);
|
2011-06-08 23:40:48 +00:00
|
|
|
for_each_connection(connection, resource) {
|
2011-06-21 15:23:59 +00:00
|
|
|
idr_remove(&connection->peer_devices, device->vnr);
|
2011-06-08 23:40:48 +00:00
|
|
|
refs++;
|
|
|
|
}
|
|
|
|
idr_remove(&resource->devices, device->vnr);
|
|
|
|
idr_remove(&drbd_devices, device_to_minor(device));
|
|
|
|
del_gendisk(device->vdisk);
|
|
|
|
synchronize_rcu();
|
|
|
|
kref_sub(&device->kref, refs, drbd_destroy_device);
|
|
|
|
}
|
|
|
|
|
2014-02-27 08:46:18 +00:00
|
|
|
static int __init drbd_init(void)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2011-01-10 10:15:17 +00:00
|
|
|
if (minor_count < DRBD_MINOR_COUNT_MIN || minor_count > DRBD_MINOR_COUNT_MAX) {
|
2014-03-27 13:10:55 +00:00
|
|
|
pr_err("invalid minor_count (%d)\n", minor_count);
|
2009-09-25 23:07:19 +00:00
|
|
|
#ifdef MODULE
|
|
|
|
return -EINVAL;
|
|
|
|
#else
|
2011-05-31 11:08:53 +00:00
|
|
|
minor_count = DRBD_MINOR_COUNT_DEF;
|
2009-09-25 23:07:19 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
err = register_blkdev(DRBD_MAJOR, "drbd");
|
|
|
|
if (err) {
|
2014-03-27 13:10:55 +00:00
|
|
|
pr_err("unable to register block device major %d\n",
|
2009-09-25 23:07:19 +00:00
|
|
|
DRBD_MAJOR);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* allocate all necessary structs
|
|
|
|
*/
|
|
|
|
init_waitqueue_head(&drbd_pp_wait);
|
|
|
|
|
|
|
|
drbd_proc = NULL; /* play safe for drbd_cleanup */
|
2011-06-07 20:54:17 +00:00
|
|
|
idr_init(&drbd_devices);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2014-08-14 16:33:30 +00:00
|
|
|
mutex_init(&resources_mutex);
|
2011-06-08 20:17:38 +00:00
|
|
|
INIT_LIST_HEAD(&drbd_resources);
|
2013-10-23 08:59:15 +00:00
|
|
|
|
|
|
|
err = drbd_genl_register();
|
|
|
|
if (err) {
|
2014-03-27 13:10:55 +00:00
|
|
|
pr_err("unable to register generic netlink family\n");
|
2013-10-23 08:59:15 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
err = drbd_create_mempools();
|
|
|
|
if (err)
|
2011-03-07 11:49:34 +00:00
|
|
|
goto fail;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2013-06-25 14:50:04 +00:00
|
|
|
err = -ENOMEM;
|
2010-03-11 15:47:58 +00:00
|
|
|
drbd_proc = proc_create_data("drbd", S_IFREG | S_IRUGO , NULL, &drbd_proc_fops, NULL);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (!drbd_proc) {
|
2014-03-27 13:10:55 +00:00
|
|
|
pr_err("unable to register proc file\n");
|
2011-03-07 11:49:34 +00:00
|
|
|
goto fail;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
drbd: fix potential deadlock during "restart" of conflicting writes
w_restart_write(), run from worker context, calls __drbd_make_request()
and further drbd_al_begin_io(, delegate=true), which then
potentially deadlocks. The previous patch moved a BUG_ON to expose
such call paths, which would now be triggered.
Also, if we call __drbd_make_request() from resource worker context,
like w_restart_write() did, and that should block for whatever reason
(!drbd_state_is_stable(), resource suspended, ...),
we potentially deadlock the whole resource, as the worker
is needed for state changes and other things.
Create a dedicated retry workqueue for this instead.
Also make sure that inc_ap_bio()/dec_ap_bio() are properly paired,
even if do_retry() needs to retry itself,
in case __drbd_make_request() returns != 0.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-11-24 09:36:25 +00:00
|
|
|
retry.wq = create_singlethread_workqueue("drbd-reissue");
|
|
|
|
if (!retry.wq) {
|
2014-03-27 13:10:55 +00:00
|
|
|
pr_err("unable to create retry workqueue\n");
|
drbd: fix potential deadlock during "restart" of conflicting writes
w_restart_write(), run from worker context, calls __drbd_make_request()
and further drbd_al_begin_io(, delegate=true), which then
potentially deadlocks. The previous patch moved a BUG_ON to expose
such call paths, which would now be triggered.
Also, if we call __drbd_make_request() from resource worker context,
like w_restart_write() did, and that should block for whatever reason
(!drbd_state_is_stable(), resource suspended, ...),
we potentially deadlock the whole resource, as the worker
is needed for state changes and other things.
Create a dedicated retry workqueue for this instead.
Also make sure that inc_ap_bio()/dec_ap_bio() are properly paired,
even if do_retry() needs to retry itself,
in case __drbd_make_request() returns != 0.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-11-24 09:36:25 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
INIT_WORK(&retry.worker, do_retry);
|
|
|
|
spin_lock_init(&retry.lock);
|
|
|
|
INIT_LIST_HEAD(&retry.writes);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2014-05-02 11:19:51 +00:00
|
|
|
if (drbd_debugfs_init())
|
|
|
|
pr_notice("failed to initialize debugfs -- will not be available\n");
|
|
|
|
|
2014-03-27 13:10:55 +00:00
|
|
|
pr_info("initialized. "
|
2009-09-25 23:07:19 +00:00
|
|
|
"Version: " REL_VERSION " (api:%d/proto:%d-%d)\n",
|
|
|
|
API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX);
|
2014-03-27 13:10:55 +00:00
|
|
|
pr_info("%s\n", drbd_buildtag());
|
|
|
|
pr_info("registered as block device major %d\n", DRBD_MAJOR);
|
2009-09-25 23:07:19 +00:00
|
|
|
return 0; /* Success! */
|
|
|
|
|
2011-03-07 11:49:34 +00:00
|
|
|
fail:
|
2009-09-25 23:07:19 +00:00
|
|
|
drbd_cleanup();
|
|
|
|
if (err == -ENOMEM)
|
2014-03-27 13:10:55 +00:00
|
|
|
pr_err("ran out of memory\n");
|
2009-09-25 23:07:19 +00:00
|
|
|
else
|
2014-03-27 13:10:55 +00:00
|
|
|
pr_err("initialization failure\n");
|
2009-09-25 23:07:19 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-05-05 21:05:47 +00:00
|
|
|
static void drbd_free_one_sock(struct drbd_socket *ds)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2014-05-05 21:05:47 +00:00
|
|
|
struct socket *s;
|
|
|
|
mutex_lock(&ds->mutex);
|
|
|
|
s = ds->socket;
|
|
|
|
ds->socket = NULL;
|
|
|
|
mutex_unlock(&ds->mutex);
|
|
|
|
if (s) {
|
|
|
|
/* so debugfs does not need to mutex_lock() */
|
|
|
|
synchronize_rcu();
|
|
|
|
kernel_sock_shutdown(s, SHUT_RDWR);
|
|
|
|
sock_release(s);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-05 21:05:47 +00:00
|
|
|
void drbd_free_sock(struct drbd_connection *connection)
|
|
|
|
{
|
|
|
|
if (connection->data.socket)
|
|
|
|
drbd_free_one_sock(&connection->data);
|
|
|
|
if (connection->meta.socket)
|
|
|
|
drbd_free_one_sock(&connection->meta);
|
|
|
|
}
|
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
/* meta data management */
|
|
|
|
|
2011-05-30 14:32:41 +00:00
|
|
|
void conn_md_sync(struct drbd_connection *connection)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-06-21 15:23:59 +00:00
|
|
|
struct drbd_peer_device *peer_device;
|
2012-08-28 14:48:03 +00:00
|
|
|
int vnr;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2012-08-28 14:48:03 +00:00
|
|
|
rcu_read_lock();
|
2011-06-21 15:23:59 +00:00
|
|
|
idr_for_each_entry(&connection->peer_devices, peer_device, vnr) {
|
|
|
|
struct drbd_device *device = peer_device->device;
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
kref_get(&device->kref);
|
2012-08-28 14:48:03 +00:00
|
|
|
rcu_read_unlock();
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_md_sync(device);
|
2011-06-07 20:54:17 +00:00
|
|
|
kref_put(&device->kref, drbd_destroy_device);
|
2012-08-28 14:48:03 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2013-03-19 17:16:43 +00:00
|
|
|
/* aligned 4kByte */
|
2009-09-25 23:07:19 +00:00
|
|
|
struct meta_data_on_disk {
|
2013-03-19 17:16:46 +00:00
|
|
|
u64 la_size_sect; /* last agreed size. */
|
2009-09-25 23:07:19 +00:00
|
|
|
u64 uuid[UI_SIZE]; /* UUIDs. */
|
|
|
|
u64 device_uuid;
|
|
|
|
u64 reserved_u64_1;
|
|
|
|
u32 flags; /* MDF */
|
|
|
|
u32 magic;
|
|
|
|
u32 md_size_sect;
|
|
|
|
u32 al_offset; /* offset to this block */
|
2013-03-19 17:16:43 +00:00
|
|
|
u32 al_nr_extents; /* important for restoring the AL (userspace) */
|
2011-03-23 13:31:09 +00:00
|
|
|
/* `-- act_log->nr_elements <-- ldev->dc.al_extents */
|
2009-09-25 23:07:19 +00:00
|
|
|
u32 bm_offset; /* offset to the bitmap, from here */
|
|
|
|
u32 bm_bytes_per_bit; /* BM_BLOCK_SIZE */
|
2011-05-20 14:39:13 +00:00
|
|
|
u32 la_peer_max_bio_size; /* last peer max_bio_size */
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2013-03-19 17:16:44 +00:00
|
|
|
/* see al_tr_number_to_on_disk_sector() */
|
|
|
|
u32 al_stripes;
|
|
|
|
u32 al_stripe_size_4k;
|
|
|
|
|
|
|
|
u8 reserved_u8[4096 - (7*8 + 10*4)];
|
2009-09-25 23:07:19 +00:00
|
|
|
} __packed;
|
|
|
|
|
2013-06-25 14:50:08 +00:00
|
|
|
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_md_write(struct drbd_device *device, void *b)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2013-06-25 14:50:08 +00:00
|
|
|
struct meta_data_on_disk *buffer = b;
|
2009-09-25 23:07:19 +00:00
|
|
|
sector_t sector;
|
|
|
|
int i;
|
|
|
|
|
2013-03-19 17:16:43 +00:00
|
|
|
memset(buffer, 0, sizeof(*buffer));
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
buffer->la_size_sect = cpu_to_be64(drbd_get_capacity(device->this_bdev));
|
2009-09-25 23:07:19 +00:00
|
|
|
for (i = UI_CURRENT; i < UI_SIZE; i++)
|
2011-07-03 11:26:43 +00:00
|
|
|
buffer->uuid[i] = cpu_to_be64(device->ldev->md.uuid[i]);
|
|
|
|
buffer->flags = cpu_to_be32(device->ldev->md.flags);
|
drbd: on attach, enforce clean meta data
Detection of unclean shutdown has moved into user space.
The kernel code will, whenever it updates the meta data, mark it as
"unclean", and will refuse to attach to such unclean meta data.
"drbdadm up" now schedules "drbdmeta apply-al", which will apply
the activity log to the bitmap, and/or reinitialize it, if necessary,
as well as set a "clean" indicator flag.
This moves a bit code out of kernel space.
As a side effect, it also prevents some 8.3 module from accidentally
ignoring the 8.4 style activity log, if someone should downgrade,
whether on purpose, or accidentally because he changed kernel versions
without providing an 8.4 for the new kernel, and the new kernel comes
with in-tree 8.3.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-07-05 18:59:26 +00:00
|
|
|
buffer->magic = cpu_to_be32(DRBD_MD_MAGIC_84_UNCLEAN);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
buffer->md_size_sect = cpu_to_be32(device->ldev->md.md_size_sect);
|
|
|
|
buffer->al_offset = cpu_to_be32(device->ldev->md.al_offset);
|
|
|
|
buffer->al_nr_extents = cpu_to_be32(device->act_log->nr_elements);
|
2009-09-25 23:07:19 +00:00
|
|
|
buffer->bm_bytes_per_bit = cpu_to_be32(BM_BLOCK_SIZE);
|
2011-07-03 11:26:43 +00:00
|
|
|
buffer->device_uuid = cpu_to_be64(device->ldev->md.device_uuid);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
buffer->bm_offset = cpu_to_be32(device->ldev->md.bm_offset);
|
|
|
|
buffer->la_peer_max_bio_size = cpu_to_be32(device->peer_max_bio_size);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
buffer->al_stripes = cpu_to_be32(device->ldev->md.al_stripes);
|
|
|
|
buffer->al_stripe_size_4k = cpu_to_be32(device->ldev->md.al_stripe_size_4k);
|
2013-03-19 17:16:44 +00:00
|
|
|
|
2011-06-27 14:23:33 +00:00
|
|
|
D_ASSERT(device, drbd_md_ss(device->ldev) == device->ldev->md.md_offset);
|
2011-07-03 11:26:43 +00:00
|
|
|
sector = device->ldev->md.md_offset;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2016-06-05 19:32:06 +00:00
|
|
|
if (drbd_md_sync_page_io(device, device->ldev, sector, REQ_OP_WRITE)) {
|
2009-09-25 23:07:19 +00:00
|
|
|
/* this was a try anyways ... */
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "meta data update failed!\n");
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_chk_io_error(device, 1, DRBD_META_IO_ERROR);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2013-06-25 14:50:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_md_sync() - Writes the meta data super block if the MD_DIRTY flag bit is set
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: DRBD device.
|
2013-06-25 14:50:08 +00:00
|
|
|
*/
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_md_sync(struct drbd_device *device)
|
2013-06-25 14:50:08 +00:00
|
|
|
{
|
|
|
|
struct meta_data_on_disk *buffer;
|
|
|
|
|
|
|
|
/* Don't accidentally change the DRBD meta data layout. */
|
|
|
|
BUILD_BUG_ON(UI_SIZE != 4);
|
|
|
|
BUILD_BUG_ON(sizeof(struct meta_data_on_disk) != 4096);
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
del_timer(&device->md_sync_timer);
|
2013-06-25 14:50:08 +00:00
|
|
|
/* timer may be rearmed by drbd_md_mark_dirty() now. */
|
2011-07-03 11:26:43 +00:00
|
|
|
if (!test_and_clear_bit(MD_DIRTY, &device->flags))
|
2013-06-25 14:50:08 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* We use here D_FAILED and not D_ATTACHING because we try to write
|
|
|
|
* metadata even if we detach due to a disk failure! */
|
2011-07-03 11:26:43 +00:00
|
|
|
if (!get_ldev_if_state(device, D_FAILED))
|
2013-06-25 14:50:08 +00:00
|
|
|
return;
|
|
|
|
|
2014-04-01 21:53:30 +00:00
|
|
|
buffer = drbd_md_get_buffer(device, __func__);
|
2013-06-25 14:50:08 +00:00
|
|
|
if (!buffer)
|
|
|
|
goto out;
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_md_write(device, buffer);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
/* Update device->ldev->md.la_size_sect,
|
2009-09-25 23:07:19 +00:00
|
|
|
* since we updated it on metadata. */
|
2011-07-03 11:26:43 +00:00
|
|
|
device->ldev->md.la_size_sect = drbd_get_capacity(device->this_bdev);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_md_put_buffer(device);
|
2011-06-27 09:51:46 +00:00
|
|
|
out:
|
2011-07-03 11:26:43 +00:00
|
|
|
put_ldev(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
static int check_activity_log_stripe_size(struct drbd_device *device,
|
2013-03-19 17:16:44 +00:00
|
|
|
struct meta_data_on_disk *on_disk,
|
|
|
|
struct drbd_md *in_core)
|
|
|
|
{
|
|
|
|
u32 al_stripes = be32_to_cpu(on_disk->al_stripes);
|
|
|
|
u32 al_stripe_size_4k = be32_to_cpu(on_disk->al_stripe_size_4k);
|
|
|
|
u64 al_size_4k;
|
|
|
|
|
|
|
|
/* both not set: default to old fixed size activity log */
|
|
|
|
if (al_stripes == 0 && al_stripe_size_4k == 0) {
|
|
|
|
al_stripes = 1;
|
|
|
|
al_stripe_size_4k = MD_32kB_SECT/8;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* some paranoia plausibility checks */
|
|
|
|
|
|
|
|
/* we need both values to be set */
|
|
|
|
if (al_stripes == 0 || al_stripe_size_4k == 0)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
al_size_4k = (u64)al_stripes * al_stripe_size_4k;
|
|
|
|
|
|
|
|
/* Upper limit of activity log area, to avoid potential overflow
|
|
|
|
* problems in al_tr_number_to_on_disk_sector(). As right now, more
|
|
|
|
* than 72 * 4k blocks total only increases the amount of history,
|
|
|
|
* limiting this arbitrarily to 16 GB is not a real limitation ;-) */
|
|
|
|
if (al_size_4k > (16 * 1024 * 1024/4))
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
/* Lower limit: we need at least 8 transaction slots (32kB)
|
|
|
|
* to not break existing setups */
|
|
|
|
if (al_size_4k < MD_32kB_SECT/8)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
in_core->al_stripe_size_4k = al_stripe_size_4k;
|
|
|
|
in_core->al_stripes = al_stripes;
|
|
|
|
in_core->al_size_4k = al_size_4k;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
err:
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "invalid activity log striping: al_stripes=%u, al_stripe_size_4k=%u\n",
|
2013-03-19 17:16:44 +00:00
|
|
|
al_stripes, al_stripe_size_4k);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
static int check_offsets_and_sizes(struct drbd_device *device, struct drbd_backing_dev *bdev)
|
2013-03-19 17:16:47 +00:00
|
|
|
{
|
|
|
|
sector_t capacity = drbd_get_capacity(bdev->md_bdev);
|
|
|
|
struct drbd_md *in_core = &bdev->md;
|
|
|
|
s32 on_disk_al_sect;
|
|
|
|
s32 on_disk_bm_sect;
|
|
|
|
|
|
|
|
/* The on-disk size of the activity log, calculated from offsets, and
|
|
|
|
* the size of the activity log calculated from the stripe settings,
|
|
|
|
* should match.
|
|
|
|
* Though we could relax this a bit: it is ok, if the striped activity log
|
|
|
|
* fits in the available on-disk activity log size.
|
|
|
|
* Right now, that would break how resize is implemented.
|
|
|
|
* TODO: make drbd_determine_dev_size() (and the drbdmeta tool) aware
|
|
|
|
* of possible unused padding space in the on disk layout. */
|
|
|
|
if (in_core->al_offset < 0) {
|
|
|
|
if (in_core->bm_offset > in_core->al_offset)
|
|
|
|
goto err;
|
|
|
|
on_disk_al_sect = -in_core->al_offset;
|
|
|
|
on_disk_bm_sect = in_core->al_offset - in_core->bm_offset;
|
|
|
|
} else {
|
|
|
|
if (in_core->al_offset != MD_4kB_SECT)
|
|
|
|
goto err;
|
|
|
|
if (in_core->bm_offset < in_core->al_offset + in_core->al_size_4k * MD_4kB_SECT)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
on_disk_al_sect = in_core->bm_offset - MD_4kB_SECT;
|
|
|
|
on_disk_bm_sect = in_core->md_size_sect - in_core->bm_offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* old fixed size meta data is exactly that: fixed. */
|
|
|
|
if (in_core->meta_dev_idx >= 0) {
|
|
|
|
if (in_core->md_size_sect != MD_128MB_SECT
|
|
|
|
|| in_core->al_offset != MD_4kB_SECT
|
|
|
|
|| in_core->bm_offset != MD_4kB_SECT + MD_32kB_SECT
|
|
|
|
|| in_core->al_stripes != 1
|
|
|
|
|| in_core->al_stripe_size_4k != MD_32kB_SECT/8)
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (capacity < in_core->md_size_sect)
|
|
|
|
goto err;
|
|
|
|
if (capacity - in_core->md_size_sect < drbd_md_first_sector(bdev))
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
/* should be aligned, and at least 32k */
|
|
|
|
if ((on_disk_al_sect & 7) || (on_disk_al_sect < MD_32kB_SECT))
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
/* should fit (for now: exactly) into the available on-disk space;
|
|
|
|
* overflow prevention is in check_activity_log_stripe_size() above. */
|
|
|
|
if (on_disk_al_sect != in_core->al_size_4k * MD_4kB_SECT)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
/* again, should be aligned */
|
|
|
|
if (in_core->bm_offset & 7)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
/* FIXME check for device grow with flex external meta data? */
|
|
|
|
|
|
|
|
/* can the available bitmap space cover the last agreed device size? */
|
|
|
|
if (on_disk_bm_sect < (in_core->la_size_sect+7)/MD_4kB_SECT/8/512)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "meta data offsets don't make sense: idx=%d "
|
2013-03-19 17:16:47 +00:00
|
|
|
"al_s=%u, al_sz4k=%u, al_offset=%d, bm_offset=%d, "
|
|
|
|
"md_size_sect=%u, la_size=%llu, md_capacity=%llu\n",
|
|
|
|
in_core->meta_dev_idx,
|
|
|
|
in_core->al_stripes, in_core->al_stripe_size_4k,
|
|
|
|
in_core->al_offset, in_core->bm_offset, in_core->md_size_sect,
|
|
|
|
(unsigned long long)in_core->la_size_sect,
|
|
|
|
(unsigned long long)capacity);
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
/**
|
|
|
|
* drbd_md_read() - Reads in the meta data super block
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: DRBD device.
|
2009-09-25 23:07:19 +00:00
|
|
|
* @bdev: Device from which the meta data should be read in.
|
|
|
|
*
|
2013-03-19 17:16:44 +00:00
|
|
|
* Return NO_ERROR on success, and an enum drbd_ret_code in case
|
drbd: on attach, enforce clean meta data
Detection of unclean shutdown has moved into user space.
The kernel code will, whenever it updates the meta data, mark it as
"unclean", and will refuse to attach to such unclean meta data.
"drbdadm up" now schedules "drbdmeta apply-al", which will apply
the activity log to the bitmap, and/or reinitialize it, if necessary,
as well as set a "clean" indicator flag.
This moves a bit code out of kernel space.
As a side effect, it also prevents some 8.3 module from accidentally
ignoring the 8.4 style activity log, if someone should downgrade,
whether on purpose, or accidentally because he changed kernel versions
without providing an 8.4 for the new kernel, and the new kernel comes
with in-tree 8.3.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-07-05 18:59:26 +00:00
|
|
|
* something goes wrong.
|
2013-03-19 17:16:44 +00:00
|
|
|
*
|
2013-03-19 17:16:47 +00:00
|
|
|
* Called exactly once during drbd_adm_attach(), while still being D_DISKLESS,
|
2011-07-03 11:26:43 +00:00
|
|
|
* even before @bdev is assigned to @device->ldev.
|
2009-09-25 23:07:19 +00:00
|
|
|
*/
|
2011-07-03 11:26:43 +00:00
|
|
|
int drbd_md_read(struct drbd_device *device, struct drbd_backing_dev *bdev)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
struct meta_data_on_disk *buffer;
|
drbd: on attach, enforce clean meta data
Detection of unclean shutdown has moved into user space.
The kernel code will, whenever it updates the meta data, mark it as
"unclean", and will refuse to attach to such unclean meta data.
"drbdadm up" now schedules "drbdmeta apply-al", which will apply
the activity log to the bitmap, and/or reinitialize it, if necessary,
as well as set a "clean" indicator flag.
This moves a bit code out of kernel space.
As a side effect, it also prevents some 8.3 module from accidentally
ignoring the 8.4 style activity log, if someone should downgrade,
whether on purpose, or accidentally because he changed kernel versions
without providing an 8.4 for the new kernel, and the new kernel comes
with in-tree 8.3.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-07-05 18:59:26 +00:00
|
|
|
u32 magic, flags;
|
2009-09-25 23:07:19 +00:00
|
|
|
int i, rv = NO_ERROR;
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (device->state.disk != D_DISKLESS)
|
2013-03-19 17:16:47 +00:00
|
|
|
return ERR_DISK_CONFIGURED;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2014-04-01 21:53:30 +00:00
|
|
|
buffer = drbd_md_get_buffer(device, __func__);
|
2011-06-27 09:51:46 +00:00
|
|
|
if (!buffer)
|
2013-03-19 17:16:47 +00:00
|
|
|
return ERR_NOMEM;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2013-03-19 17:16:47 +00:00
|
|
|
/* First, figure out where our meta data superblock is located,
|
|
|
|
* and read it. */
|
2013-03-19 17:16:44 +00:00
|
|
|
bdev->md.meta_dev_idx = bdev->disk_conf->meta_dev_idx;
|
|
|
|
bdev->md.md_offset = drbd_md_ss(bdev);
|
2015-03-24 20:35:26 +00:00
|
|
|
/* Even for (flexible or indexed) external meta data,
|
|
|
|
* initially restrict us to the 4k superblock for now.
|
|
|
|
* Affects the paranoia out-of-range access check in drbd_md_sync_page_io(). */
|
|
|
|
bdev->md.md_size_sect = 8;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2016-06-05 19:32:06 +00:00
|
|
|
if (drbd_md_sync_page_io(device, bdev, bdev->md.md_offset,
|
|
|
|
REQ_OP_READ)) {
|
2011-03-31 01:57:33 +00:00
|
|
|
/* NOTE: can't do normal error processing here as this is
|
2009-09-25 23:07:19 +00:00
|
|
|
called BEFORE disk is attached */
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "Error while reading metadata.\n");
|
2009-09-25 23:07:19 +00:00
|
|
|
rv = ERR_IO_MD_DISK;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
drbd: on attach, enforce clean meta data
Detection of unclean shutdown has moved into user space.
The kernel code will, whenever it updates the meta data, mark it as
"unclean", and will refuse to attach to such unclean meta data.
"drbdadm up" now schedules "drbdmeta apply-al", which will apply
the activity log to the bitmap, and/or reinitialize it, if necessary,
as well as set a "clean" indicator flag.
This moves a bit code out of kernel space.
As a side effect, it also prevents some 8.3 module from accidentally
ignoring the 8.4 style activity log, if someone should downgrade,
whether on purpose, or accidentally because he changed kernel versions
without providing an 8.4 for the new kernel, and the new kernel comes
with in-tree 8.3.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-07-05 18:59:26 +00:00
|
|
|
magic = be32_to_cpu(buffer->magic);
|
|
|
|
flags = be32_to_cpu(buffer->flags);
|
|
|
|
if (magic == DRBD_MD_MAGIC_84_UNCLEAN ||
|
|
|
|
(magic == DRBD_MD_MAGIC_08 && !(flags & MDF_AL_CLEAN))) {
|
|
|
|
/* btw: that's Activity Log clean, not "all" clean. */
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "Found unclean meta data. Did you \"drbdadm apply-al\"?\n");
|
drbd: on attach, enforce clean meta data
Detection of unclean shutdown has moved into user space.
The kernel code will, whenever it updates the meta data, mark it as
"unclean", and will refuse to attach to such unclean meta data.
"drbdadm up" now schedules "drbdmeta apply-al", which will apply
the activity log to the bitmap, and/or reinitialize it, if necessary,
as well as set a "clean" indicator flag.
This moves a bit code out of kernel space.
As a side effect, it also prevents some 8.3 module from accidentally
ignoring the 8.4 style activity log, if someone should downgrade,
whether on purpose, or accidentally because he changed kernel versions
without providing an 8.4 for the new kernel, and the new kernel comes
with in-tree 8.3.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-07-05 18:59:26 +00:00
|
|
|
rv = ERR_MD_UNCLEAN;
|
|
|
|
goto err;
|
|
|
|
}
|
2013-03-19 17:16:44 +00:00
|
|
|
|
|
|
|
rv = ERR_MD_INVALID;
|
drbd: on attach, enforce clean meta data
Detection of unclean shutdown has moved into user space.
The kernel code will, whenever it updates the meta data, mark it as
"unclean", and will refuse to attach to such unclean meta data.
"drbdadm up" now schedules "drbdmeta apply-al", which will apply
the activity log to the bitmap, and/or reinitialize it, if necessary,
as well as set a "clean" indicator flag.
This moves a bit code out of kernel space.
As a side effect, it also prevents some 8.3 module from accidentally
ignoring the 8.4 style activity log, if someone should downgrade,
whether on purpose, or accidentally because he changed kernel versions
without providing an 8.4 for the new kernel, and the new kernel comes
with in-tree 8.3.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-07-05 18:59:26 +00:00
|
|
|
if (magic != DRBD_MD_MAGIC_08) {
|
2011-11-10 12:16:13 +00:00
|
|
|
if (magic == DRBD_MD_MAGIC_07)
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "Found old (0.7) meta data magic. Did you \"drbdadm create-md\"?\n");
|
drbd: on attach, enforce clean meta data
Detection of unclean shutdown has moved into user space.
The kernel code will, whenever it updates the meta data, mark it as
"unclean", and will refuse to attach to such unclean meta data.
"drbdadm up" now schedules "drbdmeta apply-al", which will apply
the activity log to the bitmap, and/or reinitialize it, if necessary,
as well as set a "clean" indicator flag.
This moves a bit code out of kernel space.
As a side effect, it also prevents some 8.3 module from accidentally
ignoring the 8.4 style activity log, if someone should downgrade,
whether on purpose, or accidentally because he changed kernel versions
without providing an 8.4 for the new kernel, and the new kernel comes
with in-tree 8.3.
Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
2011-07-05 18:59:26 +00:00
|
|
|
else
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "Meta data magic not found. Did you \"drbdadm create-md\"?\n");
|
2009-09-25 23:07:19 +00:00
|
|
|
goto err;
|
|
|
|
}
|
2013-03-19 17:16:44 +00:00
|
|
|
|
2013-03-19 17:16:47 +00:00
|
|
|
if (be32_to_cpu(buffer->bm_bytes_per_bit) != BM_BLOCK_SIZE) {
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "unexpected bm_bytes_per_bit: %u (expected %u)\n",
|
2013-03-19 17:16:47 +00:00
|
|
|
be32_to_cpu(buffer->bm_bytes_per_bit), BM_BLOCK_SIZE);
|
2009-09-25 23:07:19 +00:00
|
|
|
goto err;
|
|
|
|
}
|
2013-03-19 17:16:44 +00:00
|
|
|
|
2013-03-19 17:16:47 +00:00
|
|
|
|
|
|
|
/* convert to in_core endian */
|
|
|
|
bdev->md.la_size_sect = be64_to_cpu(buffer->la_size_sect);
|
|
|
|
for (i = UI_CURRENT; i < UI_SIZE; i++)
|
|
|
|
bdev->md.uuid[i] = be64_to_cpu(buffer->uuid[i]);
|
|
|
|
bdev->md.flags = be32_to_cpu(buffer->flags);
|
|
|
|
bdev->md.device_uuid = be64_to_cpu(buffer->device_uuid);
|
|
|
|
|
|
|
|
bdev->md.md_size_sect = be32_to_cpu(buffer->md_size_sect);
|
|
|
|
bdev->md.al_offset = be32_to_cpu(buffer->al_offset);
|
|
|
|
bdev->md.bm_offset = be32_to_cpu(buffer->bm_offset);
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (check_activity_log_stripe_size(device, buffer, &bdev->md))
|
2009-09-25 23:07:19 +00:00
|
|
|
goto err;
|
2011-07-03 11:26:43 +00:00
|
|
|
if (check_offsets_and_sizes(device, bdev))
|
2013-03-19 17:16:47 +00:00
|
|
|
goto err;
|
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
if (be32_to_cpu(buffer->bm_offset) != bdev->md.bm_offset) {
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "unexpected bm_offset: %d (expected %d)\n",
|
2009-09-25 23:07:19 +00:00
|
|
|
be32_to_cpu(buffer->bm_offset), bdev->md.bm_offset);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
if (be32_to_cpu(buffer->md_size_sect) != bdev->md.md_size_sect) {
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "unexpected md_size: %u (expected %u)\n",
|
2009-09-25 23:07:19 +00:00
|
|
|
be32_to_cpu(buffer->md_size_sect), bdev->md.md_size_sect);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2013-03-19 17:16:44 +00:00
|
|
|
rv = NO_ERROR;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_lock_irq(&device->resource->req_lock);
|
2011-07-03 11:26:43 +00:00
|
|
|
if (device->state.conn < C_CONNECTED) {
|
2012-06-25 17:15:58 +00:00
|
|
|
unsigned int peer;
|
2011-05-20 14:39:13 +00:00
|
|
|
peer = be32_to_cpu(buffer->la_peer_max_bio_size);
|
2012-06-25 17:15:58 +00:00
|
|
|
peer = max(peer, DRBD_MAX_BIO_SIZE_SAFE);
|
2011-07-03 11:26:43 +00:00
|
|
|
device->peer_max_bio_size = peer;
|
2011-05-20 14:39:13 +00:00
|
|
|
}
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_unlock_irq(&device->resource->req_lock);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
err:
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_md_put_buffer(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_md_mark_dirty() - Mark meta data super block as dirty
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: DRBD device.
|
2009-09-25 23:07:19 +00:00
|
|
|
*
|
|
|
|
* Call this function if you change anything that should be written to
|
|
|
|
* the meta-data super block. This function sets MD_DIRTY, and starts a
|
|
|
|
* timer that ensures that within five seconds you have to call drbd_md_sync().
|
|
|
|
*/
|
2010-10-14 13:01:21 +00:00
|
|
|
#ifdef DEBUG
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_md_mark_dirty_(struct drbd_device *device, unsigned int line, const char *func)
|
2010-09-03 08:00:09 +00:00
|
|
|
{
|
2011-07-03 11:26:43 +00:00
|
|
|
if (!test_and_set_bit(MD_DIRTY, &device->flags)) {
|
|
|
|
mod_timer(&device->md_sync_timer, jiffies + HZ);
|
|
|
|
device->last_md_mark_dirty.line = line;
|
|
|
|
device->last_md_mark_dirty.func = func;
|
2010-09-03 08:00:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_md_mark_dirty(struct drbd_device *device)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-07-03 11:26:43 +00:00
|
|
|
if (!test_and_set_bit(MD_DIRTY, &device->flags))
|
|
|
|
mod_timer(&device->md_sync_timer, jiffies + 5*HZ);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2010-09-03 08:00:09 +00:00
|
|
|
#endif
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_uuid_move_history(struct drbd_device *device) __must_hold(local)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2011-01-20 12:25:21 +00:00
|
|
|
for (i = UI_HISTORY_START; i < UI_HISTORY_END; i++)
|
2011-07-03 11:26:43 +00:00
|
|
|
device->ldev->md.uuid[i+1] = device->ldev->md.uuid[i];
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
void __drbd_uuid_set(struct drbd_device *device, int idx, u64 val) __must_hold(local)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
if (idx == UI_CURRENT) {
|
2011-07-03 11:26:43 +00:00
|
|
|
if (device->state.role == R_PRIMARY)
|
2009-09-25 23:07:19 +00:00
|
|
|
val |= 1;
|
|
|
|
else
|
|
|
|
val &= ~((u64)1);
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_set_ed_uuid(device, val);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
device->ldev->md.uuid[idx] = val;
|
|
|
|
drbd_md_mark_dirty(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
void _drbd_uuid_set(struct drbd_device *device, int idx, u64 val) __must_hold(local)
|
2012-08-16 12:25:58 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2011-07-03 11:26:43 +00:00
|
|
|
spin_lock_irqsave(&device->ldev->md.uuid_lock, flags);
|
|
|
|
__drbd_uuid_set(device, idx, val);
|
|
|
|
spin_unlock_irqrestore(&device->ldev->md.uuid_lock, flags);
|
2012-08-16 12:25:58 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_uuid_set(struct drbd_device *device, int idx, u64 val) __must_hold(local)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2012-08-16 12:25:58 +00:00
|
|
|
unsigned long flags;
|
2011-07-03 11:26:43 +00:00
|
|
|
spin_lock_irqsave(&device->ldev->md.uuid_lock, flags);
|
|
|
|
if (device->ldev->md.uuid[idx]) {
|
|
|
|
drbd_uuid_move_history(device);
|
|
|
|
device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[idx];
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2011-07-03 11:26:43 +00:00
|
|
|
__drbd_uuid_set(device, idx, val);
|
|
|
|
spin_unlock_irqrestore(&device->ldev->md.uuid_lock, flags);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_uuid_new_current() - Creates a new current UUID
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: DRBD device.
|
2009-09-25 23:07:19 +00:00
|
|
|
*
|
|
|
|
* Creates a new current UUID, and rotates the old current UUID into
|
|
|
|
* the bitmap slot. Causes an incremental resync upon next connect.
|
|
|
|
*/
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_uuid_new_current(struct drbd_device *device) __must_hold(local)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
u64 val;
|
2012-08-16 12:25:58 +00:00
|
|
|
unsigned long long bm_uuid;
|
|
|
|
|
|
|
|
get_random_bytes(&val, sizeof(u64));
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
spin_lock_irq(&device->ldev->md.uuid_lock);
|
|
|
|
bm_uuid = device->ldev->md.uuid[UI_BITMAP];
|
2011-01-20 12:25:21 +00:00
|
|
|
|
|
|
|
if (bm_uuid)
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_warn(device, "bm UUID was already set: %llX\n", bm_uuid);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
device->ldev->md.uuid[UI_BITMAP] = device->ldev->md.uuid[UI_CURRENT];
|
|
|
|
__drbd_uuid_set(device, UI_CURRENT, val);
|
|
|
|
spin_unlock_irq(&device->ldev->md.uuid_lock);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_print_uuids(device, "new current UUID");
|
2010-10-15 11:16:53 +00:00
|
|
|
/* get it to stable storage _now_ */
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_md_sync(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_uuid_set_bm(struct drbd_device *device, u64 val) __must_hold(local)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2012-08-16 12:25:58 +00:00
|
|
|
unsigned long flags;
|
2011-07-03 11:26:43 +00:00
|
|
|
if (device->ldev->md.uuid[UI_BITMAP] == 0 && val == 0)
|
2009-09-25 23:07:19 +00:00
|
|
|
return;
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
spin_lock_irqsave(&device->ldev->md.uuid_lock, flags);
|
2009-09-25 23:07:19 +00:00
|
|
|
if (val == 0) {
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_uuid_move_history(device);
|
|
|
|
device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[UI_BITMAP];
|
|
|
|
device->ldev->md.uuid[UI_BITMAP] = 0;
|
2009-09-25 23:07:19 +00:00
|
|
|
} else {
|
2011-07-03 11:26:43 +00:00
|
|
|
unsigned long long bm_uuid = device->ldev->md.uuid[UI_BITMAP];
|
2011-01-20 12:25:21 +00:00
|
|
|
if (bm_uuid)
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_warn(device, "bm UUID was already set: %llX\n", bm_uuid);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
device->ldev->md.uuid[UI_BITMAP] = val & ~((u64)1);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2011-07-03 11:26:43 +00:00
|
|
|
spin_unlock_irqrestore(&device->ldev->md.uuid_lock, flags);
|
2012-08-16 12:25:58 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_md_mark_dirty(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_bmio_set_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: DRBD device.
|
2009-09-25 23:07:19 +00:00
|
|
|
*
|
|
|
|
* Sets all bits in the bitmap and writes the whole bitmap to stable storage.
|
|
|
|
*/
|
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 12:22:13 +00:00
|
|
|
int drbd_bmio_set_n_write(struct drbd_device *device) __must_hold(local)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
int rv = -EIO;
|
|
|
|
|
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 12:22:13 +00:00
|
|
|
drbd_md_set_flag(device, MDF_FULL_SYNC);
|
|
|
|
drbd_md_sync(device);
|
|
|
|
drbd_bm_set_all(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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 12:22:13 +00:00
|
|
|
rv = drbd_bm_write(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
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 12:22:13 +00:00
|
|
|
if (!rv) {
|
|
|
|
drbd_md_clear_flag(device, MDF_FULL_SYNC);
|
|
|
|
drbd_md_sync(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_bmio_clear_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: DRBD device.
|
2009-09-25 23:07:19 +00:00
|
|
|
*
|
|
|
|
* Clears all bits in the bitmap and writes the whole bitmap to stable storage.
|
|
|
|
*/
|
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 12:22:13 +00:00
|
|
|
int drbd_bmio_clear_n_write(struct drbd_device *device) __must_hold(local)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_resume_al(device);
|
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 12:22:13 +00:00
|
|
|
drbd_bm_clear_all(device);
|
|
|
|
return drbd_bm_write(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-03-16 14:31:39 +00:00
|
|
|
static int w_bitmap_io(struct drbd_work *w, int unused)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-07-28 13:27:51 +00:00
|
|
|
struct drbd_device *device =
|
|
|
|
container_of(w, struct drbd_device, bm_io_work.w);
|
|
|
|
struct bm_io_work *work = &device->bm_io_work;
|
2010-12-16 13:47:39 +00:00
|
|
|
int rv = -EIO;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2016-06-13 22:26:16 +00:00
|
|
|
if (work->flags != BM_LOCKED_CHANGE_ALLOWED) {
|
|
|
|
int cnt = atomic_read(&device->ap_bio_cnt);
|
|
|
|
if (cnt)
|
|
|
|
drbd_err(device, "FIXME: ap_bio_cnt %d, expected 0; queued for '%s'\n",
|
|
|
|
cnt, work->why);
|
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
if (get_ldev(device)) {
|
|
|
|
drbd_bm_lock(device, work->why, work->flags);
|
|
|
|
rv = work->io_fn(device);
|
|
|
|
drbd_bm_unlock(device);
|
|
|
|
put_ldev(device);
|
2010-12-16 13:47:39 +00:00
|
|
|
}
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
clear_bit_unlock(BITMAP_IO, &device->flags);
|
|
|
|
wake_up(&device->misc_wait);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
if (work->done)
|
2011-07-03 11:26:43 +00:00
|
|
|
work->done(device, rv);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
clear_bit(BITMAP_IO_QUEUED, &device->flags);
|
2009-09-25 23:07:19 +00:00
|
|
|
work->why = NULL;
|
2011-01-21 09:56:44 +00:00
|
|
|
work->flags = 0;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-03-16 14:31:39 +00:00
|
|
|
return 0;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_queue_bitmap_io() - Queues an IO operation on the whole bitmap
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: DRBD device.
|
2009-09-25 23:07:19 +00:00
|
|
|
* @io_fn: IO callback to be called when bitmap IO is possible
|
|
|
|
* @done: callback to be called after the bitmap IO was performed
|
|
|
|
* @why: Descriptive text of the reason for doing the IO
|
|
|
|
*
|
|
|
|
* While IO on the bitmap happens we freeze application IO thus we ensure
|
|
|
|
* that drbd_set_out_of_sync() can not be called. This function MAY ONLY be
|
|
|
|
* called from worker context. It MUST NOT be used while a previous such
|
|
|
|
* work is still pending!
|
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 12:22:13 +00:00
|
|
|
*
|
|
|
|
* Its worker function encloses the call of io_fn() by get_ldev() and
|
|
|
|
* put_ldev().
|
2009-09-25 23:07:19 +00:00
|
|
|
*/
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_queue_bitmap_io(struct drbd_device *device,
|
2011-05-30 14:15:21 +00:00
|
|
|
int (*io_fn)(struct drbd_device *),
|
|
|
|
void (*done)(struct drbd_device *, int),
|
2011-01-21 09:56:44 +00:00
|
|
|
char *why, enum bm_flag flags)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-06-27 14:23:33 +00:00
|
|
|
D_ASSERT(device, current == first_peer_device(device)->connection->worker.task);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-06-27 14:23:33 +00:00
|
|
|
D_ASSERT(device, !test_bit(BITMAP_IO_QUEUED, &device->flags));
|
|
|
|
D_ASSERT(device, !test_bit(BITMAP_IO, &device->flags));
|
|
|
|
D_ASSERT(device, list_empty(&device->bm_io_work.w.list));
|
2011-07-03 11:26:43 +00:00
|
|
|
if (device->bm_io_work.why)
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_err(device, "FIXME going to queue '%s' but '%s' still pending?\n",
|
2011-07-03 11:26:43 +00:00
|
|
|
why, device->bm_io_work.why);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
device->bm_io_work.io_fn = io_fn;
|
|
|
|
device->bm_io_work.done = done;
|
|
|
|
device->bm_io_work.why = why;
|
|
|
|
device->bm_io_work.flags = flags;
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_lock_irq(&device->resource->req_lock);
|
2011-07-03 11:26:43 +00:00
|
|
|
set_bit(BITMAP_IO, &device->flags);
|
2015-04-16 14:51:34 +00:00
|
|
|
/* don't wait for pending application IO if the caller indicates that
|
|
|
|
* application IO does not conflict anyways. */
|
|
|
|
if (flags == BM_LOCKED_CHANGE_ALLOWED || atomic_read(&device->ap_bio_cnt) == 0) {
|
2011-07-03 11:26:43 +00:00
|
|
|
if (!test_and_set_bit(BITMAP_IO_QUEUED, &device->flags))
|
2011-07-28 13:27:51 +00:00
|
|
|
drbd_queue_work(&first_peer_device(device)->connection->sender_work,
|
|
|
|
&device->bm_io_work.w);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_unlock_irq(&device->resource->req_lock);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drbd_bitmap_io() - Does an IO operation on the whole bitmap
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: DRBD device.
|
2009-09-25 23:07:19 +00:00
|
|
|
* @io_fn: IO callback to be called when bitmap IO is possible
|
|
|
|
* @why: Descriptive text of the reason for doing the IO
|
|
|
|
*
|
|
|
|
* freezes application IO while that the actual IO operations runs. This
|
|
|
|
* functions MAY NOT be called from worker context.
|
|
|
|
*/
|
2011-07-03 11:26:43 +00:00
|
|
|
int drbd_bitmap_io(struct drbd_device *device, int (*io_fn)(struct drbd_device *),
|
2011-01-21 09:56:44 +00:00
|
|
|
char *why, enum bm_flag flags)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2016-06-13 22:26:10 +00:00
|
|
|
/* Only suspend io, if some operation is supposed to be locked out */
|
|
|
|
const bool do_suspend_io = flags & (BM_DONT_CLEAR|BM_DONT_SET|BM_DONT_TEST);
|
2009-09-25 23:07:19 +00:00
|
|
|
int rv;
|
|
|
|
|
2011-06-27 14:23:33 +00:00
|
|
|
D_ASSERT(device, current != first_peer_device(device)->connection->worker.task);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2016-06-13 22:26:10 +00:00
|
|
|
if (do_suspend_io)
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_suspend_io(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_bm_lock(device, why, flags);
|
|
|
|
rv = io_fn(device);
|
|
|
|
drbd_bm_unlock(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
2016-06-13 22:26:10 +00:00
|
|
|
if (do_suspend_io)
|
2011-07-03 11:26:43 +00:00
|
|
|
drbd_resume_io(device);
|
2009-09-25 23:07:19 +00:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_md_set_flag(struct drbd_device *device, int flag) __must_hold(local)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-07-03 11:26:43 +00:00
|
|
|
if ((device->ldev->md.flags & flag) != flag) {
|
|
|
|
drbd_md_mark_dirty(device);
|
|
|
|
device->ldev->md.flags |= flag;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
void drbd_md_clear_flag(struct drbd_device *device, int flag) __must_hold(local)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
2011-07-03 11:26:43 +00:00
|
|
|
if ((device->ldev->md.flags & flag) != 0) {
|
|
|
|
drbd_md_mark_dirty(device);
|
|
|
|
device->ldev->md.flags &= ~flag;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
int drbd_md_test_flag(struct drbd_backing_dev *bdev, int flag)
|
|
|
|
{
|
|
|
|
return (bdev->md.flags & flag) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void md_sync_timer_fn(unsigned long data)
|
|
|
|
{
|
2011-07-03 11:26:43 +00:00
|
|
|
struct drbd_device *device = (struct drbd_device *) data;
|
2014-02-11 08:47:58 +00:00
|
|
|
drbd_device_post_work(device, MD_SYNC);
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2011-01-26 16:39:41 +00:00
|
|
|
const char *cmdname(enum drbd_packet cmd)
|
2011-01-26 16:13:25 +00:00
|
|
|
{
|
|
|
|
/* THINK may need to become several global tables
|
|
|
|
* when we want to support more than
|
|
|
|
* one PRO_VERSION */
|
|
|
|
static const char *cmdnames[] = {
|
|
|
|
[P_DATA] = "Data",
|
2016-06-13 22:26:31 +00:00
|
|
|
[P_WSAME] = "WriteSame",
|
|
|
|
[P_TRIM] = "Trim",
|
2011-01-26 16:13:25 +00:00
|
|
|
[P_DATA_REPLY] = "DataReply",
|
|
|
|
[P_RS_DATA_REPLY] = "RSDataReply",
|
|
|
|
[P_BARRIER] = "Barrier",
|
|
|
|
[P_BITMAP] = "ReportBitMap",
|
|
|
|
[P_BECOME_SYNC_TARGET] = "BecomeSyncTarget",
|
|
|
|
[P_BECOME_SYNC_SOURCE] = "BecomeSyncSource",
|
|
|
|
[P_UNPLUG_REMOTE] = "UnplugRemote",
|
|
|
|
[P_DATA_REQUEST] = "DataRequest",
|
|
|
|
[P_RS_DATA_REQUEST] = "RSDataRequest",
|
|
|
|
[P_SYNC_PARAM] = "SyncParam",
|
|
|
|
[P_SYNC_PARAM89] = "SyncParam89",
|
|
|
|
[P_PROTOCOL] = "ReportProtocol",
|
|
|
|
[P_UUIDS] = "ReportUUIDs",
|
|
|
|
[P_SIZES] = "ReportSizes",
|
|
|
|
[P_STATE] = "ReportState",
|
|
|
|
[P_SYNC_UUID] = "ReportSyncUUID",
|
|
|
|
[P_AUTH_CHALLENGE] = "AuthChallenge",
|
|
|
|
[P_AUTH_RESPONSE] = "AuthResponse",
|
|
|
|
[P_PING] = "Ping",
|
|
|
|
[P_PING_ACK] = "PingAck",
|
|
|
|
[P_RECV_ACK] = "RecvAck",
|
|
|
|
[P_WRITE_ACK] = "WriteAck",
|
|
|
|
[P_RS_WRITE_ACK] = "RSWriteAck",
|
2012-08-01 10:33:51 +00:00
|
|
|
[P_SUPERSEDED] = "Superseded",
|
2011-01-26 16:13:25 +00:00
|
|
|
[P_NEG_ACK] = "NegAck",
|
|
|
|
[P_NEG_DREPLY] = "NegDReply",
|
|
|
|
[P_NEG_RS_DREPLY] = "NegRSDReply",
|
|
|
|
[P_BARRIER_ACK] = "BarrierAck",
|
|
|
|
[P_STATE_CHG_REQ] = "StateChgRequest",
|
|
|
|
[P_STATE_CHG_REPLY] = "StateChgReply",
|
|
|
|
[P_OV_REQUEST] = "OVRequest",
|
|
|
|
[P_OV_REPLY] = "OVReply",
|
|
|
|
[P_OV_RESULT] = "OVResult",
|
|
|
|
[P_CSUM_RS_REQUEST] = "CsumRSRequest",
|
|
|
|
[P_RS_IS_IN_SYNC] = "CsumRSIsInSync",
|
|
|
|
[P_COMPRESSED_BITMAP] = "CBitmap",
|
|
|
|
[P_DELAY_PROBE] = "DelayProbe",
|
|
|
|
[P_OUT_OF_SYNC] = "OutOfSync",
|
2011-02-22 01:15:32 +00:00
|
|
|
[P_RETRY_WRITE] = "RetryWrite",
|
2011-04-23 22:01:16 +00:00
|
|
|
[P_RS_CANCEL] = "RSCancel",
|
|
|
|
[P_CONN_ST_CHG_REQ] = "conn_st_chg_req",
|
|
|
|
[P_CONN_ST_CHG_REPLY] = "conn_st_chg_reply",
|
2011-05-16 15:38:11 +00:00
|
|
|
[P_RETRY_WRITE] = "retry_write",
|
|
|
|
[P_PROTOCOL_UPDATE] = "protocol_update",
|
2016-06-13 22:26:13 +00:00
|
|
|
[P_RS_THIN_REQ] = "rs_thin_req",
|
|
|
|
[P_RS_DEALLOCATED] = "rs_deallocated",
|
2011-04-23 22:01:16 +00:00
|
|
|
|
|
|
|
/* enum drbd_packet, but not commands - obsoleted flags:
|
|
|
|
* P_MAY_IGNORE
|
|
|
|
* P_MAX_OPT_CMD
|
|
|
|
*/
|
2011-01-26 16:13:25 +00:00
|
|
|
};
|
|
|
|
|
2011-04-23 22:01:16 +00:00
|
|
|
/* too big for the array: 0xfffX */
|
2011-03-28 14:44:40 +00:00
|
|
|
if (cmd == P_INITIAL_META)
|
|
|
|
return "InitialMeta";
|
|
|
|
if (cmd == P_INITIAL_DATA)
|
|
|
|
return "InitialData";
|
2011-03-28 15:05:50 +00:00
|
|
|
if (cmd == P_CONNECTION_FEATURES)
|
|
|
|
return "ConnectionFeatures";
|
2011-03-14 16:27:45 +00:00
|
|
|
if (cmd >= ARRAY_SIZE(cmdnames))
|
2011-01-26 16:13:25 +00:00
|
|
|
return "Unknown";
|
|
|
|
return cmdnames[cmd];
|
|
|
|
}
|
|
|
|
|
2011-02-22 01:15:32 +00:00
|
|
|
/**
|
|
|
|
* drbd_wait_misc - wait for a request to make progress
|
2011-07-03 11:26:43 +00:00
|
|
|
* @device: device associated with the request
|
2011-02-22 01:15:32 +00:00
|
|
|
* @i: the struct drbd_interval embedded in struct drbd_request or
|
|
|
|
* struct drbd_peer_request
|
|
|
|
*/
|
2011-07-03 11:26:43 +00:00
|
|
|
int drbd_wait_misc(struct drbd_device *device, struct drbd_interval *i)
|
2011-02-22 01:15:32 +00:00
|
|
|
{
|
2011-04-19 15:10:19 +00:00
|
|
|
struct net_conf *nc;
|
2011-02-22 01:15:32 +00:00
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
long timeout;
|
|
|
|
|
2011-04-19 15:10:19 +00:00
|
|
|
rcu_read_lock();
|
2011-05-31 12:33:49 +00:00
|
|
|
nc = rcu_dereference(first_peer_device(device)->connection->net_conf);
|
2011-04-19 15:10:19 +00:00
|
|
|
if (!nc) {
|
|
|
|
rcu_read_unlock();
|
2011-02-22 01:15:32 +00:00
|
|
|
return -ETIMEDOUT;
|
2011-04-19 15:10:19 +00:00
|
|
|
}
|
|
|
|
timeout = nc->ko_count ? nc->timeout * HZ / 10 * nc->ko_count : MAX_SCHEDULE_TIMEOUT;
|
|
|
|
rcu_read_unlock();
|
2011-02-22 01:15:32 +00:00
|
|
|
|
2011-07-03 11:26:43 +00:00
|
|
|
/* Indicate to wake up device->misc_wait on progress. */
|
2011-02-22 01:15:32 +00:00
|
|
|
i->waiting = true;
|
2011-07-03 11:26:43 +00:00
|
|
|
prepare_to_wait(&device->misc_wait, &wait, TASK_INTERRUPTIBLE);
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_unlock_irq(&device->resource->req_lock);
|
2011-02-22 01:15:32 +00:00
|
|
|
timeout = schedule_timeout(timeout);
|
2011-07-03 11:26:43 +00:00
|
|
|
finish_wait(&device->misc_wait, &wait);
|
2011-07-07 12:19:42 +00:00
|
|
|
spin_lock_irq(&device->resource->req_lock);
|
2011-07-03 11:26:43 +00:00
|
|
|
if (!timeout || device->state.conn < C_CONNECTED)
|
2011-02-22 01:15:32 +00:00
|
|
|
return -ETIMEDOUT;
|
|
|
|
if (signal_pending(current))
|
|
|
|
return -ERESTARTSYS;
|
|
|
|
return 0;
|
2009-09-25 23:07:19 +00:00
|
|
|
}
|
|
|
|
|
2014-08-14 16:33:30 +00:00
|
|
|
void lock_all_resources(void)
|
|
|
|
{
|
|
|
|
struct drbd_resource *resource;
|
|
|
|
int __maybe_unused i = 0;
|
|
|
|
|
|
|
|
mutex_lock(&resources_mutex);
|
|
|
|
local_irq_disable();
|
|
|
|
for_each_resource(resource, &drbd_resources)
|
|
|
|
spin_lock_nested(&resource->req_lock, i++);
|
|
|
|
}
|
|
|
|
|
|
|
|
void unlock_all_resources(void)
|
|
|
|
{
|
|
|
|
struct drbd_resource *resource;
|
|
|
|
|
|
|
|
for_each_resource(resource, &drbd_resources)
|
|
|
|
spin_unlock(&resource->req_lock);
|
|
|
|
local_irq_enable();
|
|
|
|
mutex_unlock(&resources_mutex);
|
|
|
|
}
|
|
|
|
|
2009-09-25 23:07:19 +00:00
|
|
|
#ifdef CONFIG_DRBD_FAULT_INJECTION
|
|
|
|
/* Fault insertion support including random number generator shamelessly
|
|
|
|
* stolen from kernel/rcutorture.c */
|
|
|
|
struct fault_random_state {
|
|
|
|
unsigned long state;
|
|
|
|
unsigned long count;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define FAULT_RANDOM_MULT 39916801 /* prime */
|
|
|
|
#define FAULT_RANDOM_ADD 479001701 /* prime */
|
|
|
|
#define FAULT_RANDOM_REFRESH 10000
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Crude but fast random-number generator. Uses a linear congruential
|
|
|
|
* generator, with occasional help from get_random_bytes().
|
|
|
|
*/
|
|
|
|
static unsigned long
|
|
|
|
_drbd_fault_random(struct fault_random_state *rsp)
|
|
|
|
{
|
|
|
|
long refresh;
|
|
|
|
|
2009-12-15 21:55:44 +00:00
|
|
|
if (!rsp->count--) {
|
2009-09-25 23:07:19 +00:00
|
|
|
get_random_bytes(&refresh, sizeof(refresh));
|
|
|
|
rsp->state += refresh;
|
|
|
|
rsp->count = FAULT_RANDOM_REFRESH;
|
|
|
|
}
|
|
|
|
rsp->state = rsp->state * FAULT_RANDOM_MULT + FAULT_RANDOM_ADD;
|
|
|
|
return swahw32(rsp->state);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_drbd_fault_str(unsigned int type) {
|
|
|
|
static char *_faults[] = {
|
|
|
|
[DRBD_FAULT_MD_WR] = "Meta-data write",
|
|
|
|
[DRBD_FAULT_MD_RD] = "Meta-data read",
|
|
|
|
[DRBD_FAULT_RS_WR] = "Resync write",
|
|
|
|
[DRBD_FAULT_RS_RD] = "Resync read",
|
|
|
|
[DRBD_FAULT_DT_WR] = "Data write",
|
|
|
|
[DRBD_FAULT_DT_RD] = "Data read",
|
|
|
|
[DRBD_FAULT_DT_RA] = "Data read ahead",
|
|
|
|
[DRBD_FAULT_BM_ALLOC] = "BM allocation",
|
2010-04-26 12:11:45 +00:00
|
|
|
[DRBD_FAULT_AL_EE] = "EE allocation",
|
|
|
|
[DRBD_FAULT_RECEIVE] = "receive data corruption",
|
2009-09-25 23:07:19 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
return (type < DRBD_FAULT_MAX) ? _faults[type] : "**Unknown**";
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int
|
2011-07-03 11:26:43 +00:00
|
|
|
_drbd_insert_fault(struct drbd_device *device, unsigned int type)
|
2009-09-25 23:07:19 +00:00
|
|
|
{
|
|
|
|
static struct fault_random_state rrs = {0, 0};
|
|
|
|
|
|
|
|
unsigned int ret = (
|
|
|
|
(fault_devs == 0 ||
|
2011-07-03 11:26:43 +00:00
|
|
|
((1 << device_to_minor(device)) & fault_devs) != 0) &&
|
2009-09-25 23:07:19 +00:00
|
|
|
(((_drbd_fault_random(&rrs) % 100) + 1) <= fault_rate));
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
fault_count++;
|
|
|
|
|
2010-05-27 09:51:56 +00:00
|
|
|
if (__ratelimit(&drbd_ratelimit_state))
|
2011-07-03 15:53:52 +00:00
|
|
|
drbd_warn(device, "***Simulating %s failure\n",
|
2009-09-25 23:07:19 +00:00
|
|
|
_drbd_fault_str(type));
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
const char *drbd_buildtag(void)
|
|
|
|
{
|
|
|
|
/* DRBD built from external sources has here a reference to the
|
|
|
|
git hash of the source code. */
|
|
|
|
|
|
|
|
static char buildtag[38] = "\0uilt-in";
|
|
|
|
|
|
|
|
if (buildtag[0] == 0) {
|
2012-04-03 06:13:36 +00:00
|
|
|
#ifdef MODULE
|
|
|
|
sprintf(buildtag, "srcversion: %-24s", THIS_MODULE->srcversion);
|
|
|
|
#else
|
|
|
|
buildtag[0] = 'b';
|
2009-09-25 23:07:19 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
return buildtag;
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(drbd_init)
|
|
|
|
module_exit(drbd_cleanup)
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(drbd_conn_str);
|
|
|
|
EXPORT_SYMBOL(drbd_role_str);
|
|
|
|
EXPORT_SYMBOL(drbd_disk_str);
|
|
|
|
EXPORT_SYMBOL(drbd_set_st_err_str);
|