1b411b363SPhilipp Reisner /* 2b411b363SPhilipp Reisner drbd_receiver.c 3b411b363SPhilipp Reisner 4b411b363SPhilipp Reisner This file is part of DRBD by Philipp Reisner and Lars Ellenberg. 5b411b363SPhilipp Reisner 6b411b363SPhilipp Reisner Copyright (C) 2001-2008, LINBIT Information Technologies GmbH. 7b411b363SPhilipp Reisner Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>. 8b411b363SPhilipp Reisner Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>. 9b411b363SPhilipp Reisner 10b411b363SPhilipp Reisner drbd is free software; you can redistribute it and/or modify 11b411b363SPhilipp Reisner it under the terms of the GNU General Public License as published by 12b411b363SPhilipp Reisner the Free Software Foundation; either version 2, or (at your option) 13b411b363SPhilipp Reisner any later version. 14b411b363SPhilipp Reisner 15b411b363SPhilipp Reisner drbd is distributed in the hope that it will be useful, 16b411b363SPhilipp Reisner but WITHOUT ANY WARRANTY; without even the implied warranty of 17b411b363SPhilipp Reisner MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18b411b363SPhilipp Reisner GNU General Public License for more details. 19b411b363SPhilipp Reisner 20b411b363SPhilipp Reisner You should have received a copy of the GNU General Public License 21b411b363SPhilipp Reisner along with drbd; see the file COPYING. If not, write to 22b411b363SPhilipp Reisner the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 23b411b363SPhilipp Reisner */ 24b411b363SPhilipp Reisner 25b411b363SPhilipp Reisner 26b411b363SPhilipp Reisner #include <linux/module.h> 27b411b363SPhilipp Reisner 28b411b363SPhilipp Reisner #include <asm/uaccess.h> 29b411b363SPhilipp Reisner #include <net/sock.h> 30b411b363SPhilipp Reisner 31b411b363SPhilipp Reisner #include <linux/drbd.h> 32b411b363SPhilipp Reisner #include <linux/fs.h> 33b411b363SPhilipp Reisner #include <linux/file.h> 34b411b363SPhilipp Reisner #include <linux/in.h> 35b411b363SPhilipp Reisner #include <linux/mm.h> 36b411b363SPhilipp Reisner #include <linux/memcontrol.h> 37b411b363SPhilipp Reisner #include <linux/mm_inline.h> 38b411b363SPhilipp Reisner #include <linux/slab.h> 39b411b363SPhilipp Reisner #include <linux/pkt_sched.h> 40b411b363SPhilipp Reisner #define __KERNEL_SYSCALLS__ 41b411b363SPhilipp Reisner #include <linux/unistd.h> 42b411b363SPhilipp Reisner #include <linux/vmalloc.h> 43b411b363SPhilipp Reisner #include <linux/random.h> 44b411b363SPhilipp Reisner #include <linux/string.h> 45b411b363SPhilipp Reisner #include <linux/scatterlist.h> 46b411b363SPhilipp Reisner #include "drbd_int.h" 47b411b363SPhilipp Reisner #include "drbd_req.h" 48b411b363SPhilipp Reisner 49b411b363SPhilipp Reisner #include "drbd_vli.h" 50b411b363SPhilipp Reisner 51b411b363SPhilipp Reisner enum finish_epoch { 52b411b363SPhilipp Reisner FE_STILL_LIVE, 53b411b363SPhilipp Reisner FE_DESTROYED, 54b411b363SPhilipp Reisner FE_RECYCLED, 55b411b363SPhilipp Reisner }; 56b411b363SPhilipp Reisner 57b411b363SPhilipp Reisner static int drbd_do_handshake(struct drbd_conf *mdev); 58b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev); 59b411b363SPhilipp Reisner 60b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event); 61b411b363SPhilipp Reisner static int e_end_block(struct drbd_conf *, struct drbd_work *, int); 62b411b363SPhilipp Reisner 63b411b363SPhilipp Reisner 64b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 65b411b363SPhilipp Reisner 6645bb912bSLars Ellenberg /* 6745bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 6845bb912bSLars Ellenberg * page->private being our "next" pointer. 6945bb912bSLars Ellenberg */ 7045bb912bSLars Ellenberg 7145bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 7245bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 7345bb912bSLars Ellenberg * Locking is the responsibility of the caller. 7445bb912bSLars Ellenberg */ 7545bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 7645bb912bSLars Ellenberg { 7745bb912bSLars Ellenberg struct page *page; 7845bb912bSLars Ellenberg struct page *tmp; 7945bb912bSLars Ellenberg 8045bb912bSLars Ellenberg BUG_ON(!n); 8145bb912bSLars Ellenberg BUG_ON(!head); 8245bb912bSLars Ellenberg 8345bb912bSLars Ellenberg page = *head; 8423ce4227SPhilipp Reisner 8523ce4227SPhilipp Reisner if (!page) 8623ce4227SPhilipp Reisner return NULL; 8723ce4227SPhilipp Reisner 8845bb912bSLars Ellenberg while (page) { 8945bb912bSLars Ellenberg tmp = page_chain_next(page); 9045bb912bSLars Ellenberg if (--n == 0) 9145bb912bSLars Ellenberg break; /* found sufficient pages */ 9245bb912bSLars Ellenberg if (tmp == NULL) 9345bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 9445bb912bSLars Ellenberg return NULL; 9545bb912bSLars Ellenberg page = tmp; 9645bb912bSLars Ellenberg } 9745bb912bSLars Ellenberg 9845bb912bSLars Ellenberg /* add end of list marker for the returned list */ 9945bb912bSLars Ellenberg set_page_private(page, 0); 10045bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 10145bb912bSLars Ellenberg page = *head; 10245bb912bSLars Ellenberg *head = tmp; 10345bb912bSLars Ellenberg return page; 10445bb912bSLars Ellenberg } 10545bb912bSLars Ellenberg 10645bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 10745bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 10845bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 10945bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 11045bb912bSLars Ellenberg { 11145bb912bSLars Ellenberg struct page *tmp; 11245bb912bSLars Ellenberg int i = 1; 11345bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 11445bb912bSLars Ellenberg ++i, page = tmp; 11545bb912bSLars Ellenberg if (len) 11645bb912bSLars Ellenberg *len = i; 11745bb912bSLars Ellenberg return page; 11845bb912bSLars Ellenberg } 11945bb912bSLars Ellenberg 12045bb912bSLars Ellenberg static int page_chain_free(struct page *page) 12145bb912bSLars Ellenberg { 12245bb912bSLars Ellenberg struct page *tmp; 12345bb912bSLars Ellenberg int i = 0; 12445bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 12545bb912bSLars Ellenberg put_page(page); 12645bb912bSLars Ellenberg ++i; 12745bb912bSLars Ellenberg } 12845bb912bSLars Ellenberg return i; 12945bb912bSLars Ellenberg } 13045bb912bSLars Ellenberg 13145bb912bSLars Ellenberg static void page_chain_add(struct page **head, 13245bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 13345bb912bSLars Ellenberg { 13445bb912bSLars Ellenberg #if 1 13545bb912bSLars Ellenberg struct page *tmp; 13645bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 13745bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 13845bb912bSLars Ellenberg #endif 13945bb912bSLars Ellenberg 14045bb912bSLars Ellenberg /* add chain to head */ 14145bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 14245bb912bSLars Ellenberg *head = chain_first; 14345bb912bSLars Ellenberg } 14445bb912bSLars Ellenberg 14545bb912bSLars Ellenberg static struct page *drbd_pp_first_pages_or_try_alloc(struct drbd_conf *mdev, int number) 146b411b363SPhilipp Reisner { 147b411b363SPhilipp Reisner struct page *page = NULL; 14845bb912bSLars Ellenberg struct page *tmp = NULL; 14945bb912bSLars Ellenberg int i = 0; 150b411b363SPhilipp Reisner 151b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 152b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 15345bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 154b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 15545bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 15645bb912bSLars Ellenberg if (page) 15745bb912bSLars Ellenberg drbd_pp_vacant -= number; 158b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 15945bb912bSLars Ellenberg if (page) 16045bb912bSLars Ellenberg return page; 161b411b363SPhilipp Reisner } 16245bb912bSLars Ellenberg 163b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 164b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 165b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 16645bb912bSLars Ellenberg for (i = 0; i < number; i++) { 16745bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 16845bb912bSLars Ellenberg if (!tmp) 16945bb912bSLars Ellenberg break; 17045bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 17145bb912bSLars Ellenberg page = tmp; 17245bb912bSLars Ellenberg } 17345bb912bSLars Ellenberg 17445bb912bSLars Ellenberg if (i == number) 175b411b363SPhilipp Reisner return page; 17645bb912bSLars Ellenberg 17745bb912bSLars Ellenberg /* Not enough pages immediately available this time. 17845bb912bSLars Ellenberg * No need to jump around here, drbd_pp_alloc will retry this 17945bb912bSLars Ellenberg * function "soon". */ 18045bb912bSLars Ellenberg if (page) { 18145bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 18245bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 18345bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 18445bb912bSLars Ellenberg drbd_pp_vacant += i; 18545bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 18645bb912bSLars Ellenberg } 18745bb912bSLars Ellenberg return NULL; 188b411b363SPhilipp Reisner } 189b411b363SPhilipp Reisner 190b411b363SPhilipp Reisner static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed) 191b411b363SPhilipp Reisner { 192db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 193b411b363SPhilipp Reisner struct list_head *le, *tle; 194b411b363SPhilipp Reisner 195b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 196b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 197b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 198b411b363SPhilipp Reisner stop to examine the list... */ 199b411b363SPhilipp Reisner 200b411b363SPhilipp Reisner list_for_each_safe(le, tle, &mdev->net_ee) { 201db830c46SAndreas Gruenbacher peer_req = list_entry(le, struct drbd_peer_request, w.list); 202db830c46SAndreas Gruenbacher if (drbd_ee_has_active_page(peer_req)) 203b411b363SPhilipp Reisner break; 204b411b363SPhilipp Reisner list_move(le, to_be_freed); 205b411b363SPhilipp Reisner } 206b411b363SPhilipp Reisner } 207b411b363SPhilipp Reisner 208b411b363SPhilipp Reisner static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev) 209b411b363SPhilipp Reisner { 210b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 211db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 212b411b363SPhilipp Reisner 21387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 214b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 21587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 216b411b363SPhilipp Reisner 217db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 218db830c46SAndreas Gruenbacher drbd_free_net_ee(mdev, peer_req); 219b411b363SPhilipp Reisner } 220b411b363SPhilipp Reisner 221b411b363SPhilipp Reisner /** 22245bb912bSLars Ellenberg * drbd_pp_alloc() - Returns @number pages, retries forever (or until signalled) 223b411b363SPhilipp Reisner * @mdev: DRBD device. 22445bb912bSLars Ellenberg * @number: number of pages requested 22545bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 226b411b363SPhilipp Reisner * 22745bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 22845bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 22945bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 23045bb912bSLars Ellenberg * 23145bb912bSLars Ellenberg * Returns a page chain linked via page->private. 232b411b363SPhilipp Reisner */ 23345bb912bSLars Ellenberg static struct page *drbd_pp_alloc(struct drbd_conf *mdev, unsigned number, bool retry) 234b411b363SPhilipp Reisner { 235b411b363SPhilipp Reisner struct page *page = NULL; 236b411b363SPhilipp Reisner DEFINE_WAIT(wait); 237b411b363SPhilipp Reisner 23845bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 23945bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 24089e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) 24145bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 242b411b363SPhilipp Reisner 24345bb912bSLars Ellenberg while (page == NULL) { 244b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 245b411b363SPhilipp Reisner 246b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 247b411b363SPhilipp Reisner 24889e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) { 24945bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 250b411b363SPhilipp Reisner if (page) 251b411b363SPhilipp Reisner break; 252b411b363SPhilipp Reisner } 253b411b363SPhilipp Reisner 254b411b363SPhilipp Reisner if (!retry) 255b411b363SPhilipp Reisner break; 256b411b363SPhilipp Reisner 257b411b363SPhilipp Reisner if (signal_pending(current)) { 258b411b363SPhilipp Reisner dev_warn(DEV, "drbd_pp_alloc interrupted!\n"); 259b411b363SPhilipp Reisner break; 260b411b363SPhilipp Reisner } 261b411b363SPhilipp Reisner 262b411b363SPhilipp Reisner schedule(); 263b411b363SPhilipp Reisner } 264b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 265b411b363SPhilipp Reisner 26645bb912bSLars Ellenberg if (page) 26745bb912bSLars Ellenberg atomic_add(number, &mdev->pp_in_use); 268b411b363SPhilipp Reisner return page; 269b411b363SPhilipp Reisner } 270b411b363SPhilipp Reisner 271b411b363SPhilipp Reisner /* Must not be used from irq, as that may deadlock: see drbd_pp_alloc. 27287eeee41SPhilipp Reisner * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock); 27345bb912bSLars Ellenberg * Either links the page chain back to the global pool, 27445bb912bSLars Ellenberg * or returns all pages to the system. */ 275435f0740SLars Ellenberg static void drbd_pp_free(struct drbd_conf *mdev, struct page *page, int is_net) 276b411b363SPhilipp Reisner { 277435f0740SLars Ellenberg atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use; 278b411b363SPhilipp Reisner int i; 279435f0740SLars Ellenberg 2801816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE)*minor_count) 28145bb912bSLars Ellenberg i = page_chain_free(page); 28245bb912bSLars Ellenberg else { 28345bb912bSLars Ellenberg struct page *tmp; 28445bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 285b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 28645bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 28745bb912bSLars Ellenberg drbd_pp_vacant += i; 288b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 289b411b363SPhilipp Reisner } 290435f0740SLars Ellenberg i = atomic_sub_return(i, a); 29145bb912bSLars Ellenberg if (i < 0) 292435f0740SLars Ellenberg dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n", 293435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 294b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 295b411b363SPhilipp Reisner } 296b411b363SPhilipp Reisner 297b411b363SPhilipp Reisner /* 298b411b363SPhilipp Reisner You need to hold the req_lock: 299b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 300b411b363SPhilipp Reisner 301b411b363SPhilipp Reisner You must not have the req_lock: 302b411b363SPhilipp Reisner drbd_free_ee() 303b411b363SPhilipp Reisner drbd_alloc_ee() 304b411b363SPhilipp Reisner drbd_init_ee() 305b411b363SPhilipp Reisner drbd_release_ee() 306b411b363SPhilipp Reisner drbd_ee_fix_bhs() 307b411b363SPhilipp Reisner drbd_process_done_ee() 308b411b363SPhilipp Reisner drbd_clear_done_ee() 309b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 310b411b363SPhilipp Reisner */ 311b411b363SPhilipp Reisner 312f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 313f6ffca9fSAndreas Gruenbacher drbd_alloc_ee(struct drbd_conf *mdev, u64 id, sector_t sector, 314f6ffca9fSAndreas Gruenbacher unsigned int data_size, gfp_t gfp_mask) __must_hold(local) 315b411b363SPhilipp Reisner { 316db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 317b411b363SPhilipp Reisner struct page *page; 31845bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 319b411b363SPhilipp Reisner 3200cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE)) 321b411b363SPhilipp Reisner return NULL; 322b411b363SPhilipp Reisner 323db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 324db830c46SAndreas Gruenbacher if (!peer_req) { 325b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 326b411b363SPhilipp Reisner dev_err(DEV, "alloc_ee: Allocation of an EE failed\n"); 327b411b363SPhilipp Reisner return NULL; 328b411b363SPhilipp Reisner } 329b411b363SPhilipp Reisner 33045bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT)); 33145bb912bSLars Ellenberg if (!page) 33245bb912bSLars Ellenberg goto fail; 333b411b363SPhilipp Reisner 334db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 335db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 336db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 337db830c46SAndreas Gruenbacher peer_req->i.local = false; 338db830c46SAndreas Gruenbacher peer_req->i.waiting = false; 33953840641SAndreas Gruenbacher 340db830c46SAndreas Gruenbacher peer_req->epoch = NULL; 341db830c46SAndreas Gruenbacher peer_req->mdev = mdev; 342db830c46SAndreas Gruenbacher peer_req->pages = page; 343db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, 0); 344db830c46SAndreas Gruenbacher peer_req->flags = 0; 3459a8e7753SAndreas Gruenbacher /* 3469a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3479a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3489a8e7753SAndreas Gruenbacher */ 349db830c46SAndreas Gruenbacher peer_req->block_id = id; 350b411b363SPhilipp Reisner 351db830c46SAndreas Gruenbacher return peer_req; 352b411b363SPhilipp Reisner 35345bb912bSLars Ellenberg fail: 354db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 355b411b363SPhilipp Reisner return NULL; 356b411b363SPhilipp Reisner } 357b411b363SPhilipp Reisner 358db830c46SAndreas Gruenbacher void drbd_free_some_ee(struct drbd_conf *mdev, struct drbd_peer_request *peer_req, 359f6ffca9fSAndreas Gruenbacher int is_net) 360b411b363SPhilipp Reisner { 361db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 362db830c46SAndreas Gruenbacher kfree(peer_req->digest); 363db830c46SAndreas Gruenbacher drbd_pp_free(mdev, peer_req->pages, is_net); 364db830c46SAndreas Gruenbacher D_ASSERT(atomic_read(&peer_req->pending_bios) == 0); 365db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 366db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 367b411b363SPhilipp Reisner } 368b411b363SPhilipp Reisner 369b411b363SPhilipp Reisner int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list) 370b411b363SPhilipp Reisner { 371b411b363SPhilipp Reisner LIST_HEAD(work_list); 372db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 373b411b363SPhilipp Reisner int count = 0; 374435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 375b411b363SPhilipp Reisner 37687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 377b411b363SPhilipp Reisner list_splice_init(list, &work_list); 37887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 379b411b363SPhilipp Reisner 380db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 381db830c46SAndreas Gruenbacher drbd_free_some_ee(mdev, peer_req, is_net); 382b411b363SPhilipp Reisner count++; 383b411b363SPhilipp Reisner } 384b411b363SPhilipp Reisner return count; 385b411b363SPhilipp Reisner } 386b411b363SPhilipp Reisner 387b411b363SPhilipp Reisner 388b411b363SPhilipp Reisner /* 389b411b363SPhilipp Reisner * This function is called from _asender only_ 3908554df1cSAndreas Gruenbacher * but see also comments in _req_mod(,BARRIER_ACKED) 391b411b363SPhilipp Reisner * and receive_Barrier. 392b411b363SPhilipp Reisner * 393b411b363SPhilipp Reisner * Move entries from net_ee to done_ee, if ready. 394b411b363SPhilipp Reisner * Grab done_ee, call all callbacks, free the entries. 395b411b363SPhilipp Reisner * The callbacks typically send out ACKs. 396b411b363SPhilipp Reisner */ 397b411b363SPhilipp Reisner static int drbd_process_done_ee(struct drbd_conf *mdev) 398b411b363SPhilipp Reisner { 399b411b363SPhilipp Reisner LIST_HEAD(work_list); 400b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 401db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 402b411b363SPhilipp Reisner int ok = (mdev->state.conn >= C_WF_REPORT_PARAMS); 403b411b363SPhilipp Reisner 40487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 405b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 406b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 40787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 408b411b363SPhilipp Reisner 409db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 410db830c46SAndreas Gruenbacher drbd_free_net_ee(mdev, peer_req); 411b411b363SPhilipp Reisner 412b411b363SPhilipp Reisner /* possible callbacks here: 413b411b363SPhilipp Reisner * e_end_block, and e_end_resync_block, e_send_discard_ack. 414b411b363SPhilipp Reisner * all ignore the last argument. 415b411b363SPhilipp Reisner */ 416db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 417b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 418db830c46SAndreas Gruenbacher ok = peer_req->w.cb(mdev, &peer_req->w, !ok) && ok; 419db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 420b411b363SPhilipp Reisner } 421b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 422b411b363SPhilipp Reisner 423b411b363SPhilipp Reisner return ok; 424b411b363SPhilipp Reisner } 425b411b363SPhilipp Reisner 426b411b363SPhilipp Reisner void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 427b411b363SPhilipp Reisner { 428b411b363SPhilipp Reisner DEFINE_WAIT(wait); 429b411b363SPhilipp Reisner 430b411b363SPhilipp Reisner /* avoids spin_lock/unlock 431b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 432b411b363SPhilipp Reisner while (!list_empty(head)) { 433b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 43487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4357eaceaccSJens Axboe io_schedule(); 436b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 43787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 438b411b363SPhilipp Reisner } 439b411b363SPhilipp Reisner } 440b411b363SPhilipp Reisner 441b411b363SPhilipp Reisner void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 442b411b363SPhilipp Reisner { 44387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 444b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 44587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 446b411b363SPhilipp Reisner } 447b411b363SPhilipp Reisner 448b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 449b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 4507653620dSPhilipp Reisner static int drbd_accept(const char **what, struct socket *sock, struct socket **newsock) 451b411b363SPhilipp Reisner { 452b411b363SPhilipp Reisner struct sock *sk = sock->sk; 453b411b363SPhilipp Reisner int err = 0; 454b411b363SPhilipp Reisner 455b411b363SPhilipp Reisner *what = "listen"; 456b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 457b411b363SPhilipp Reisner if (err < 0) 458b411b363SPhilipp Reisner goto out; 459b411b363SPhilipp Reisner 460b411b363SPhilipp Reisner *what = "sock_create_lite"; 461b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 462b411b363SPhilipp Reisner newsock); 463b411b363SPhilipp Reisner if (err < 0) 464b411b363SPhilipp Reisner goto out; 465b411b363SPhilipp Reisner 466b411b363SPhilipp Reisner *what = "accept"; 467b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 468b411b363SPhilipp Reisner if (err < 0) { 469b411b363SPhilipp Reisner sock_release(*newsock); 470b411b363SPhilipp Reisner *newsock = NULL; 471b411b363SPhilipp Reisner goto out; 472b411b363SPhilipp Reisner } 473b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 474b411b363SPhilipp Reisner 475b411b363SPhilipp Reisner out: 476b411b363SPhilipp Reisner return err; 477b411b363SPhilipp Reisner } 478b411b363SPhilipp Reisner 479b411b363SPhilipp Reisner static int drbd_recv_short(struct drbd_conf *mdev, struct socket *sock, 480b411b363SPhilipp Reisner void *buf, size_t size, int flags) 481b411b363SPhilipp Reisner { 482b411b363SPhilipp Reisner mm_segment_t oldfs; 483b411b363SPhilipp Reisner struct kvec iov = { 484b411b363SPhilipp Reisner .iov_base = buf, 485b411b363SPhilipp Reisner .iov_len = size, 486b411b363SPhilipp Reisner }; 487b411b363SPhilipp Reisner struct msghdr msg = { 488b411b363SPhilipp Reisner .msg_iovlen = 1, 489b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 490b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 491b411b363SPhilipp Reisner }; 492b411b363SPhilipp Reisner int rv; 493b411b363SPhilipp Reisner 494b411b363SPhilipp Reisner oldfs = get_fs(); 495b411b363SPhilipp Reisner set_fs(KERNEL_DS); 496b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 497b411b363SPhilipp Reisner set_fs(oldfs); 498b411b363SPhilipp Reisner 499b411b363SPhilipp Reisner return rv; 500b411b363SPhilipp Reisner } 501b411b363SPhilipp Reisner 502b411b363SPhilipp Reisner static int drbd_recv(struct drbd_conf *mdev, void *buf, size_t size) 503b411b363SPhilipp Reisner { 504b411b363SPhilipp Reisner mm_segment_t oldfs; 505b411b363SPhilipp Reisner struct kvec iov = { 506b411b363SPhilipp Reisner .iov_base = buf, 507b411b363SPhilipp Reisner .iov_len = size, 508b411b363SPhilipp Reisner }; 509b411b363SPhilipp Reisner struct msghdr msg = { 510b411b363SPhilipp Reisner .msg_iovlen = 1, 511b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 512b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 513b411b363SPhilipp Reisner }; 514b411b363SPhilipp Reisner int rv; 515b411b363SPhilipp Reisner 516b411b363SPhilipp Reisner oldfs = get_fs(); 517b411b363SPhilipp Reisner set_fs(KERNEL_DS); 518b411b363SPhilipp Reisner 519b411b363SPhilipp Reisner for (;;) { 520e42325a5SPhilipp Reisner rv = sock_recvmsg(mdev->tconn->data.socket, &msg, size, msg.msg_flags); 521b411b363SPhilipp Reisner if (rv == size) 522b411b363SPhilipp Reisner break; 523b411b363SPhilipp Reisner 524b411b363SPhilipp Reisner /* Note: 525b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 526b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 527b411b363SPhilipp Reisner */ 528b411b363SPhilipp Reisner 529b411b363SPhilipp Reisner if (rv < 0) { 530b411b363SPhilipp Reisner if (rv == -ECONNRESET) 531b411b363SPhilipp Reisner dev_info(DEV, "sock was reset by peer\n"); 532b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 533b411b363SPhilipp Reisner dev_err(DEV, "sock_recvmsg returned %d\n", rv); 534b411b363SPhilipp Reisner break; 535b411b363SPhilipp Reisner } else if (rv == 0) { 536b411b363SPhilipp Reisner dev_info(DEV, "sock was shut down by peer\n"); 537b411b363SPhilipp Reisner break; 538b411b363SPhilipp Reisner } else { 539b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 540b411b363SPhilipp Reisner * after we read a partial message 541b411b363SPhilipp Reisner */ 542b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 543b411b363SPhilipp Reisner break; 544b411b363SPhilipp Reisner } 545b411b363SPhilipp Reisner }; 546b411b363SPhilipp Reisner 547b411b363SPhilipp Reisner set_fs(oldfs); 548b411b363SPhilipp Reisner 549b411b363SPhilipp Reisner if (rv != size) 550b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_BROKEN_PIPE)); 551b411b363SPhilipp Reisner 552b411b363SPhilipp Reisner return rv; 553b411b363SPhilipp Reisner } 554b411b363SPhilipp Reisner 5555dbf1673SLars Ellenberg /* quoting tcp(7): 5565dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5575dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5585dbf1673SLars Ellenberg * This is our wrapper to do so. 5595dbf1673SLars Ellenberg */ 5605dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5615dbf1673SLars Ellenberg unsigned int rcv) 5625dbf1673SLars Ellenberg { 5635dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5645dbf1673SLars Ellenberg if (snd) { 5655dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5665dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5675dbf1673SLars Ellenberg } 5685dbf1673SLars Ellenberg if (rcv) { 5695dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5705dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5715dbf1673SLars Ellenberg } 5725dbf1673SLars Ellenberg } 5735dbf1673SLars Ellenberg 574eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 575b411b363SPhilipp Reisner { 576b411b363SPhilipp Reisner const char *what; 577b411b363SPhilipp Reisner struct socket *sock; 578b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 579b411b363SPhilipp Reisner int err; 580b411b363SPhilipp Reisner int disconnect_on_error = 1; 581b411b363SPhilipp Reisner 582eac3e990SPhilipp Reisner if (!get_net_conf(tconn)) 583b411b363SPhilipp Reisner return NULL; 584b411b363SPhilipp Reisner 585b411b363SPhilipp Reisner what = "sock_create_kern"; 586eac3e990SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 587b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 588b411b363SPhilipp Reisner if (err < 0) { 589b411b363SPhilipp Reisner sock = NULL; 590b411b363SPhilipp Reisner goto out; 591b411b363SPhilipp Reisner } 592b411b363SPhilipp Reisner 593b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 594eac3e990SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->try_connect_int*HZ; 595eac3e990SPhilipp Reisner drbd_setbufsize(sock, tconn->net_conf->sndbuf_size, 596eac3e990SPhilipp Reisner tconn->net_conf->rcvbuf_size); 597b411b363SPhilipp Reisner 598b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 599b411b363SPhilipp Reisner * for the outgoing connections. 600b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 601b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 602b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 603b411b363SPhilipp Reisner * a free one dynamically. 604b411b363SPhilipp Reisner */ 605eac3e990SPhilipp Reisner memcpy(&src_in6, tconn->net_conf->my_addr, 606eac3e990SPhilipp Reisner min_t(int, tconn->net_conf->my_addr_len, sizeof(src_in6))); 607eac3e990SPhilipp Reisner if (((struct sockaddr *)tconn->net_conf->my_addr)->sa_family == AF_INET6) 608b411b363SPhilipp Reisner src_in6.sin6_port = 0; 609b411b363SPhilipp Reisner else 610b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 611b411b363SPhilipp Reisner 612b411b363SPhilipp Reisner what = "bind before connect"; 613b411b363SPhilipp Reisner err = sock->ops->bind(sock, 614b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 615eac3e990SPhilipp Reisner tconn->net_conf->my_addr_len); 616b411b363SPhilipp Reisner if (err < 0) 617b411b363SPhilipp Reisner goto out; 618b411b363SPhilipp Reisner 619b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 620b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 621b411b363SPhilipp Reisner disconnect_on_error = 0; 622b411b363SPhilipp Reisner what = "connect"; 623b411b363SPhilipp Reisner err = sock->ops->connect(sock, 624eac3e990SPhilipp Reisner (struct sockaddr *)tconn->net_conf->peer_addr, 625eac3e990SPhilipp Reisner tconn->net_conf->peer_addr_len, 0); 626b411b363SPhilipp Reisner 627b411b363SPhilipp Reisner out: 628b411b363SPhilipp Reisner if (err < 0) { 629b411b363SPhilipp Reisner if (sock) { 630b411b363SPhilipp Reisner sock_release(sock); 631b411b363SPhilipp Reisner sock = NULL; 632b411b363SPhilipp Reisner } 633b411b363SPhilipp Reisner switch (-err) { 634b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 635b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 636b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 637b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 638b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 639b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 640b411b363SPhilipp Reisner disconnect_on_error = 0; 641b411b363SPhilipp Reisner break; 642b411b363SPhilipp Reisner default: 643eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 644b411b363SPhilipp Reisner } 645b411b363SPhilipp Reisner if (disconnect_on_error) 646eac3e990SPhilipp Reisner drbd_force_state(tconn->volume0, NS(conn, C_DISCONNECTING)); 647b411b363SPhilipp Reisner } 648eac3e990SPhilipp Reisner put_net_conf(tconn); 649b411b363SPhilipp Reisner return sock; 650b411b363SPhilipp Reisner } 651b411b363SPhilipp Reisner 6527653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 653b411b363SPhilipp Reisner { 654b411b363SPhilipp Reisner int timeo, err; 655b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 656b411b363SPhilipp Reisner const char *what; 657b411b363SPhilipp Reisner 6587653620dSPhilipp Reisner if (!get_net_conf(tconn)) 659b411b363SPhilipp Reisner return NULL; 660b411b363SPhilipp Reisner 661b411b363SPhilipp Reisner what = "sock_create_kern"; 6627653620dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 663b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 664b411b363SPhilipp Reisner if (err) { 665b411b363SPhilipp Reisner s_listen = NULL; 666b411b363SPhilipp Reisner goto out; 667b411b363SPhilipp Reisner } 668b411b363SPhilipp Reisner 6697653620dSPhilipp Reisner timeo = tconn->net_conf->try_connect_int * HZ; 670b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 671b411b363SPhilipp Reisner 672b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 673b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 674b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 6757653620dSPhilipp Reisner drbd_setbufsize(s_listen, tconn->net_conf->sndbuf_size, 6767653620dSPhilipp Reisner tconn->net_conf->rcvbuf_size); 677b411b363SPhilipp Reisner 678b411b363SPhilipp Reisner what = "bind before listen"; 679b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 6807653620dSPhilipp Reisner (struct sockaddr *) tconn->net_conf->my_addr, 6817653620dSPhilipp Reisner tconn->net_conf->my_addr_len); 682b411b363SPhilipp Reisner if (err < 0) 683b411b363SPhilipp Reisner goto out; 684b411b363SPhilipp Reisner 6857653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 686b411b363SPhilipp Reisner 687b411b363SPhilipp Reisner out: 688b411b363SPhilipp Reisner if (s_listen) 689b411b363SPhilipp Reisner sock_release(s_listen); 690b411b363SPhilipp Reisner if (err < 0) { 691b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 6927653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 6937653620dSPhilipp Reisner drbd_force_state(tconn->volume0, NS(conn, C_DISCONNECTING)); 694b411b363SPhilipp Reisner } 695b411b363SPhilipp Reisner } 6967653620dSPhilipp Reisner put_net_conf(tconn); 697b411b363SPhilipp Reisner 698b411b363SPhilipp Reisner return s_estab; 699b411b363SPhilipp Reisner } 700b411b363SPhilipp Reisner 701d8763023SAndreas Gruenbacher static int drbd_send_fp(struct drbd_conf *mdev, struct socket *sock, 702d8763023SAndreas Gruenbacher enum drbd_packet cmd) 703b411b363SPhilipp Reisner { 704c012949aSPhilipp Reisner struct p_header *h = &mdev->tconn->data.sbuf.header; 705b411b363SPhilipp Reisner 706b411b363SPhilipp Reisner return _drbd_send_cmd(mdev, sock, cmd, h, sizeof(*h), 0); 707b411b363SPhilipp Reisner } 708b411b363SPhilipp Reisner 709d8763023SAndreas Gruenbacher static enum drbd_packet drbd_recv_fp(struct drbd_conf *mdev, 710d8763023SAndreas Gruenbacher struct socket *sock) 711b411b363SPhilipp Reisner { 712e42325a5SPhilipp Reisner struct p_header80 *h = &mdev->tconn->data.rbuf.header.h80; 713b411b363SPhilipp Reisner int rr; 714b411b363SPhilipp Reisner 715b411b363SPhilipp Reisner rr = drbd_recv_short(mdev, sock, h, sizeof(*h), 0); 716b411b363SPhilipp Reisner 717ca9bc12bSAndreas Gruenbacher if (rr == sizeof(*h) && h->magic == cpu_to_be32(DRBD_MAGIC)) 718b411b363SPhilipp Reisner return be16_to_cpu(h->command); 719b411b363SPhilipp Reisner 720b411b363SPhilipp Reisner return 0xffff; 721b411b363SPhilipp Reisner } 722b411b363SPhilipp Reisner 723b411b363SPhilipp Reisner /** 724b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 725b411b363SPhilipp Reisner * @mdev: DRBD device. 726b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 727b411b363SPhilipp Reisner */ 728b411b363SPhilipp Reisner static int drbd_socket_okay(struct drbd_conf *mdev, struct socket **sock) 729b411b363SPhilipp Reisner { 730b411b363SPhilipp Reisner int rr; 731b411b363SPhilipp Reisner char tb[4]; 732b411b363SPhilipp Reisner 733b411b363SPhilipp Reisner if (!*sock) 73481e84650SAndreas Gruenbacher return false; 735b411b363SPhilipp Reisner 736b411b363SPhilipp Reisner rr = drbd_recv_short(mdev, *sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 737b411b363SPhilipp Reisner 738b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 73981e84650SAndreas Gruenbacher return true; 740b411b363SPhilipp Reisner } else { 741b411b363SPhilipp Reisner sock_release(*sock); 742b411b363SPhilipp Reisner *sock = NULL; 74381e84650SAndreas Gruenbacher return false; 744b411b363SPhilipp Reisner } 745b411b363SPhilipp Reisner } 746b411b363SPhilipp Reisner 747b411b363SPhilipp Reisner /* 748b411b363SPhilipp Reisner * return values: 749b411b363SPhilipp Reisner * 1 yes, we have a valid connection 750b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 751b411b363SPhilipp Reisner * -1 peer talks different language, 752b411b363SPhilipp Reisner * no point in trying again, please go standalone. 753b411b363SPhilipp Reisner * -2 We do not have a network config... 754b411b363SPhilipp Reisner */ 755b411b363SPhilipp Reisner static int drbd_connect(struct drbd_conf *mdev) 756b411b363SPhilipp Reisner { 757b411b363SPhilipp Reisner struct socket *s, *sock, *msock; 758b411b363SPhilipp Reisner int try, h, ok; 759b411b363SPhilipp Reisner 760e42325a5SPhilipp Reisner D_ASSERT(!mdev->tconn->data.socket); 761b411b363SPhilipp Reisner 762b411b363SPhilipp Reisner if (drbd_request_state(mdev, NS(conn, C_WF_CONNECTION)) < SS_SUCCESS) 763b411b363SPhilipp Reisner return -2; 764b411b363SPhilipp Reisner 76525703f83SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 766fd340c12SPhilipp Reisner mdev->tconn->agreed_pro_version = 99; 767fd340c12SPhilipp Reisner /* agreed_pro_version must be smaller than 100 so we send the old 768fd340c12SPhilipp Reisner header (h80) in the first packet and in the handshake packet. */ 769b411b363SPhilipp Reisner 770b411b363SPhilipp Reisner sock = NULL; 771b411b363SPhilipp Reisner msock = NULL; 772b411b363SPhilipp Reisner 773b411b363SPhilipp Reisner do { 774b411b363SPhilipp Reisner for (try = 0;;) { 775b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 776eac3e990SPhilipp Reisner s = drbd_try_connect(mdev->tconn); 777b411b363SPhilipp Reisner if (s || ++try >= 3) 778b411b363SPhilipp Reisner break; 779b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 78020ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 781b411b363SPhilipp Reisner } 782b411b363SPhilipp Reisner 783b411b363SPhilipp Reisner if (s) { 784b411b363SPhilipp Reisner if (!sock) { 785b411b363SPhilipp Reisner drbd_send_fp(mdev, s, P_HAND_SHAKE_S); 786b411b363SPhilipp Reisner sock = s; 787b411b363SPhilipp Reisner s = NULL; 788b411b363SPhilipp Reisner } else if (!msock) { 789b411b363SPhilipp Reisner drbd_send_fp(mdev, s, P_HAND_SHAKE_M); 790b411b363SPhilipp Reisner msock = s; 791b411b363SPhilipp Reisner s = NULL; 792b411b363SPhilipp Reisner } else { 793b411b363SPhilipp Reisner dev_err(DEV, "Logic error in drbd_connect()\n"); 794b411b363SPhilipp Reisner goto out_release_sockets; 795b411b363SPhilipp Reisner } 796b411b363SPhilipp Reisner } 797b411b363SPhilipp Reisner 798b411b363SPhilipp Reisner if (sock && msock) { 79989e58e75SPhilipp Reisner schedule_timeout_interruptible(mdev->tconn->net_conf->ping_timeo*HZ/10); 800b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &sock); 801b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &msock) && ok; 802b411b363SPhilipp Reisner if (ok) 803b411b363SPhilipp Reisner break; 804b411b363SPhilipp Reisner } 805b411b363SPhilipp Reisner 806b411b363SPhilipp Reisner retry: 8077653620dSPhilipp Reisner s = drbd_wait_for_connect(mdev->tconn); 808b411b363SPhilipp Reisner if (s) { 809b411b363SPhilipp Reisner try = drbd_recv_fp(mdev, s); 810b411b363SPhilipp Reisner drbd_socket_okay(mdev, &sock); 811b411b363SPhilipp Reisner drbd_socket_okay(mdev, &msock); 812b411b363SPhilipp Reisner switch (try) { 813b411b363SPhilipp Reisner case P_HAND_SHAKE_S: 814b411b363SPhilipp Reisner if (sock) { 815b411b363SPhilipp Reisner dev_warn(DEV, "initial packet S crossed\n"); 816b411b363SPhilipp Reisner sock_release(sock); 817b411b363SPhilipp Reisner } 818b411b363SPhilipp Reisner sock = s; 819b411b363SPhilipp Reisner break; 820b411b363SPhilipp Reisner case P_HAND_SHAKE_M: 821b411b363SPhilipp Reisner if (msock) { 822b411b363SPhilipp Reisner dev_warn(DEV, "initial packet M crossed\n"); 823b411b363SPhilipp Reisner sock_release(msock); 824b411b363SPhilipp Reisner } 825b411b363SPhilipp Reisner msock = s; 82625703f83SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 827b411b363SPhilipp Reisner break; 828b411b363SPhilipp Reisner default: 829b411b363SPhilipp Reisner dev_warn(DEV, "Error receiving initial packet\n"); 830b411b363SPhilipp Reisner sock_release(s); 831b411b363SPhilipp Reisner if (random32() & 1) 832b411b363SPhilipp Reisner goto retry; 833b411b363SPhilipp Reisner } 834b411b363SPhilipp Reisner } 835b411b363SPhilipp Reisner 836b411b363SPhilipp Reisner if (mdev->state.conn <= C_DISCONNECTING) 837b411b363SPhilipp Reisner goto out_release_sockets; 838b411b363SPhilipp Reisner if (signal_pending(current)) { 839b411b363SPhilipp Reisner flush_signals(current); 840b411b363SPhilipp Reisner smp_rmb(); 841e6b3ea83SPhilipp Reisner if (get_t_state(&mdev->tconn->receiver) == EXITING) 842b411b363SPhilipp Reisner goto out_release_sockets; 843b411b363SPhilipp Reisner } 844b411b363SPhilipp Reisner 845b411b363SPhilipp Reisner if (sock && msock) { 846b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &sock); 847b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &msock) && ok; 848b411b363SPhilipp Reisner if (ok) 849b411b363SPhilipp Reisner break; 850b411b363SPhilipp Reisner } 851b411b363SPhilipp Reisner } while (1); 852b411b363SPhilipp Reisner 853b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 854b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 855b411b363SPhilipp Reisner 856b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 857b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 858b411b363SPhilipp Reisner 859b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 860b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 861b411b363SPhilipp Reisner 862b411b363SPhilipp Reisner /* NOT YET ... 86389e58e75SPhilipp Reisner * sock->sk->sk_sndtimeo = mdev->tconn->net_conf->timeout*HZ/10; 864b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 865b411b363SPhilipp Reisner * first set it to the P_HAND_SHAKE timeout, 866b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 867b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 86889e58e75SPhilipp Reisner sock->sk->sk_rcvtimeo = mdev->tconn->net_conf->ping_timeo*4*HZ/10; 869b411b363SPhilipp Reisner 87089e58e75SPhilipp Reisner msock->sk->sk_sndtimeo = mdev->tconn->net_conf->timeout*HZ/10; 87189e58e75SPhilipp Reisner msock->sk->sk_rcvtimeo = mdev->tconn->net_conf->ping_int*HZ; 872b411b363SPhilipp Reisner 873b411b363SPhilipp Reisner /* we don't want delays. 87425985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 875b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 876b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 877b411b363SPhilipp Reisner 878e42325a5SPhilipp Reisner mdev->tconn->data.socket = sock; 879e42325a5SPhilipp Reisner mdev->tconn->meta.socket = msock; 88031890f4aSPhilipp Reisner mdev->tconn->last_received = jiffies; 881b411b363SPhilipp Reisner 882e6b3ea83SPhilipp Reisner D_ASSERT(mdev->tconn->asender.task == NULL); 883b411b363SPhilipp Reisner 884b411b363SPhilipp Reisner h = drbd_do_handshake(mdev); 885b411b363SPhilipp Reisner if (h <= 0) 886b411b363SPhilipp Reisner return h; 887b411b363SPhilipp Reisner 888a0638456SPhilipp Reisner if (mdev->tconn->cram_hmac_tfm) { 889b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 890b10d96cbSJohannes Thoma switch (drbd_do_auth(mdev)) { 891b10d96cbSJohannes Thoma case -1: 892b411b363SPhilipp Reisner dev_err(DEV, "Authentication of peer failed\n"); 893b411b363SPhilipp Reisner return -1; 894b10d96cbSJohannes Thoma case 0: 895b10d96cbSJohannes Thoma dev_err(DEV, "Authentication of peer failed, trying again.\n"); 896b10d96cbSJohannes Thoma return 0; 897b411b363SPhilipp Reisner } 898b411b363SPhilipp Reisner } 899b411b363SPhilipp Reisner 900b411b363SPhilipp Reisner if (drbd_request_state(mdev, NS(conn, C_WF_REPORT_PARAMS)) < SS_SUCCESS) 901b411b363SPhilipp Reisner return 0; 902b411b363SPhilipp Reisner 90389e58e75SPhilipp Reisner sock->sk->sk_sndtimeo = mdev->tconn->net_conf->timeout*HZ/10; 904b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 905b411b363SPhilipp Reisner 906b411b363SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 907b411b363SPhilipp Reisner mdev->peer_seq = 0; 908b411b363SPhilipp Reisner 909e6b3ea83SPhilipp Reisner drbd_thread_start(&mdev->tconn->asender); 910b411b363SPhilipp Reisner 911148efa16SPhilipp Reisner if (drbd_send_protocol(mdev) == -1) 9127e2455c1SPhilipp Reisner return -1; 913b411b363SPhilipp Reisner drbd_send_sync_param(mdev, &mdev->sync_conf); 914e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, 0); 915b411b363SPhilipp Reisner drbd_send_uuids(mdev); 916b411b363SPhilipp Reisner drbd_send_state(mdev); 917b411b363SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 918b411b363SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 9197fde2be9SPhilipp Reisner mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */ 920b411b363SPhilipp Reisner 921b411b363SPhilipp Reisner return 1; 922b411b363SPhilipp Reisner 923b411b363SPhilipp Reisner out_release_sockets: 924b411b363SPhilipp Reisner if (sock) 925b411b363SPhilipp Reisner sock_release(sock); 926b411b363SPhilipp Reisner if (msock) 927b411b363SPhilipp Reisner sock_release(msock); 928b411b363SPhilipp Reisner return -1; 929b411b363SPhilipp Reisner } 930b411b363SPhilipp Reisner 931d8763023SAndreas Gruenbacher static bool decode_header(struct drbd_conf *mdev, struct p_header *h, 932d8763023SAndreas Gruenbacher enum drbd_packet *cmd, unsigned int *packet_size) 933b411b363SPhilipp Reisner { 934fd340c12SPhilipp Reisner if (h->h80.magic == cpu_to_be32(DRBD_MAGIC)) { 93502918be2SPhilipp Reisner *cmd = be16_to_cpu(h->h80.command); 93602918be2SPhilipp Reisner *packet_size = be16_to_cpu(h->h80.length); 937ca9bc12bSAndreas Gruenbacher } else if (h->h95.magic == cpu_to_be16(DRBD_MAGIC_BIG)) { 93802918be2SPhilipp Reisner *cmd = be16_to_cpu(h->h95.command); 939fd340c12SPhilipp Reisner *packet_size = be32_to_cpu(h->h95.length) & 0x00ffffff; 94002918be2SPhilipp Reisner } else { 941004352faSLars Ellenberg dev_err(DEV, "magic?? on data m: 0x%08x c: %d l: %d\n", 942004352faSLars Ellenberg be32_to_cpu(h->h80.magic), 943004352faSLars Ellenberg be16_to_cpu(h->h80.command), 944004352faSLars Ellenberg be16_to_cpu(h->h80.length)); 94581e84650SAndreas Gruenbacher return false; 946b411b363SPhilipp Reisner } 947257d0af6SPhilipp Reisner return true; 948257d0af6SPhilipp Reisner } 949257d0af6SPhilipp Reisner 950d8763023SAndreas Gruenbacher static int drbd_recv_header(struct drbd_conf *mdev, enum drbd_packet *cmd, 951d8763023SAndreas Gruenbacher unsigned int *packet_size) 952257d0af6SPhilipp Reisner { 953257d0af6SPhilipp Reisner struct p_header *h = &mdev->tconn->data.rbuf.header; 954257d0af6SPhilipp Reisner int r; 955257d0af6SPhilipp Reisner 956257d0af6SPhilipp Reisner r = drbd_recv(mdev, h, sizeof(*h)); 957257d0af6SPhilipp Reisner if (unlikely(r != sizeof(*h))) { 958257d0af6SPhilipp Reisner if (!signal_pending(current)) 959257d0af6SPhilipp Reisner dev_warn(DEV, "short read expecting header on sock: r=%d\n", r); 960257d0af6SPhilipp Reisner return false; 961257d0af6SPhilipp Reisner } 962257d0af6SPhilipp Reisner 963257d0af6SPhilipp Reisner r = decode_header(mdev, h, cmd, packet_size); 96431890f4aSPhilipp Reisner mdev->tconn->last_received = jiffies; 965b411b363SPhilipp Reisner 966257d0af6SPhilipp Reisner return r; 967b411b363SPhilipp Reisner } 968b411b363SPhilipp Reisner 9692451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 970b411b363SPhilipp Reisner { 971b411b363SPhilipp Reisner int rv; 972b411b363SPhilipp Reisner 973b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 974fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 975dd3932edSChristoph Hellwig NULL); 976b411b363SPhilipp Reisner if (rv) { 977b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 978b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 979b411b363SPhilipp Reisner * don't try again for ANY return value != 0 980b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 981b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 982b411b363SPhilipp Reisner } 983b411b363SPhilipp Reisner put_ldev(mdev); 984b411b363SPhilipp Reisner } 985b411b363SPhilipp Reisner } 986b411b363SPhilipp Reisner 987b411b363SPhilipp Reisner /** 988b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 989b411b363SPhilipp Reisner * @mdev: DRBD device. 990b411b363SPhilipp Reisner * @epoch: Epoch object. 991b411b363SPhilipp Reisner * @ev: Epoch event. 992b411b363SPhilipp Reisner */ 993b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 994b411b363SPhilipp Reisner struct drbd_epoch *epoch, 995b411b363SPhilipp Reisner enum epoch_event ev) 996b411b363SPhilipp Reisner { 9972451fc3bSPhilipp Reisner int epoch_size; 998b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 999b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1000b411b363SPhilipp Reisner 1001b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1002b411b363SPhilipp Reisner do { 1003b411b363SPhilipp Reisner next_epoch = NULL; 1004b411b363SPhilipp Reisner 1005b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1006b411b363SPhilipp Reisner 1007b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1008b411b363SPhilipp Reisner case EV_PUT: 1009b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1010b411b363SPhilipp Reisner break; 1011b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1012b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1013b411b363SPhilipp Reisner break; 1014b411b363SPhilipp Reisner case EV_BECAME_LAST: 1015b411b363SPhilipp Reisner /* nothing to do*/ 1016b411b363SPhilipp Reisner break; 1017b411b363SPhilipp Reisner } 1018b411b363SPhilipp Reisner 1019b411b363SPhilipp Reisner if (epoch_size != 0 && 1020b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 10212451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1022b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1023b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1024b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1025b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1026b411b363SPhilipp Reisner } 1027b411b363SPhilipp Reisner dec_unacked(mdev); 1028b411b363SPhilipp Reisner 1029b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1030b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1031b411b363SPhilipp Reisner list_del(&epoch->list); 1032b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1033b411b363SPhilipp Reisner mdev->epochs--; 1034b411b363SPhilipp Reisner kfree(epoch); 1035b411b363SPhilipp Reisner 1036b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1037b411b363SPhilipp Reisner rv = FE_DESTROYED; 1038b411b363SPhilipp Reisner } else { 1039b411b363SPhilipp Reisner epoch->flags = 0; 1040b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1041698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1042b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1043b411b363SPhilipp Reisner rv = FE_RECYCLED; 10442451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1045b411b363SPhilipp Reisner } 1046b411b363SPhilipp Reisner } 1047b411b363SPhilipp Reisner 1048b411b363SPhilipp Reisner if (!next_epoch) 1049b411b363SPhilipp Reisner break; 1050b411b363SPhilipp Reisner 1051b411b363SPhilipp Reisner epoch = next_epoch; 1052b411b363SPhilipp Reisner } while (1); 1053b411b363SPhilipp Reisner 1054b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1055b411b363SPhilipp Reisner 1056b411b363SPhilipp Reisner return rv; 1057b411b363SPhilipp Reisner } 1058b411b363SPhilipp Reisner 1059b411b363SPhilipp Reisner /** 1060b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1061b411b363SPhilipp Reisner * @mdev: DRBD device. 1062b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1063b411b363SPhilipp Reisner */ 1064b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1065b411b363SPhilipp Reisner { 1066b411b363SPhilipp Reisner enum write_ordering_e pwo; 1067b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1068b411b363SPhilipp Reisner [WO_none] = "none", 1069b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1070b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1071b411b363SPhilipp Reisner }; 1072b411b363SPhilipp Reisner 1073b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1074b411b363SPhilipp Reisner wo = min(pwo, wo); 1075b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1076b411b363SPhilipp Reisner wo = WO_drain_io; 1077b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1078b411b363SPhilipp Reisner wo = WO_none; 1079b411b363SPhilipp Reisner mdev->write_ordering = wo; 10802451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1081b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1082b411b363SPhilipp Reisner } 1083b411b363SPhilipp Reisner 1084b411b363SPhilipp Reisner /** 108545bb912bSLars Ellenberg * drbd_submit_ee() 108645bb912bSLars Ellenberg * @mdev: DRBD device. 1087db830c46SAndreas Gruenbacher * @peer_req: peer request 108845bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 108910f6d992SLars Ellenberg * 109010f6d992SLars Ellenberg * May spread the pages to multiple bios, 109110f6d992SLars Ellenberg * depending on bio_add_page restrictions. 109210f6d992SLars Ellenberg * 109310f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 109410f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 109510f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 109610f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 109710f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 109810f6d992SLars Ellenberg * on certain Xen deployments. 109945bb912bSLars Ellenberg */ 110045bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1101db830c46SAndreas Gruenbacher int drbd_submit_ee(struct drbd_conf *mdev, struct drbd_peer_request *peer_req, 110245bb912bSLars Ellenberg const unsigned rw, const int fault_type) 110345bb912bSLars Ellenberg { 110445bb912bSLars Ellenberg struct bio *bios = NULL; 110545bb912bSLars Ellenberg struct bio *bio; 1106db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1107db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1108db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 110945bb912bSLars Ellenberg unsigned n_bios = 0; 111045bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 111110f6d992SLars Ellenberg int err = -ENOMEM; 111245bb912bSLars Ellenberg 111345bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 111445bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 111545bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 111645bb912bSLars Ellenberg * request in more than one bio. */ 111745bb912bSLars Ellenberg next_bio: 111845bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 111945bb912bSLars Ellenberg if (!bio) { 112045bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 112145bb912bSLars Ellenberg goto fail; 112245bb912bSLars Ellenberg } 1123db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 112445bb912bSLars Ellenberg bio->bi_sector = sector; 112545bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 112645bb912bSLars Ellenberg bio->bi_rw = rw; 1127db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 112845bb912bSLars Ellenberg bio->bi_end_io = drbd_endio_sec; 112945bb912bSLars Ellenberg 113045bb912bSLars Ellenberg bio->bi_next = bios; 113145bb912bSLars Ellenberg bios = bio; 113245bb912bSLars Ellenberg ++n_bios; 113345bb912bSLars Ellenberg 113445bb912bSLars Ellenberg page_chain_for_each(page) { 113545bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 113645bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 113710f6d992SLars Ellenberg /* A single page must always be possible! 113810f6d992SLars Ellenberg * But in case it fails anyways, 113910f6d992SLars Ellenberg * we deal with it, and complain (below). */ 114010f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 114110f6d992SLars Ellenberg dev_err(DEV, 114210f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 114310f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 114410f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 114510f6d992SLars Ellenberg err = -ENOSPC; 114610f6d992SLars Ellenberg goto fail; 114710f6d992SLars Ellenberg } 114845bb912bSLars Ellenberg goto next_bio; 114945bb912bSLars Ellenberg } 115045bb912bSLars Ellenberg ds -= len; 115145bb912bSLars Ellenberg sector += len >> 9; 115245bb912bSLars Ellenberg --nr_pages; 115345bb912bSLars Ellenberg } 115445bb912bSLars Ellenberg D_ASSERT(page == NULL); 115545bb912bSLars Ellenberg D_ASSERT(ds == 0); 115645bb912bSLars Ellenberg 1157db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 115845bb912bSLars Ellenberg do { 115945bb912bSLars Ellenberg bio = bios; 116045bb912bSLars Ellenberg bios = bios->bi_next; 116145bb912bSLars Ellenberg bio->bi_next = NULL; 116245bb912bSLars Ellenberg 116345bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 116445bb912bSLars Ellenberg } while (bios); 116545bb912bSLars Ellenberg return 0; 116645bb912bSLars Ellenberg 116745bb912bSLars Ellenberg fail: 116845bb912bSLars Ellenberg while (bios) { 116945bb912bSLars Ellenberg bio = bios; 117045bb912bSLars Ellenberg bios = bios->bi_next; 117145bb912bSLars Ellenberg bio_put(bio); 117245bb912bSLars Ellenberg } 117310f6d992SLars Ellenberg return err; 117445bb912bSLars Ellenberg } 117545bb912bSLars Ellenberg 117653840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1177db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 117853840641SAndreas Gruenbacher { 1179db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 118053840641SAndreas Gruenbacher 118153840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 118253840641SAndreas Gruenbacher drbd_clear_interval(i); 118353840641SAndreas Gruenbacher 11846c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 118553840641SAndreas Gruenbacher if (i->waiting) 118653840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 118753840641SAndreas Gruenbacher } 118853840641SAndreas Gruenbacher 1189d8763023SAndreas Gruenbacher static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packet cmd, 1190d8763023SAndreas Gruenbacher unsigned int data_size) 1191b411b363SPhilipp Reisner { 11922451fc3bSPhilipp Reisner int rv; 1193e42325a5SPhilipp Reisner struct p_barrier *p = &mdev->tconn->data.rbuf.barrier; 1194b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1195b411b363SPhilipp Reisner 1196b411b363SPhilipp Reisner inc_unacked(mdev); 1197b411b363SPhilipp Reisner 1198b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1199b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1200b411b363SPhilipp Reisner 1201b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1202b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1203b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1204b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1205b411b363SPhilipp Reisner * completed. */ 1206b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1207b411b363SPhilipp Reisner case WO_none: 1208b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 120981e84650SAndreas Gruenbacher return true; 1210b411b363SPhilipp Reisner 1211b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1212b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1213b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12142451fc3bSPhilipp Reisner if (epoch) 12152451fc3bSPhilipp Reisner break; 12162451fc3bSPhilipp Reisner else 1217b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 12182451fc3bSPhilipp Reisner /* Fall through */ 12192451fc3bSPhilipp Reisner 12202451fc3bSPhilipp Reisner case WO_bdev_flush: 12212451fc3bSPhilipp Reisner case WO_drain_io: 1222b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 12232451fc3bSPhilipp Reisner drbd_flush(mdev); 12242451fc3bSPhilipp Reisner 12252451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 12262451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12272451fc3bSPhilipp Reisner if (epoch) 12282451fc3bSPhilipp Reisner break; 1229b411b363SPhilipp Reisner } 1230b411b363SPhilipp Reisner 12312451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 12322451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 12332451fc3bSPhilipp Reisner 12342451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 12352451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1236b411b363SPhilipp Reisner 123781e84650SAndreas Gruenbacher return true; 12382451fc3bSPhilipp Reisner default: 12392451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 124081e84650SAndreas Gruenbacher return false; 1241b411b363SPhilipp Reisner } 1242b411b363SPhilipp Reisner 1243b411b363SPhilipp Reisner epoch->flags = 0; 1244b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1245b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1246b411b363SPhilipp Reisner 1247b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1248b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1249b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1250b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1251b411b363SPhilipp Reisner mdev->epochs++; 1252b411b363SPhilipp Reisner } else { 1253b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1254b411b363SPhilipp Reisner kfree(epoch); 1255b411b363SPhilipp Reisner } 1256b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1257b411b363SPhilipp Reisner 125881e84650SAndreas Gruenbacher return true; 1259b411b363SPhilipp Reisner } 1260b411b363SPhilipp Reisner 1261b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1262b411b363SPhilipp Reisner * and from receive_Data */ 1263f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1264f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1265f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1266b411b363SPhilipp Reisner { 12676666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1268db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1269b411b363SPhilipp Reisner struct page *page; 127045bb912bSLars Ellenberg int dgs, ds, rr; 1271a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1272a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 12736b4388acSPhilipp Reisner unsigned long *data; 1274b411b363SPhilipp Reisner 1275a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1276a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1277b411b363SPhilipp Reisner 1278b411b363SPhilipp Reisner if (dgs) { 1279b411b363SPhilipp Reisner rr = drbd_recv(mdev, dig_in, dgs); 1280b411b363SPhilipp Reisner if (rr != dgs) { 12810ddc5549SLars Ellenberg if (!signal_pending(current)) 12820ddc5549SLars Ellenberg dev_warn(DEV, 12830ddc5549SLars Ellenberg "short read receiving data digest: read %d expected %d\n", 1284b411b363SPhilipp Reisner rr, dgs); 1285b411b363SPhilipp Reisner return NULL; 1286b411b363SPhilipp Reisner } 1287b411b363SPhilipp Reisner } 1288b411b363SPhilipp Reisner 1289b411b363SPhilipp Reisner data_size -= dgs; 1290b411b363SPhilipp Reisner 1291841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1292841ce241SAndreas Gruenbacher return NULL; 1293841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1294841ce241SAndreas Gruenbacher return NULL; 1295841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1296841ce241SAndreas Gruenbacher return NULL; 1297b411b363SPhilipp Reisner 12986666032aSLars Ellenberg /* even though we trust out peer, 12996666032aSLars Ellenberg * we sometimes have to double check. */ 13006666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1301fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1302fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 13036666032aSLars Ellenberg (unsigned long long)capacity, 13046666032aSLars Ellenberg (unsigned long long)sector, data_size); 13056666032aSLars Ellenberg return NULL; 13066666032aSLars Ellenberg } 13076666032aSLars Ellenberg 1308b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1309b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1310b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1311db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO); 1312db830c46SAndreas Gruenbacher if (!peer_req) 1313b411b363SPhilipp Reisner return NULL; 131445bb912bSLars Ellenberg 1315b411b363SPhilipp Reisner ds = data_size; 1316db830c46SAndreas Gruenbacher page = peer_req->pages; 131745bb912bSLars Ellenberg page_chain_for_each(page) { 131845bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 13196b4388acSPhilipp Reisner data = kmap(page); 132045bb912bSLars Ellenberg rr = drbd_recv(mdev, data, len); 13210cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 13226b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 13236b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 13246b4388acSPhilipp Reisner } 1325b411b363SPhilipp Reisner kunmap(page); 132645bb912bSLars Ellenberg if (rr != len) { 1327db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 13280ddc5549SLars Ellenberg if (!signal_pending(current)) 1329b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 133045bb912bSLars Ellenberg rr, len); 1331b411b363SPhilipp Reisner return NULL; 1332b411b363SPhilipp Reisner } 1333b411b363SPhilipp Reisner ds -= rr; 1334b411b363SPhilipp Reisner } 1335b411b363SPhilipp Reisner 1336b411b363SPhilipp Reisner if (dgs) { 1337db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->integrity_r_tfm, peer_req, dig_vv); 1338b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1339470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1340470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1341b411b363SPhilipp Reisner drbd_bcast_ee(mdev, "digest failed", 1342db830c46SAndreas Gruenbacher dgs, dig_in, dig_vv, peer_req); 1343db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1344b411b363SPhilipp Reisner return NULL; 1345b411b363SPhilipp Reisner } 1346b411b363SPhilipp Reisner } 1347b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1348db830c46SAndreas Gruenbacher return peer_req; 1349b411b363SPhilipp Reisner } 1350b411b363SPhilipp Reisner 1351b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1352b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1353b411b363SPhilipp Reisner */ 1354b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1355b411b363SPhilipp Reisner { 1356b411b363SPhilipp Reisner struct page *page; 1357b411b363SPhilipp Reisner int rr, rv = 1; 1358b411b363SPhilipp Reisner void *data; 1359b411b363SPhilipp Reisner 1360c3470cdeSLars Ellenberg if (!data_size) 136181e84650SAndreas Gruenbacher return true; 1362c3470cdeSLars Ellenberg 136345bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, 1, 1); 1364b411b363SPhilipp Reisner 1365b411b363SPhilipp Reisner data = kmap(page); 1366b411b363SPhilipp Reisner while (data_size) { 1367b411b363SPhilipp Reisner rr = drbd_recv(mdev, data, min_t(int, data_size, PAGE_SIZE)); 1368b411b363SPhilipp Reisner if (rr != min_t(int, data_size, PAGE_SIZE)) { 1369b411b363SPhilipp Reisner rv = 0; 13700ddc5549SLars Ellenberg if (!signal_pending(current)) 13710ddc5549SLars Ellenberg dev_warn(DEV, 13720ddc5549SLars Ellenberg "short read receiving data: read %d expected %d\n", 1373b411b363SPhilipp Reisner rr, min_t(int, data_size, PAGE_SIZE)); 1374b411b363SPhilipp Reisner break; 1375b411b363SPhilipp Reisner } 1376b411b363SPhilipp Reisner data_size -= rr; 1377b411b363SPhilipp Reisner } 1378b411b363SPhilipp Reisner kunmap(page); 1379435f0740SLars Ellenberg drbd_pp_free(mdev, page, 0); 1380b411b363SPhilipp Reisner return rv; 1381b411b363SPhilipp Reisner } 1382b411b363SPhilipp Reisner 1383b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1384b411b363SPhilipp Reisner sector_t sector, int data_size) 1385b411b363SPhilipp Reisner { 1386b411b363SPhilipp Reisner struct bio_vec *bvec; 1387b411b363SPhilipp Reisner struct bio *bio; 1388b411b363SPhilipp Reisner int dgs, rr, i, expect; 1389a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1390a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1391b411b363SPhilipp Reisner 1392a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1393a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1394b411b363SPhilipp Reisner 1395b411b363SPhilipp Reisner if (dgs) { 1396b411b363SPhilipp Reisner rr = drbd_recv(mdev, dig_in, dgs); 1397b411b363SPhilipp Reisner if (rr != dgs) { 13980ddc5549SLars Ellenberg if (!signal_pending(current)) 13990ddc5549SLars Ellenberg dev_warn(DEV, 14000ddc5549SLars Ellenberg "short read receiving data reply digest: read %d expected %d\n", 1401b411b363SPhilipp Reisner rr, dgs); 1402b411b363SPhilipp Reisner return 0; 1403b411b363SPhilipp Reisner } 1404b411b363SPhilipp Reisner } 1405b411b363SPhilipp Reisner 1406b411b363SPhilipp Reisner data_size -= dgs; 1407b411b363SPhilipp Reisner 1408b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1409b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1410b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1411b411b363SPhilipp Reisner 1412b411b363SPhilipp Reisner bio = req->master_bio; 1413b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1414b411b363SPhilipp Reisner 1415b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1416b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1417b411b363SPhilipp Reisner rr = drbd_recv(mdev, 1418b411b363SPhilipp Reisner kmap(bvec->bv_page)+bvec->bv_offset, 1419b411b363SPhilipp Reisner expect); 1420b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1421b411b363SPhilipp Reisner if (rr != expect) { 14220ddc5549SLars Ellenberg if (!signal_pending(current)) 1423b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply: " 1424b411b363SPhilipp Reisner "read %d expected %d\n", 1425b411b363SPhilipp Reisner rr, expect); 1426b411b363SPhilipp Reisner return 0; 1427b411b363SPhilipp Reisner } 1428b411b363SPhilipp Reisner data_size -= rr; 1429b411b363SPhilipp Reisner } 1430b411b363SPhilipp Reisner 1431b411b363SPhilipp Reisner if (dgs) { 1432a0638456SPhilipp Reisner drbd_csum_bio(mdev, mdev->tconn->integrity_r_tfm, bio, dig_vv); 1433b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1434b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 1435b411b363SPhilipp Reisner return 0; 1436b411b363SPhilipp Reisner } 1437b411b363SPhilipp Reisner } 1438b411b363SPhilipp Reisner 1439b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 1440b411b363SPhilipp Reisner return 1; 1441b411b363SPhilipp Reisner } 1442b411b363SPhilipp Reisner 1443b411b363SPhilipp Reisner /* e_end_resync_block() is called via 1444b411b363SPhilipp Reisner * drbd_process_done_ee() by asender only */ 1445b411b363SPhilipp Reisner static int e_end_resync_block(struct drbd_conf *mdev, struct drbd_work *w, int unused) 1446b411b363SPhilipp Reisner { 1447db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = (struct drbd_peer_request *)w; 1448db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1449b411b363SPhilipp Reisner int ok; 1450b411b363SPhilipp Reisner 1451db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1452b411b363SPhilipp Reisner 1453db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1454db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1455db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1456b411b363SPhilipp Reisner } else { 1457b411b363SPhilipp Reisner /* Record failure to sync */ 1458db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1459b411b363SPhilipp Reisner 1460db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1461b411b363SPhilipp Reisner } 1462b411b363SPhilipp Reisner dec_unacked(mdev); 1463b411b363SPhilipp Reisner 1464b411b363SPhilipp Reisner return ok; 1465b411b363SPhilipp Reisner } 1466b411b363SPhilipp Reisner 1467b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1468b411b363SPhilipp Reisner { 1469db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1470b411b363SPhilipp Reisner 1471db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1472db830c46SAndreas Gruenbacher if (!peer_req) 147345bb912bSLars Ellenberg goto fail; 1474b411b363SPhilipp Reisner 1475b411b363SPhilipp Reisner dec_rs_pending(mdev); 1476b411b363SPhilipp Reisner 1477b411b363SPhilipp Reisner inc_unacked(mdev); 1478b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1479b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1480b411b363SPhilipp Reisner 1481db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 148245bb912bSLars Ellenberg 148387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1484db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 148587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1486b411b363SPhilipp Reisner 14870f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1488db830c46SAndreas Gruenbacher if (drbd_submit_ee(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 148981e84650SAndreas Gruenbacher return true; 149045bb912bSLars Ellenberg 149110f6d992SLars Ellenberg /* don't care for the reason here */ 149210f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 149387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1494db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 149587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 149622cc37a9SLars Ellenberg 1497db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 149845bb912bSLars Ellenberg fail: 149945bb912bSLars Ellenberg put_ldev(mdev); 150081e84650SAndreas Gruenbacher return false; 1501b411b363SPhilipp Reisner } 1502b411b363SPhilipp Reisner 1503668eebc6SAndreas Gruenbacher static struct drbd_request * 1504bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1505bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1506668eebc6SAndreas Gruenbacher { 1507668eebc6SAndreas Gruenbacher struct drbd_request *req; 1508668eebc6SAndreas Gruenbacher 1509bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1510bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 15115e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1512668eebc6SAndreas Gruenbacher return req; 1513c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1514c3afd8f5SAndreas Gruenbacher dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func, 1515c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1516c3afd8f5SAndreas Gruenbacher } 1517668eebc6SAndreas Gruenbacher return NULL; 1518668eebc6SAndreas Gruenbacher } 1519668eebc6SAndreas Gruenbacher 1520d8763023SAndreas Gruenbacher static int receive_DataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1521d8763023SAndreas Gruenbacher unsigned int data_size) 1522b411b363SPhilipp Reisner { 1523b411b363SPhilipp Reisner struct drbd_request *req; 1524b411b363SPhilipp Reisner sector_t sector; 1525b411b363SPhilipp Reisner int ok; 1526e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1527b411b363SPhilipp Reisner 1528b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1529b411b363SPhilipp Reisner 153087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1531bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 153287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1533c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 153481e84650SAndreas Gruenbacher return false; 1535b411b363SPhilipp Reisner 153624c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1537b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1538b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1539b411b363SPhilipp Reisner ok = recv_dless_read(mdev, req, sector, data_size); 1540b411b363SPhilipp Reisner 1541b411b363SPhilipp Reisner if (ok) 15428554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1543b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1544b411b363SPhilipp Reisner * I don't think we may complete this just yet 1545b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1546b411b363SPhilipp Reisner 1547b411b363SPhilipp Reisner return ok; 1548b411b363SPhilipp Reisner } 1549b411b363SPhilipp Reisner 1550d8763023SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1551d8763023SAndreas Gruenbacher unsigned int data_size) 1552b411b363SPhilipp Reisner { 1553b411b363SPhilipp Reisner sector_t sector; 1554b411b363SPhilipp Reisner int ok; 1555e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1556b411b363SPhilipp Reisner 1557b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1558b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1559b411b363SPhilipp Reisner 1560b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1561b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1562b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 15639c50842aSAndreas Gruenbacher * or in drbd_endio_sec. */ 1564b411b363SPhilipp Reisner ok = recv_resync_read(mdev, sector, data_size); 1565b411b363SPhilipp Reisner } else { 1566b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1567b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1568b411b363SPhilipp Reisner 1569b411b363SPhilipp Reisner ok = drbd_drain_block(mdev, data_size); 1570b411b363SPhilipp Reisner 15712b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1572b411b363SPhilipp Reisner } 1573b411b363SPhilipp Reisner 1574778f271dSPhilipp Reisner atomic_add(data_size >> 9, &mdev->rs_sect_in); 1575778f271dSPhilipp Reisner 1576b411b363SPhilipp Reisner return ok; 1577b411b363SPhilipp Reisner } 1578b411b363SPhilipp Reisner 1579b411b363SPhilipp Reisner /* e_end_block() is called via drbd_process_done_ee(). 1580b411b363SPhilipp Reisner * this means this function only runs in the asender thread 1581b411b363SPhilipp Reisner */ 1582b411b363SPhilipp Reisner static int e_end_block(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1583b411b363SPhilipp Reisner { 1584db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = (struct drbd_peer_request *)w; 1585db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1586b411b363SPhilipp Reisner int ok = 1, pcmd; 1587b411b363SPhilipp Reisner 158889e58e75SPhilipp Reisner if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C) { 1589db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1590b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1591b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1592db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1593b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1594db830c46SAndreas Gruenbacher ok &= drbd_send_ack(mdev, pcmd, peer_req); 1595b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1596db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1597b411b363SPhilipp Reisner } else { 1598db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1599b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1600b411b363SPhilipp Reisner * maybe assert this? */ 1601b411b363SPhilipp Reisner } 1602b411b363SPhilipp Reisner dec_unacked(mdev); 1603b411b363SPhilipp Reisner } 1604b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1605b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 160689e58e75SPhilipp Reisner if (mdev->tconn->net_conf->two_primaries) { 160787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1608db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1609db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 161087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1611bb3bfe96SAndreas Gruenbacher } else 1612db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1613b411b363SPhilipp Reisner 1614db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1615b411b363SPhilipp Reisner 1616b411b363SPhilipp Reisner return ok; 1617b411b363SPhilipp Reisner } 1618b411b363SPhilipp Reisner 1619b411b363SPhilipp Reisner static int e_send_discard_ack(struct drbd_conf *mdev, struct drbd_work *w, int unused) 1620b411b363SPhilipp Reisner { 1621db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = (struct drbd_peer_request *)w; 1622b411b363SPhilipp Reisner int ok = 1; 1623b411b363SPhilipp Reisner 162489e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 1625db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_DISCARD_ACK, peer_req); 1626b411b363SPhilipp Reisner 162787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1628db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1629db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 163087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1631b411b363SPhilipp Reisner 1632b411b363SPhilipp Reisner dec_unacked(mdev); 1633b411b363SPhilipp Reisner 1634b411b363SPhilipp Reisner return ok; 1635b411b363SPhilipp Reisner } 1636b411b363SPhilipp Reisner 16373e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 16383e394da1SAndreas Gruenbacher { 16393e394da1SAndreas Gruenbacher /* 16403e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 16413e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 16423e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 16433e394da1SAndreas Gruenbacher */ 16443e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 16453e394da1SAndreas Gruenbacher } 16463e394da1SAndreas Gruenbacher 16473e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 16483e394da1SAndreas Gruenbacher { 16493e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 16503e394da1SAndreas Gruenbacher } 16513e394da1SAndreas Gruenbacher 165243ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 16533e394da1SAndreas Gruenbacher { 165443ae077dSAndreas Gruenbacher unsigned int old_peer_seq; 16553e394da1SAndreas Gruenbacher 16563e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 165743ae077dSAndreas Gruenbacher old_peer_seq = mdev->peer_seq; 165843ae077dSAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 16593e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 166043ae077dSAndreas Gruenbacher if (old_peer_seq != peer_seq) 16613e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 16623e394da1SAndreas Gruenbacher } 16633e394da1SAndreas Gruenbacher 1664b411b363SPhilipp Reisner /* Called from receive_Data. 1665b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1666b411b363SPhilipp Reisner * 1667b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1668b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1669b411b363SPhilipp Reisner * been sent. 1670b411b363SPhilipp Reisner * 1671b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1672b411b363SPhilipp Reisner * 1673b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1674b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1675b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1676b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1677b411b363SPhilipp Reisner * 1678b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1679b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1680b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1681b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1682b411b363SPhilipp Reisner * 1683b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1684b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 1685b411b363SPhilipp Reisner static int drbd_wait_peer_seq(struct drbd_conf *mdev, const u32 packet_seq) 1686b411b363SPhilipp Reisner { 1687b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1688b411b363SPhilipp Reisner unsigned int p_seq; 1689b411b363SPhilipp Reisner long timeout; 1690b411b363SPhilipp Reisner int ret = 0; 1691b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1692b411b363SPhilipp Reisner for (;;) { 1693b411b363SPhilipp Reisner prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 16943e394da1SAndreas Gruenbacher if (!seq_greater(packet_seq, mdev->peer_seq + 1)) 1695b411b363SPhilipp Reisner break; 1696b411b363SPhilipp Reisner if (signal_pending(current)) { 1697b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1698b411b363SPhilipp Reisner break; 1699b411b363SPhilipp Reisner } 1700b411b363SPhilipp Reisner p_seq = mdev->peer_seq; 1701b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1702b411b363SPhilipp Reisner timeout = schedule_timeout(30*HZ); 1703b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1704b411b363SPhilipp Reisner if (timeout == 0 && p_seq == mdev->peer_seq) { 1705b411b363SPhilipp Reisner ret = -ETIMEDOUT; 1706b411b363SPhilipp Reisner dev_err(DEV, "ASSERT FAILED waited 30 seconds for sequence update, forcing reconnect\n"); 1707b411b363SPhilipp Reisner break; 1708b411b363SPhilipp Reisner } 1709b411b363SPhilipp Reisner } 1710b411b363SPhilipp Reisner finish_wait(&mdev->seq_wait, &wait); 1711b411b363SPhilipp Reisner if (mdev->peer_seq+1 == packet_seq) 1712b411b363SPhilipp Reisner mdev->peer_seq++; 1713b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1714b411b363SPhilipp Reisner return ret; 1715b411b363SPhilipp Reisner } 1716b411b363SPhilipp Reisner 1717688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1718688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1719688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1720688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 172176d2e7ecSPhilipp Reisner { 172276d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 172376d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1724688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 172576d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 172676d2e7ecSPhilipp Reisner } 172776d2e7ecSPhilipp Reisner 1728b411b363SPhilipp Reisner /* mirrored write */ 1729d8763023SAndreas Gruenbacher static int receive_Data(struct drbd_conf *mdev, enum drbd_packet cmd, 1730d8763023SAndreas Gruenbacher unsigned int data_size) 1731b411b363SPhilipp Reisner { 1732b411b363SPhilipp Reisner sector_t sector; 1733db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1734e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1735b411b363SPhilipp Reisner int rw = WRITE; 1736b411b363SPhilipp Reisner u32 dp_flags; 1737b411b363SPhilipp Reisner 1738b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 1739b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1740b411b363SPhilipp Reisner if (mdev->peer_seq+1 == be32_to_cpu(p->seq_num)) 1741b411b363SPhilipp Reisner mdev->peer_seq++; 1742b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1743b411b363SPhilipp Reisner 17442b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1745b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 1746b411b363SPhilipp Reisner return drbd_drain_block(mdev, data_size); 1747b411b363SPhilipp Reisner } 1748b411b363SPhilipp Reisner 1749b411b363SPhilipp Reisner /* get_ldev(mdev) successful. 1750b411b363SPhilipp Reisner * Corresponding put_ldev done either below (on various errors), 17519c50842aSAndreas Gruenbacher * or in drbd_endio_sec, if we successfully submit the data at 1752b411b363SPhilipp Reisner * the end of this function. */ 1753b411b363SPhilipp Reisner 1754b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1755db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, data_size); 1756db830c46SAndreas Gruenbacher if (!peer_req) { 1757b411b363SPhilipp Reisner put_ldev(mdev); 175881e84650SAndreas Gruenbacher return false; 1759b411b363SPhilipp Reisner } 1760b411b363SPhilipp Reisner 1761db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 1762b411b363SPhilipp Reisner 1763688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 1764688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 1765688593c5SLars Ellenberg 1766688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 1767db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 1768688593c5SLars Ellenberg 1769b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1770db830c46SAndreas Gruenbacher peer_req->epoch = mdev->current_epoch; 1771db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 1772db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 1773b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1774b411b363SPhilipp Reisner 1775b411b363SPhilipp Reisner /* I'm the receiver, I do hold a net_cnt reference. */ 177689e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->two_primaries) { 177787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1778b411b363SPhilipp Reisner } else { 1779b411b363SPhilipp Reisner /* don't get the req_lock yet, 1780b411b363SPhilipp Reisner * we may sleep in drbd_wait_peer_seq */ 1781db830c46SAndreas Gruenbacher const int size = peer_req->i.size; 178225703f83SPhilipp Reisner const int discard = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 1783b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1784b411b363SPhilipp Reisner int first; 1785b411b363SPhilipp Reisner 178689e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 1787b411b363SPhilipp Reisner 1788b411b363SPhilipp Reisner /* conflict detection and handling: 1789b411b363SPhilipp Reisner * 1. wait on the sequence number, 1790b411b363SPhilipp Reisner * in case this data packet overtook ACK packets. 17915e472264SAndreas Gruenbacher * 2. check for conflicting write requests. 1792b411b363SPhilipp Reisner * 1793b411b363SPhilipp Reisner * Note: for two_primaries, we are protocol C, 1794b411b363SPhilipp Reisner * so there cannot be any request that is DONE 1795b411b363SPhilipp Reisner * but still on the transfer log. 1796b411b363SPhilipp Reisner * 1797b411b363SPhilipp Reisner * if no conflicting request is found: 1798b411b363SPhilipp Reisner * submit. 1799b411b363SPhilipp Reisner * 1800b411b363SPhilipp Reisner * if any conflicting request is found 1801b411b363SPhilipp Reisner * that has not yet been acked, 1802b411b363SPhilipp Reisner * AND I have the "discard concurrent writes" flag: 1803b411b363SPhilipp Reisner * queue (via done_ee) the P_DISCARD_ACK; OUT. 1804b411b363SPhilipp Reisner * 1805b411b363SPhilipp Reisner * if any conflicting request is found: 1806b411b363SPhilipp Reisner * block the receiver, waiting on misc_wait 1807b411b363SPhilipp Reisner * until no more conflicting requests are there, 1808b411b363SPhilipp Reisner * or we get interrupted (disconnect). 1809b411b363SPhilipp Reisner * 1810b411b363SPhilipp Reisner * we do not just write after local io completion of those 1811b411b363SPhilipp Reisner * requests, but only after req is done completely, i.e. 1812b411b363SPhilipp Reisner * we wait for the P_DISCARD_ACK to arrive! 1813b411b363SPhilipp Reisner * 1814b411b363SPhilipp Reisner * then proceed normally, i.e. submit. 1815b411b363SPhilipp Reisner */ 1816b411b363SPhilipp Reisner if (drbd_wait_peer_seq(mdev, be32_to_cpu(p->seq_num))) 1817b411b363SPhilipp Reisner goto out_interrupted; 1818b411b363SPhilipp Reisner 181987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1820b411b363SPhilipp Reisner 1821b411b363SPhilipp Reisner first = 1; 1822b411b363SPhilipp Reisner for (;;) { 1823de696716SAndreas Gruenbacher struct drbd_interval *i; 1824b411b363SPhilipp Reisner int have_unacked = 0; 1825b411b363SPhilipp Reisner int have_conflict = 0; 1826b411b363SPhilipp Reisner prepare_to_wait(&mdev->misc_wait, &wait, 1827b411b363SPhilipp Reisner TASK_INTERRUPTIBLE); 1828de696716SAndreas Gruenbacher 1829de696716SAndreas Gruenbacher i = drbd_find_overlap(&mdev->write_requests, sector, size); 1830de696716SAndreas Gruenbacher if (i) { 1831b411b363SPhilipp Reisner /* only ALERT on first iteration, 1832b411b363SPhilipp Reisner * we may be woken up early... */ 1833b411b363SPhilipp Reisner if (first) 18345e472264SAndreas Gruenbacher dev_alert(DEV, "%s[%u] Concurrent %s write detected!" 1835b411b363SPhilipp Reisner " new: %llus +%u; pending: %llus +%u\n", 1836b411b363SPhilipp Reisner current->comm, current->pid, 18375e472264SAndreas Gruenbacher i->local ? "local" : "remote", 1838b411b363SPhilipp Reisner (unsigned long long)sector, size, 18395e472264SAndreas Gruenbacher (unsigned long long)i->sector, i->size); 18405e472264SAndreas Gruenbacher 18415e472264SAndreas Gruenbacher if (i->local) { 18425e472264SAndreas Gruenbacher struct drbd_request *req2; 18435e472264SAndreas Gruenbacher 18445e472264SAndreas Gruenbacher req2 = container_of(i, struct drbd_request, i); 1845de696716SAndreas Gruenbacher if (req2->rq_state & RQ_NET_PENDING) 1846b411b363SPhilipp Reisner ++have_unacked; 18475e472264SAndreas Gruenbacher } 1848b411b363SPhilipp Reisner ++have_conflict; 1849b411b363SPhilipp Reisner } 1850b411b363SPhilipp Reisner if (!have_conflict) 1851b411b363SPhilipp Reisner break; 1852b411b363SPhilipp Reisner 1853b411b363SPhilipp Reisner /* Discard Ack only for the _first_ iteration */ 1854b411b363SPhilipp Reisner if (first && discard && have_unacked) { 1855b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [DISCARD BY FLAG] sec=%llus\n", 1856b411b363SPhilipp Reisner (unsigned long long)sector); 1857b411b363SPhilipp Reisner inc_unacked(mdev); 1858db830c46SAndreas Gruenbacher peer_req->w.cb = e_send_discard_ack; 1859db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 1860b411b363SPhilipp Reisner 186187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1862b411b363SPhilipp Reisner 1863b411b363SPhilipp Reisner /* we could probably send that P_DISCARD_ACK ourselves, 1864b411b363SPhilipp Reisner * but I don't like the receiver using the msock */ 1865b411b363SPhilipp Reisner 1866b411b363SPhilipp Reisner put_ldev(mdev); 1867b411b363SPhilipp Reisner wake_asender(mdev); 1868b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 186981e84650SAndreas Gruenbacher return true; 1870b411b363SPhilipp Reisner } 1871b411b363SPhilipp Reisner 1872b411b363SPhilipp Reisner if (signal_pending(current)) { 187387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1874b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1875b411b363SPhilipp Reisner goto out_interrupted; 1876b411b363SPhilipp Reisner } 1877b411b363SPhilipp Reisner 1878a500c2efSAndreas Gruenbacher /* Indicate to wake up mdev->misc_wait upon completion. */ 187953840641SAndreas Gruenbacher i->waiting = true; 1880a500c2efSAndreas Gruenbacher 188187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1882b411b363SPhilipp Reisner if (first) { 1883b411b363SPhilipp Reisner first = 0; 1884b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [W AFTERWARDS] " 1885b411b363SPhilipp Reisner "sec=%llus\n", (unsigned long long)sector); 1886b411b363SPhilipp Reisner } else if (discard) { 1887b411b363SPhilipp Reisner /* we had none on the first iteration. 1888b411b363SPhilipp Reisner * there must be none now. */ 1889b411b363SPhilipp Reisner D_ASSERT(have_unacked == 0); 1890b411b363SPhilipp Reisner } 1891b411b363SPhilipp Reisner schedule(); 189287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1893b411b363SPhilipp Reisner } 1894b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 18955e472264SAndreas Gruenbacher 1896db830c46SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 1897b411b363SPhilipp Reisner } 1898b411b363SPhilipp Reisner 1899db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 190087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1901b411b363SPhilipp Reisner 190289e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->wire_protocol) { 1903b411b363SPhilipp Reisner case DRBD_PROT_C: 1904b411b363SPhilipp Reisner inc_unacked(mdev); 1905b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 1906b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1907b411b363SPhilipp Reisner break; 1908b411b363SPhilipp Reisner case DRBD_PROT_B: 1909b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 1910b411b363SPhilipp Reisner * sends on the msock, but anyways */ 1911db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 1912b411b363SPhilipp Reisner break; 1913b411b363SPhilipp Reisner case DRBD_PROT_A: 1914b411b363SPhilipp Reisner /* nothing to do */ 1915b411b363SPhilipp Reisner break; 1916b411b363SPhilipp Reisner } 1917b411b363SPhilipp Reisner 19186719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 1919b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 1920db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 1921db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 1922db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 1923db830c46SAndreas Gruenbacher drbd_al_begin_io(mdev, peer_req->i.sector); 1924b411b363SPhilipp Reisner } 1925b411b363SPhilipp Reisner 1926db830c46SAndreas Gruenbacher if (drbd_submit_ee(mdev, peer_req, rw, DRBD_FAULT_DT_WR) == 0) 192781e84650SAndreas Gruenbacher return true; 1928b411b363SPhilipp Reisner 192910f6d992SLars Ellenberg /* don't care for the reason here */ 193010f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 193187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1932db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 1933db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 193487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1935db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 1936db830c46SAndreas Gruenbacher drbd_al_complete_io(mdev, peer_req->i.sector); 193722cc37a9SLars Ellenberg 1938b411b363SPhilipp Reisner out_interrupted: 1939db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP); 1940b411b363SPhilipp Reisner put_ldev(mdev); 1941db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 194281e84650SAndreas Gruenbacher return false; 1943b411b363SPhilipp Reisner } 1944b411b363SPhilipp Reisner 19450f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 19460f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 19470f0601f4SLars Ellenberg * 19480f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 19490f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 19500f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 19510f0601f4SLars Ellenberg * activity, it obviously is "busy". 19520f0601f4SLars Ellenberg * 19530f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 19540f0601f4SLars Ellenberg * to have a short time average so we can react faster. 19550f0601f4SLars Ellenberg */ 1956e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 19570f0601f4SLars Ellenberg { 19580f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 19590f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 1960e3555d85SPhilipp Reisner struct lc_element *tmp; 19610f0601f4SLars Ellenberg int curr_events; 19620f0601f4SLars Ellenberg int throttle = 0; 19630f0601f4SLars Ellenberg 19640f0601f4SLars Ellenberg /* feature disabled? */ 19650f0601f4SLars Ellenberg if (mdev->sync_conf.c_min_rate == 0) 19660f0601f4SLars Ellenberg return 0; 19670f0601f4SLars Ellenberg 1968e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 1969e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 1970e3555d85SPhilipp Reisner if (tmp) { 1971e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 1972e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 1973e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 1974e3555d85SPhilipp Reisner return 0; 1975e3555d85SPhilipp Reisner } 1976e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 1977e3555d85SPhilipp Reisner } 1978e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 1979e3555d85SPhilipp Reisner 19800f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 19810f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 19820f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 1983e3555d85SPhilipp Reisner 19840f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 19850f0601f4SLars Ellenberg unsigned long rs_left; 19860f0601f4SLars Ellenberg int i; 19870f0601f4SLars Ellenberg 19880f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 19890f0601f4SLars Ellenberg 19900f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 19910f0601f4SLars Ellenberg * approx. */ 19922649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 19932649f080SLars Ellenberg 19942649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 19952649f080SLars Ellenberg rs_left = mdev->ov_left; 19962649f080SLars Ellenberg else 19970f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 19980f0601f4SLars Ellenberg 19990f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 20000f0601f4SLars Ellenberg if (!dt) 20010f0601f4SLars Ellenberg dt++; 20020f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 20030f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 20040f0601f4SLars Ellenberg 20050f0601f4SLars Ellenberg if (dbdt > mdev->sync_conf.c_min_rate) 20060f0601f4SLars Ellenberg throttle = 1; 20070f0601f4SLars Ellenberg } 20080f0601f4SLars Ellenberg return throttle; 20090f0601f4SLars Ellenberg } 20100f0601f4SLars Ellenberg 20110f0601f4SLars Ellenberg 2012d8763023SAndreas Gruenbacher static int receive_DataRequest(struct drbd_conf *mdev, enum drbd_packet cmd, 2013d8763023SAndreas Gruenbacher unsigned int digest_size) 2014b411b363SPhilipp Reisner { 2015b411b363SPhilipp Reisner sector_t sector; 2016b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 2017db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2018b411b363SPhilipp Reisner struct digest_info *di = NULL; 2019b18b37beSPhilipp Reisner int size, verb; 2020b411b363SPhilipp Reisner unsigned int fault_type; 2021e42325a5SPhilipp Reisner struct p_block_req *p = &mdev->tconn->data.rbuf.block_req; 2022b411b363SPhilipp Reisner 2023b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2024b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2025b411b363SPhilipp Reisner 20261816a2b4SLars Ellenberg if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_BIO_SIZE) { 2027b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2028b411b363SPhilipp Reisner (unsigned long long)sector, size); 202981e84650SAndreas Gruenbacher return false; 2030b411b363SPhilipp Reisner } 2031b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2032b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2033b411b363SPhilipp Reisner (unsigned long long)sector, size); 203481e84650SAndreas Gruenbacher return false; 2035b411b363SPhilipp Reisner } 2036b411b363SPhilipp Reisner 2037b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2038b18b37beSPhilipp Reisner verb = 1; 2039b18b37beSPhilipp Reisner switch (cmd) { 2040b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2041b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2042b18b37beSPhilipp Reisner break; 2043b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2044b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2045b18b37beSPhilipp Reisner case P_OV_REQUEST: 2046b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2047b18b37beSPhilipp Reisner break; 2048b18b37beSPhilipp Reisner case P_OV_REPLY: 2049b18b37beSPhilipp Reisner verb = 0; 2050b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2051b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2052b18b37beSPhilipp Reisner break; 2053b18b37beSPhilipp Reisner default: 2054b18b37beSPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 2055b18b37beSPhilipp Reisner cmdname(cmd)); 2056b18b37beSPhilipp Reisner } 2057b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2058b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2059b411b363SPhilipp Reisner "no local data.\n"); 2060b18b37beSPhilipp Reisner 2061a821cc4aSLars Ellenberg /* drain possibly payload */ 2062a821cc4aSLars Ellenberg return drbd_drain_block(mdev, digest_size); 2063b411b363SPhilipp Reisner } 2064b411b363SPhilipp Reisner 2065b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2066b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2067b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2068db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO); 2069db830c46SAndreas Gruenbacher if (!peer_req) { 2070b411b363SPhilipp Reisner put_ldev(mdev); 207181e84650SAndreas Gruenbacher return false; 2072b411b363SPhilipp Reisner } 2073b411b363SPhilipp Reisner 207402918be2SPhilipp Reisner switch (cmd) { 2075b411b363SPhilipp Reisner case P_DATA_REQUEST: 2076db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2077b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 207880a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 207980a40e43SLars Ellenberg goto submit; 208080a40e43SLars Ellenberg 2081b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2082db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2083b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 20845f9915bbSLars Ellenberg /* used in the sector offset progress display */ 20855f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2086b411b363SPhilipp Reisner break; 2087b411b363SPhilipp Reisner 2088b411b363SPhilipp Reisner case P_OV_REPLY: 2089b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2090b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2091b411b363SPhilipp Reisner di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO); 2092b411b363SPhilipp Reisner if (!di) 2093b411b363SPhilipp Reisner goto out_free_e; 2094b411b363SPhilipp Reisner 2095b411b363SPhilipp Reisner di->digest_size = digest_size; 2096b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2097b411b363SPhilipp Reisner 2098db830c46SAndreas Gruenbacher peer_req->digest = di; 2099db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2100c36c3cedSLars Ellenberg 2101b411b363SPhilipp Reisner if (drbd_recv(mdev, di->digest, digest_size) != digest_size) 2102b411b363SPhilipp Reisner goto out_free_e; 2103b411b363SPhilipp Reisner 210402918be2SPhilipp Reisner if (cmd == P_CSUM_RS_REQUEST) { 210531890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2106db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 21075f9915bbSLars Ellenberg /* used in the sector offset progress display */ 21085f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 210902918be2SPhilipp Reisner } else if (cmd == P_OV_REPLY) { 21102649f080SLars Ellenberg /* track progress, we may need to throttle */ 21112649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2112db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2113b411b363SPhilipp Reisner dec_rs_pending(mdev); 21140f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 21150f0601f4SLars Ellenberg * but accounting still needs to be done. */ 21160f0601f4SLars Ellenberg goto submit_for_resync; 2117b411b363SPhilipp Reisner } 2118b411b363SPhilipp Reisner break; 2119b411b363SPhilipp Reisner 2120b411b363SPhilipp Reisner case P_OV_REQUEST: 2121b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 212231890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2123de228bbaSLars Ellenberg unsigned long now = jiffies; 2124de228bbaSLars Ellenberg int i; 2125b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2126b411b363SPhilipp Reisner mdev->ov_position = sector; 212730b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 212830b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2129de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2130de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2131de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2132de228bbaSLars Ellenberg } 2133b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2134b411b363SPhilipp Reisner (unsigned long long)sector); 2135b411b363SPhilipp Reisner } 2136db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2137b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2138b411b363SPhilipp Reisner break; 2139b411b363SPhilipp Reisner 2140b411b363SPhilipp Reisner default: 2141b411b363SPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 214202918be2SPhilipp Reisner cmdname(cmd)); 2143b411b363SPhilipp Reisner fault_type = DRBD_FAULT_MAX; 214480a40e43SLars Ellenberg goto out_free_e; 2145b411b363SPhilipp Reisner } 2146b411b363SPhilipp Reisner 21470f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 21480f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 21490f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 21500f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 21510f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 21520f0601f4SLars Ellenberg * 21530f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 21540f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 21550f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 21560f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 21570f0601f4SLars Ellenberg * a while, anyways. 21580f0601f4SLars Ellenberg */ 2159b411b363SPhilipp Reisner 21600f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 21610f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 21620f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 21630f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 21640f0601f4SLars Ellenberg * 21650f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 21660f0601f4SLars Ellenberg * we would also throttle its application reads. 21670f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 21680f0601f4SLars Ellenberg */ 2169e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2170e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2171e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 217280a40e43SLars Ellenberg goto out_free_e; 2173b411b363SPhilipp Reisner 21740f0601f4SLars Ellenberg submit_for_resync: 21750f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 21760f0601f4SLars Ellenberg 217780a40e43SLars Ellenberg submit: 2178b411b363SPhilipp Reisner inc_unacked(mdev); 217987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2180db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 218187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2182b411b363SPhilipp Reisner 2183db830c46SAndreas Gruenbacher if (drbd_submit_ee(mdev, peer_req, READ, fault_type) == 0) 218481e84650SAndreas Gruenbacher return true; 2185b411b363SPhilipp Reisner 218610f6d992SLars Ellenberg /* don't care for the reason here */ 218710f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 218887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2189db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 219087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 219122cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 219222cc37a9SLars Ellenberg 2193b411b363SPhilipp Reisner out_free_e: 2194b411b363SPhilipp Reisner put_ldev(mdev); 2195db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 219681e84650SAndreas Gruenbacher return false; 2197b411b363SPhilipp Reisner } 2198b411b363SPhilipp Reisner 2199b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2200b411b363SPhilipp Reisner { 2201b411b363SPhilipp Reisner int self, peer, rv = -100; 2202b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2203b411b363SPhilipp Reisner 2204b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2205b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2206b411b363SPhilipp Reisner 2207b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2208b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2209b411b363SPhilipp Reisner 221089e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_0p) { 2211b411b363SPhilipp Reisner case ASB_CONSENSUS: 2212b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2213b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2214b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2215b411b363SPhilipp Reisner break; 2216b411b363SPhilipp Reisner case ASB_DISCONNECT: 2217b411b363SPhilipp Reisner break; 2218b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2219b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2220b411b363SPhilipp Reisner rv = -1; 2221b411b363SPhilipp Reisner break; 2222b411b363SPhilipp Reisner } 2223b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2224b411b363SPhilipp Reisner rv = 1; 2225b411b363SPhilipp Reisner break; 2226b411b363SPhilipp Reisner } 2227b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2228b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2229b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2230b411b363SPhilipp Reisner rv = 1; 2231b411b363SPhilipp Reisner break; 2232b411b363SPhilipp Reisner } 2233b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2234b411b363SPhilipp Reisner rv = -1; 2235b411b363SPhilipp Reisner break; 2236b411b363SPhilipp Reisner } 2237b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2238ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2239b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2240b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2241b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 224225703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2243b411b363SPhilipp Reisner ? -1 : 1; 2244b411b363SPhilipp Reisner break; 2245b411b363SPhilipp Reisner } else { 2246b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2247b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2248b411b363SPhilipp Reisner } 224989e58e75SPhilipp Reisner if (mdev->tconn->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2250b411b363SPhilipp Reisner break; 2251b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2252b411b363SPhilipp Reisner if (ch_self < ch_peer) 2253b411b363SPhilipp Reisner rv = -1; 2254b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2255b411b363SPhilipp Reisner rv = 1; 2256b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2257b411b363SPhilipp Reisner /* Well, then use something else. */ 225825703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2259b411b363SPhilipp Reisner ? -1 : 1; 2260b411b363SPhilipp Reisner break; 2261b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2262b411b363SPhilipp Reisner rv = -1; 2263b411b363SPhilipp Reisner break; 2264b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2265b411b363SPhilipp Reisner rv = 1; 2266b411b363SPhilipp Reisner } 2267b411b363SPhilipp Reisner 2268b411b363SPhilipp Reisner return rv; 2269b411b363SPhilipp Reisner } 2270b411b363SPhilipp Reisner 2271b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2272b411b363SPhilipp Reisner { 22736184ea21SAndreas Gruenbacher int hg, rv = -100; 2274b411b363SPhilipp Reisner 227589e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_1p) { 2276b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2277b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2278b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2279b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2280b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2281b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2282b411b363SPhilipp Reisner break; 2283b411b363SPhilipp Reisner case ASB_DISCONNECT: 2284b411b363SPhilipp Reisner break; 2285b411b363SPhilipp Reisner case ASB_CONSENSUS: 2286b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2287b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2288b411b363SPhilipp Reisner rv = hg; 2289b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2290b411b363SPhilipp Reisner rv = hg; 2291b411b363SPhilipp Reisner break; 2292b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2293b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2294b411b363SPhilipp Reisner break; 2295b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2296b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2297b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2298b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2299b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2300bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2301bb437946SAndreas Gruenbacher 2302bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2303b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2304b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2305b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2306bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2307bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2308b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2309b411b363SPhilipp Reisner } else { 2310b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2311b411b363SPhilipp Reisner rv = hg; 2312b411b363SPhilipp Reisner } 2313b411b363SPhilipp Reisner } else 2314b411b363SPhilipp Reisner rv = hg; 2315b411b363SPhilipp Reisner } 2316b411b363SPhilipp Reisner 2317b411b363SPhilipp Reisner return rv; 2318b411b363SPhilipp Reisner } 2319b411b363SPhilipp Reisner 2320b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2321b411b363SPhilipp Reisner { 23226184ea21SAndreas Gruenbacher int hg, rv = -100; 2323b411b363SPhilipp Reisner 232489e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_2p) { 2325b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2326b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2327b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2328b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2329b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2330b411b363SPhilipp Reisner case ASB_CONSENSUS: 2331b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2332b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2333b411b363SPhilipp Reisner break; 2334b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2335b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2336b411b363SPhilipp Reisner break; 2337b411b363SPhilipp Reisner case ASB_DISCONNECT: 2338b411b363SPhilipp Reisner break; 2339b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2340b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2341b411b363SPhilipp Reisner if (hg == -1) { 2342bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2343bb437946SAndreas Gruenbacher 2344b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2345b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2346b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2347bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2348bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2349b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2350b411b363SPhilipp Reisner } else { 2351b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2352b411b363SPhilipp Reisner rv = hg; 2353b411b363SPhilipp Reisner } 2354b411b363SPhilipp Reisner } else 2355b411b363SPhilipp Reisner rv = hg; 2356b411b363SPhilipp Reisner } 2357b411b363SPhilipp Reisner 2358b411b363SPhilipp Reisner return rv; 2359b411b363SPhilipp Reisner } 2360b411b363SPhilipp Reisner 2361b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2362b411b363SPhilipp Reisner u64 bits, u64 flags) 2363b411b363SPhilipp Reisner { 2364b411b363SPhilipp Reisner if (!uuid) { 2365b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2366b411b363SPhilipp Reisner return; 2367b411b363SPhilipp Reisner } 2368b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2369b411b363SPhilipp Reisner text, 2370b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2371b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2372b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2373b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2374b411b363SPhilipp Reisner (unsigned long long)bits, 2375b411b363SPhilipp Reisner (unsigned long long)flags); 2376b411b363SPhilipp Reisner } 2377b411b363SPhilipp Reisner 2378b411b363SPhilipp Reisner /* 2379b411b363SPhilipp Reisner 100 after split brain try auto recover 2380b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2381b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2382b411b363SPhilipp Reisner 0 no Sync 2383b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2384b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2385b411b363SPhilipp Reisner -100 after split brain, disconnect 2386b411b363SPhilipp Reisner -1000 unrelated data 23874a23f264SPhilipp Reisner -1091 requires proto 91 23884a23f264SPhilipp Reisner -1096 requires proto 96 2389b411b363SPhilipp Reisner */ 2390b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2391b411b363SPhilipp Reisner { 2392b411b363SPhilipp Reisner u64 self, peer; 2393b411b363SPhilipp Reisner int i, j; 2394b411b363SPhilipp Reisner 2395b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2396b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2397b411b363SPhilipp Reisner 2398b411b363SPhilipp Reisner *rule_nr = 10; 2399b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2400b411b363SPhilipp Reisner return 0; 2401b411b363SPhilipp Reisner 2402b411b363SPhilipp Reisner *rule_nr = 20; 2403b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2404b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2405b411b363SPhilipp Reisner return -2; 2406b411b363SPhilipp Reisner 2407b411b363SPhilipp Reisner *rule_nr = 30; 2408b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2409b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2410b411b363SPhilipp Reisner return 2; 2411b411b363SPhilipp Reisner 2412b411b363SPhilipp Reisner if (self == peer) { 2413b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2414b411b363SPhilipp Reisner 2415b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2416b411b363SPhilipp Reisner 241731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 24184a23f264SPhilipp Reisner return -1091; 2419b411b363SPhilipp Reisner 2420b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2421b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2422b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2423b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2424b411b363SPhilipp Reisner 2425b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2426b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2427b411b363SPhilipp Reisner *rule_nr = 34; 2428b411b363SPhilipp Reisner } else { 2429b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2430b411b363SPhilipp Reisner *rule_nr = 36; 2431b411b363SPhilipp Reisner } 2432b411b363SPhilipp Reisner 2433b411b363SPhilipp Reisner return 1; 2434b411b363SPhilipp Reisner } 2435b411b363SPhilipp Reisner 2436b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2437b411b363SPhilipp Reisner 243831890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 24394a23f264SPhilipp Reisner return -1091; 2440b411b363SPhilipp Reisner 2441b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2442b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2443b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2444b411b363SPhilipp Reisner 2445b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2446b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2447b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2448b411b363SPhilipp Reisner 2449b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2450b411b363SPhilipp Reisner *rule_nr = 35; 2451b411b363SPhilipp Reisner } else { 2452b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2453b411b363SPhilipp Reisner *rule_nr = 37; 2454b411b363SPhilipp Reisner } 2455b411b363SPhilipp Reisner 2456b411b363SPhilipp Reisner return -1; 2457b411b363SPhilipp Reisner } 2458b411b363SPhilipp Reisner 2459b411b363SPhilipp Reisner /* Common power [off|failure] */ 2460b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2461b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2462b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2463b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2464b411b363SPhilipp Reisner *rule_nr = 40; 2465b411b363SPhilipp Reisner 2466b411b363SPhilipp Reisner switch (rct) { 2467b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2468b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2469b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2470b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 247125703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2472b411b363SPhilipp Reisner return dc ? -1 : 1; 2473b411b363SPhilipp Reisner } 2474b411b363SPhilipp Reisner } 2475b411b363SPhilipp Reisner 2476b411b363SPhilipp Reisner *rule_nr = 50; 2477b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2478b411b363SPhilipp Reisner if (self == peer) 2479b411b363SPhilipp Reisner return -1; 2480b411b363SPhilipp Reisner 2481b411b363SPhilipp Reisner *rule_nr = 51; 2482b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2483b411b363SPhilipp Reisner if (self == peer) { 248431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 24854a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 24864a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 24874a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2488b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2489b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2490b411b363SPhilipp Reisner 249131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 24924a23f264SPhilipp Reisner return -1091; 2493b411b363SPhilipp Reisner 2494b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2495b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 24964a23f264SPhilipp Reisner 24974a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 24984a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 24994a23f264SPhilipp Reisner 2500b411b363SPhilipp Reisner return -1; 2501b411b363SPhilipp Reisner } 2502b411b363SPhilipp Reisner } 2503b411b363SPhilipp Reisner 2504b411b363SPhilipp Reisner *rule_nr = 60; 2505b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2506b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2507b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2508b411b363SPhilipp Reisner if (self == peer) 2509b411b363SPhilipp Reisner return -2; 2510b411b363SPhilipp Reisner } 2511b411b363SPhilipp Reisner 2512b411b363SPhilipp Reisner *rule_nr = 70; 2513b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2514b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2515b411b363SPhilipp Reisner if (self == peer) 2516b411b363SPhilipp Reisner return 1; 2517b411b363SPhilipp Reisner 2518b411b363SPhilipp Reisner *rule_nr = 71; 2519b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2520b411b363SPhilipp Reisner if (self == peer) { 252131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 25224a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 25234a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 25244a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2525b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2526b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2527b411b363SPhilipp Reisner 252831890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25294a23f264SPhilipp Reisner return -1091; 2530b411b363SPhilipp Reisner 2531b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2532b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2533b411b363SPhilipp Reisner 25344a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2535b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2536b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2537b411b363SPhilipp Reisner 2538b411b363SPhilipp Reisner return 1; 2539b411b363SPhilipp Reisner } 2540b411b363SPhilipp Reisner } 2541b411b363SPhilipp Reisner 2542b411b363SPhilipp Reisner 2543b411b363SPhilipp Reisner *rule_nr = 80; 2544d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2545b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2546b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2547b411b363SPhilipp Reisner if (self == peer) 2548b411b363SPhilipp Reisner return 2; 2549b411b363SPhilipp Reisner } 2550b411b363SPhilipp Reisner 2551b411b363SPhilipp Reisner *rule_nr = 90; 2552b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2553b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2554b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2555b411b363SPhilipp Reisner return 100; 2556b411b363SPhilipp Reisner 2557b411b363SPhilipp Reisner *rule_nr = 100; 2558b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2559b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2560b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2561b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2562b411b363SPhilipp Reisner if (self == peer) 2563b411b363SPhilipp Reisner return -100; 2564b411b363SPhilipp Reisner } 2565b411b363SPhilipp Reisner } 2566b411b363SPhilipp Reisner 2567b411b363SPhilipp Reisner return -1000; 2568b411b363SPhilipp Reisner } 2569b411b363SPhilipp Reisner 2570b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2571b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2572b411b363SPhilipp Reisner */ 2573b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2574b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2575b411b363SPhilipp Reisner { 2576b411b363SPhilipp Reisner int hg, rule_nr; 2577b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2578b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2579b411b363SPhilipp Reisner 2580b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2581b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2582b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2583b411b363SPhilipp Reisner 2584b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2585b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2586b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2587b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2588b411b363SPhilipp Reisner 2589b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2590b411b363SPhilipp Reisner 2591b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2592b411b363SPhilipp Reisner 2593b411b363SPhilipp Reisner if (hg == -1000) { 2594b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2595b411b363SPhilipp Reisner return C_MASK; 2596b411b363SPhilipp Reisner } 25974a23f264SPhilipp Reisner if (hg < -1000) { 25984a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2599b411b363SPhilipp Reisner return C_MASK; 2600b411b363SPhilipp Reisner } 2601b411b363SPhilipp Reisner 2602b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2603b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2604b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2605b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2606b411b363SPhilipp Reisner if (f) 2607b411b363SPhilipp Reisner hg = hg*2; 2608b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2609b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2610b411b363SPhilipp Reisner } 2611b411b363SPhilipp Reisner 26123a11a487SAdam Gandelman if (abs(hg) == 100) 26133a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 26143a11a487SAdam Gandelman 261589e58e75SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->tconn->net_conf->always_asbp)) { 2616b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2617b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2618b411b363SPhilipp Reisner int forced = (hg == -100); 2619b411b363SPhilipp Reisner 2620b411b363SPhilipp Reisner switch (pcount) { 2621b411b363SPhilipp Reisner case 0: 2622b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2623b411b363SPhilipp Reisner break; 2624b411b363SPhilipp Reisner case 1: 2625b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2626b411b363SPhilipp Reisner break; 2627b411b363SPhilipp Reisner case 2: 2628b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2629b411b363SPhilipp Reisner break; 2630b411b363SPhilipp Reisner } 2631b411b363SPhilipp Reisner if (abs(hg) < 100) { 2632b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2633b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2634b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2635b411b363SPhilipp Reisner if (forced) { 2636b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2637b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2638b411b363SPhilipp Reisner hg = hg*2; 2639b411b363SPhilipp Reisner } 2640b411b363SPhilipp Reisner } 2641b411b363SPhilipp Reisner } 2642b411b363SPhilipp Reisner 2643b411b363SPhilipp Reisner if (hg == -100) { 264489e58e75SPhilipp Reisner if (mdev->tconn->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2645b411b363SPhilipp Reisner hg = -1; 264689e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2647b411b363SPhilipp Reisner hg = 1; 2648b411b363SPhilipp Reisner 2649b411b363SPhilipp Reisner if (abs(hg) < 100) 2650b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2651b411b363SPhilipp Reisner "Sync from %s node\n", 2652b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2653b411b363SPhilipp Reisner } 2654b411b363SPhilipp Reisner 2655b411b363SPhilipp Reisner if (hg == -100) { 2656580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2657580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2658580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2659580b9767SLars Ellenberg * to that disk, in a way... */ 26603a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2661b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2662b411b363SPhilipp Reisner return C_MASK; 2663b411b363SPhilipp Reisner } 2664b411b363SPhilipp Reisner 2665b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2666b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2667b411b363SPhilipp Reisner return C_MASK; 2668b411b363SPhilipp Reisner } 2669b411b363SPhilipp Reisner 2670b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2671b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 267289e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->rr_conflict) { 2673b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2674b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2675b411b363SPhilipp Reisner /* fall through */ 2676b411b363SPhilipp Reisner case ASB_DISCONNECT: 2677b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2678b411b363SPhilipp Reisner return C_MASK; 2679b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2680b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2681b411b363SPhilipp Reisner "assumption\n"); 2682b411b363SPhilipp Reisner } 2683b411b363SPhilipp Reisner } 2684b411b363SPhilipp Reisner 268589e58e75SPhilipp Reisner if (mdev->tconn->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->flags)) { 2686cf14c2e9SPhilipp Reisner if (hg == 0) 2687cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2688cf14c2e9SPhilipp Reisner else 2689cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2690cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2691cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2692cf14c2e9SPhilipp Reisner return C_MASK; 2693cf14c2e9SPhilipp Reisner } 2694cf14c2e9SPhilipp Reisner 2695b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2696b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 269720ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 269820ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2699b411b363SPhilipp Reisner return C_MASK; 2700b411b363SPhilipp Reisner } 2701b411b363SPhilipp Reisner 2702b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2703b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2704b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2705b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2706b411b363SPhilipp Reisner } else { 2707b411b363SPhilipp Reisner rv = C_CONNECTED; 2708b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2709b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2710b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2711b411b363SPhilipp Reisner } 2712b411b363SPhilipp Reisner } 2713b411b363SPhilipp Reisner 2714b411b363SPhilipp Reisner return rv; 2715b411b363SPhilipp Reisner } 2716b411b363SPhilipp Reisner 2717b411b363SPhilipp Reisner /* returns 1 if invalid */ 2718b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2719b411b363SPhilipp Reisner { 2720b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2721b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2722b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2723b411b363SPhilipp Reisner return 0; 2724b411b363SPhilipp Reisner 2725b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2726b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2727b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2728b411b363SPhilipp Reisner return 1; 2729b411b363SPhilipp Reisner 2730b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2731b411b363SPhilipp Reisner if (peer == self) 2732b411b363SPhilipp Reisner return 0; 2733b411b363SPhilipp Reisner 2734b411b363SPhilipp Reisner /* everything es is invalid. */ 2735b411b363SPhilipp Reisner return 1; 2736b411b363SPhilipp Reisner } 2737b411b363SPhilipp Reisner 2738d8763023SAndreas Gruenbacher static int receive_protocol(struct drbd_conf *mdev, enum drbd_packet cmd, 2739d8763023SAndreas Gruenbacher unsigned int data_size) 2740b411b363SPhilipp Reisner { 2741e42325a5SPhilipp Reisner struct p_protocol *p = &mdev->tconn->data.rbuf.protocol; 2742b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2743cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2744b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2745b411b363SPhilipp Reisner 2746b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2747b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2748b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2749b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2750b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2751cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2752cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2753cf14c2e9SPhilipp Reisner 2754cf14c2e9SPhilipp Reisner clear_bit(CONN_DRY_RUN, &mdev->flags); 2755cf14c2e9SPhilipp Reisner 2756cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 2757cf14c2e9SPhilipp Reisner set_bit(CONN_DRY_RUN, &mdev->flags); 2758b411b363SPhilipp Reisner 275989e58e75SPhilipp Reisner if (p_proto != mdev->tconn->net_conf->wire_protocol) { 2760b411b363SPhilipp Reisner dev_err(DEV, "incompatible communication protocols\n"); 2761b411b363SPhilipp Reisner goto disconnect; 2762b411b363SPhilipp Reisner } 2763b411b363SPhilipp Reisner 276489e58e75SPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, mdev->tconn->net_conf->after_sb_0p)) { 2765b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-0pri settings\n"); 2766b411b363SPhilipp Reisner goto disconnect; 2767b411b363SPhilipp Reisner } 2768b411b363SPhilipp Reisner 276989e58e75SPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, mdev->tconn->net_conf->after_sb_1p)) { 2770b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-1pri settings\n"); 2771b411b363SPhilipp Reisner goto disconnect; 2772b411b363SPhilipp Reisner } 2773b411b363SPhilipp Reisner 277489e58e75SPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, mdev->tconn->net_conf->after_sb_2p)) { 2775b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-2pri settings\n"); 2776b411b363SPhilipp Reisner goto disconnect; 2777b411b363SPhilipp Reisner } 2778b411b363SPhilipp Reisner 277989e58e75SPhilipp Reisner if (p_want_lose && mdev->tconn->net_conf->want_lose) { 2780b411b363SPhilipp Reisner dev_err(DEV, "both sides have the 'want_lose' flag set\n"); 2781b411b363SPhilipp Reisner goto disconnect; 2782b411b363SPhilipp Reisner } 2783b411b363SPhilipp Reisner 278489e58e75SPhilipp Reisner if (p_two_primaries != mdev->tconn->net_conf->two_primaries) { 2785b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the two-primaries options\n"); 2786b411b363SPhilipp Reisner goto disconnect; 2787b411b363SPhilipp Reisner } 2788b411b363SPhilipp Reisner 278931890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version >= 87) { 279089e58e75SPhilipp Reisner unsigned char *my_alg = mdev->tconn->net_conf->integrity_alg; 2791b411b363SPhilipp Reisner 2792b411b363SPhilipp Reisner if (drbd_recv(mdev, p_integrity_alg, data_size) != data_size) 279381e84650SAndreas Gruenbacher return false; 2794b411b363SPhilipp Reisner 2795b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2796b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 2797b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the data-integrity-alg\n"); 2798b411b363SPhilipp Reisner goto disconnect; 2799b411b363SPhilipp Reisner } 2800b411b363SPhilipp Reisner dev_info(DEV, "data-integrity-alg: %s\n", 2801b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2802b411b363SPhilipp Reisner } 2803b411b363SPhilipp Reisner 280481e84650SAndreas Gruenbacher return true; 2805b411b363SPhilipp Reisner 2806b411b363SPhilipp Reisner disconnect: 2807b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 280881e84650SAndreas Gruenbacher return false; 2809b411b363SPhilipp Reisner } 2810b411b363SPhilipp Reisner 2811b411b363SPhilipp Reisner /* helper function 2812b411b363SPhilipp Reisner * input: alg name, feature name 2813b411b363SPhilipp Reisner * return: NULL (alg name was "") 2814b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2815b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2816b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2817b411b363SPhilipp Reisner const char *alg, const char *name) 2818b411b363SPhilipp Reisner { 2819b411b363SPhilipp Reisner struct crypto_hash *tfm; 2820b411b363SPhilipp Reisner 2821b411b363SPhilipp Reisner if (!alg[0]) 2822b411b363SPhilipp Reisner return NULL; 2823b411b363SPhilipp Reisner 2824b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2825b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 2826b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 2827b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 2828b411b363SPhilipp Reisner return tfm; 2829b411b363SPhilipp Reisner } 2830b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 2831b411b363SPhilipp Reisner crypto_free_hash(tfm); 2832b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 2833b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 2834b411b363SPhilipp Reisner } 2835b411b363SPhilipp Reisner return tfm; 2836b411b363SPhilipp Reisner } 2837b411b363SPhilipp Reisner 2838d8763023SAndreas Gruenbacher static int receive_SyncParam(struct drbd_conf *mdev, enum drbd_packet cmd, 2839d8763023SAndreas Gruenbacher unsigned int packet_size) 2840b411b363SPhilipp Reisner { 284181e84650SAndreas Gruenbacher int ok = true; 2842e42325a5SPhilipp Reisner struct p_rs_param_95 *p = &mdev->tconn->data.rbuf.rs_param_95; 2843b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 2844b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 2845b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 284631890f4aSPhilipp Reisner const int apv = mdev->tconn->agreed_pro_version; 2847778f271dSPhilipp Reisner int *rs_plan_s = NULL; 2848778f271dSPhilipp Reisner int fifo_size = 0; 2849b411b363SPhilipp Reisner 2850b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 2851b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 2852b411b363SPhilipp Reisner + SHARED_SECRET_MAX 28538e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 28548e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 2855b411b363SPhilipp Reisner 285602918be2SPhilipp Reisner if (packet_size > exp_max_sz) { 2857b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 285802918be2SPhilipp Reisner packet_size, exp_max_sz); 285981e84650SAndreas Gruenbacher return false; 2860b411b363SPhilipp Reisner } 2861b411b363SPhilipp Reisner 2862b411b363SPhilipp Reisner if (apv <= 88) { 2863257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param) - sizeof(struct p_header); 286402918be2SPhilipp Reisner data_size = packet_size - header_size; 28658e26f9ccSPhilipp Reisner } else if (apv <= 94) { 2866257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header); 286702918be2SPhilipp Reisner data_size = packet_size - header_size; 2868b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 28698e26f9ccSPhilipp Reisner } else { 2870257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header); 287102918be2SPhilipp Reisner data_size = packet_size - header_size; 2872b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 2873b411b363SPhilipp Reisner } 2874b411b363SPhilipp Reisner 2875b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 2876b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 2877b411b363SPhilipp Reisner 287802918be2SPhilipp Reisner if (drbd_recv(mdev, &p->head.payload, header_size) != header_size) 287981e84650SAndreas Gruenbacher return false; 2880b411b363SPhilipp Reisner 2881b411b363SPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 2882b411b363SPhilipp Reisner 2883b411b363SPhilipp Reisner if (apv >= 88) { 2884b411b363SPhilipp Reisner if (apv == 88) { 2885b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 2886b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 2887b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 2888b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 288981e84650SAndreas Gruenbacher return false; 2890b411b363SPhilipp Reisner } 2891b411b363SPhilipp Reisner 2892b411b363SPhilipp Reisner if (drbd_recv(mdev, p->verify_alg, data_size) != data_size) 289381e84650SAndreas Gruenbacher return false; 2894b411b363SPhilipp Reisner 2895b411b363SPhilipp Reisner /* we expect NUL terminated string */ 2896b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2897b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 2898b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 2899b411b363SPhilipp Reisner 2900b411b363SPhilipp Reisner } else /* apv >= 89 */ { 2901b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 2902b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2903b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 2904b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 2905b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 2906b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 2907b411b363SPhilipp Reisner } 2908b411b363SPhilipp Reisner 2909b411b363SPhilipp Reisner if (strcmp(mdev->sync_conf.verify_alg, p->verify_alg)) { 2910b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2911b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 2912b411b363SPhilipp Reisner mdev->sync_conf.verify_alg, p->verify_alg); 2913b411b363SPhilipp Reisner goto disconnect; 2914b411b363SPhilipp Reisner } 2915b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 2916b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 2917b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 2918b411b363SPhilipp Reisner verify_tfm = NULL; 2919b411b363SPhilipp Reisner goto disconnect; 2920b411b363SPhilipp Reisner } 2921b411b363SPhilipp Reisner } 2922b411b363SPhilipp Reisner 2923b411b363SPhilipp Reisner if (apv >= 89 && strcmp(mdev->sync_conf.csums_alg, p->csums_alg)) { 2924b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2925b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 2926b411b363SPhilipp Reisner mdev->sync_conf.csums_alg, p->csums_alg); 2927b411b363SPhilipp Reisner goto disconnect; 2928b411b363SPhilipp Reisner } 2929b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 2930b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 2931b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 2932b411b363SPhilipp Reisner csums_tfm = NULL; 2933b411b363SPhilipp Reisner goto disconnect; 2934b411b363SPhilipp Reisner } 2935b411b363SPhilipp Reisner } 2936b411b363SPhilipp Reisner 29378e26f9ccSPhilipp Reisner if (apv > 94) { 29388e26f9ccSPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 29398e26f9ccSPhilipp Reisner mdev->sync_conf.c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 29408e26f9ccSPhilipp Reisner mdev->sync_conf.c_delay_target = be32_to_cpu(p->c_delay_target); 29418e26f9ccSPhilipp Reisner mdev->sync_conf.c_fill_target = be32_to_cpu(p->c_fill_target); 29428e26f9ccSPhilipp Reisner mdev->sync_conf.c_max_rate = be32_to_cpu(p->c_max_rate); 2943778f271dSPhilipp Reisner 2944778f271dSPhilipp Reisner fifo_size = (mdev->sync_conf.c_plan_ahead * 10 * SLEEP_TIME) / HZ; 2945778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) { 2946778f271dSPhilipp Reisner rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL); 2947778f271dSPhilipp Reisner if (!rs_plan_s) { 2948778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 2949778f271dSPhilipp Reisner goto disconnect; 2950778f271dSPhilipp Reisner } 2951778f271dSPhilipp Reisner } 29528e26f9ccSPhilipp Reisner } 2953b411b363SPhilipp Reisner 2954b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 2955b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 2956b411b363SPhilipp Reisner if (verify_tfm) { 2957b411b363SPhilipp Reisner strcpy(mdev->sync_conf.verify_alg, p->verify_alg); 2958b411b363SPhilipp Reisner mdev->sync_conf.verify_alg_len = strlen(p->verify_alg) + 1; 2959b411b363SPhilipp Reisner crypto_free_hash(mdev->verify_tfm); 2960b411b363SPhilipp Reisner mdev->verify_tfm = verify_tfm; 2961b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 2962b411b363SPhilipp Reisner } 2963b411b363SPhilipp Reisner if (csums_tfm) { 2964b411b363SPhilipp Reisner strcpy(mdev->sync_conf.csums_alg, p->csums_alg); 2965b411b363SPhilipp Reisner mdev->sync_conf.csums_alg_len = strlen(p->csums_alg) + 1; 2966b411b363SPhilipp Reisner crypto_free_hash(mdev->csums_tfm); 2967b411b363SPhilipp Reisner mdev->csums_tfm = csums_tfm; 2968b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 2969b411b363SPhilipp Reisner } 2970778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size) { 2971778f271dSPhilipp Reisner kfree(mdev->rs_plan_s.values); 2972778f271dSPhilipp Reisner mdev->rs_plan_s.values = rs_plan_s; 2973778f271dSPhilipp Reisner mdev->rs_plan_s.size = fifo_size; 2974778f271dSPhilipp Reisner mdev->rs_planed = 0; 2975778f271dSPhilipp Reisner } 2976b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 2977b411b363SPhilipp Reisner } 2978b411b363SPhilipp Reisner 2979b411b363SPhilipp Reisner return ok; 2980b411b363SPhilipp Reisner disconnect: 2981b411b363SPhilipp Reisner /* just for completeness: actually not needed, 2982b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 2983b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 2984b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 2985b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 2986b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 298781e84650SAndreas Gruenbacher return false; 2988b411b363SPhilipp Reisner } 2989b411b363SPhilipp Reisner 2990b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 2991b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 2992b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 2993b411b363SPhilipp Reisner { 2994b411b363SPhilipp Reisner sector_t d; 2995b411b363SPhilipp Reisner if (a == 0 || b == 0) 2996b411b363SPhilipp Reisner return; 2997b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 2998b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 2999b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3000b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3001b411b363SPhilipp Reisner } 3002b411b363SPhilipp Reisner 3003d8763023SAndreas Gruenbacher static int receive_sizes(struct drbd_conf *mdev, enum drbd_packet cmd, 3004d8763023SAndreas Gruenbacher unsigned int data_size) 3005b411b363SPhilipp Reisner { 3006e42325a5SPhilipp Reisner struct p_sizes *p = &mdev->tconn->data.rbuf.sizes; 3007b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3008b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3009b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3010e89b591cSPhilipp Reisner enum dds_flags ddsf; 3011b411b363SPhilipp Reisner 3012b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3013b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3014b411b363SPhilipp Reisner 3015b411b363SPhilipp Reisner if (p_size == 0 && mdev->state.disk == D_DISKLESS) { 3016b411b363SPhilipp Reisner dev_err(DEV, "some backing storage is needed\n"); 3017b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 301881e84650SAndreas Gruenbacher return false; 3019b411b363SPhilipp Reisner } 3020b411b363SPhilipp Reisner 3021b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3022b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3023b411b363SPhilipp Reisner mdev->p_size = p_size; 3024b411b363SPhilipp Reisner 3025b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3026b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3027b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3028b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3029b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 3030b411b363SPhilipp Reisner 3031b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3032b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3033b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3034b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 3035b411b363SPhilipp Reisner p_usize); 3036b411b363SPhilipp Reisner 3037b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 3038b411b363SPhilipp Reisner 3039b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 3040b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 3041b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3042b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 3043b411b363SPhilipp Reisner } 3044b411b363SPhilipp Reisner 3045b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3046b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3047a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 3048b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3049b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3050b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3051b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 3052b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3053b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 3054b411b363SPhilipp Reisner put_ldev(mdev); 305581e84650SAndreas Gruenbacher return false; 3056b411b363SPhilipp Reisner } 3057b411b363SPhilipp Reisner put_ldev(mdev); 3058b411b363SPhilipp Reisner } 3059b411b363SPhilipp Reisner 3060e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3061b411b363SPhilipp Reisner if (get_ldev(mdev)) { 306224c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3063b411b363SPhilipp Reisner put_ldev(mdev); 3064b411b363SPhilipp Reisner if (dd == dev_size_error) 306581e84650SAndreas Gruenbacher return false; 3066b411b363SPhilipp Reisner drbd_md_sync(mdev); 3067b411b363SPhilipp Reisner } else { 3068b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3069b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3070b411b363SPhilipp Reisner } 3071b411b363SPhilipp Reisner 307299432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 307399432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 307499432fccSPhilipp Reisner 3075b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3076b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3077b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3078b411b363SPhilipp Reisner ldsc = 1; 3079b411b363SPhilipp Reisner } 3080b411b363SPhilipp Reisner 3081b411b363SPhilipp Reisner put_ldev(mdev); 3082b411b363SPhilipp Reisner } 3083b411b363SPhilipp Reisner 3084b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3085b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3086b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3087b411b363SPhilipp Reisner /* we have different sizes, probably peer 3088b411b363SPhilipp Reisner * needs to know my new size... */ 3089e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3090b411b363SPhilipp Reisner } 3091b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3092b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3093b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3094e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3095e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3096e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3097b411b363SPhilipp Reisner else 3098e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3099e89b591cSPhilipp Reisner } else 3100b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3101b411b363SPhilipp Reisner } 3102b411b363SPhilipp Reisner } 3103b411b363SPhilipp Reisner 310481e84650SAndreas Gruenbacher return true; 3105b411b363SPhilipp Reisner } 3106b411b363SPhilipp Reisner 3107d8763023SAndreas Gruenbacher static int receive_uuids(struct drbd_conf *mdev, enum drbd_packet cmd, 3108d8763023SAndreas Gruenbacher unsigned int data_size) 3109b411b363SPhilipp Reisner { 3110e42325a5SPhilipp Reisner struct p_uuids *p = &mdev->tconn->data.rbuf.uuids; 3111b411b363SPhilipp Reisner u64 *p_uuid; 311262b0da3aSLars Ellenberg int i, updated_uuids = 0; 3113b411b363SPhilipp Reisner 3114b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3115b411b363SPhilipp Reisner 3116b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3117b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3118b411b363SPhilipp Reisner 3119b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3120b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3121b411b363SPhilipp Reisner 3122b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3123b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3124b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3125b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3126b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3127b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 3128b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 312981e84650SAndreas Gruenbacher return false; 3130b411b363SPhilipp Reisner } 3131b411b363SPhilipp Reisner 3132b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3133b411b363SPhilipp Reisner int skip_initial_sync = 3134b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 313531890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3136b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3137b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3138b411b363SPhilipp Reisner if (skip_initial_sync) { 3139b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3140b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 314120ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 314220ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3143b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3144b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3145b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3146b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3147b411b363SPhilipp Reisner drbd_md_sync(mdev); 314862b0da3aSLars Ellenberg updated_uuids = 1; 3149b411b363SPhilipp Reisner } 3150b411b363SPhilipp Reisner put_ldev(mdev); 315118a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 315218a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 315318a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 315418a50fa2SPhilipp Reisner for me. */ 315562b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3156b411b363SPhilipp Reisner } 3157b411b363SPhilipp Reisner 3158b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3159b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3160b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3161b411b363SPhilipp Reisner new disk state... */ 3162b411b363SPhilipp Reisner wait_event(mdev->misc_wait, !test_bit(CLUSTER_ST_CHANGE, &mdev->flags)); 3163b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 316462b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 316562b0da3aSLars Ellenberg 316662b0da3aSLars Ellenberg if (updated_uuids) 316762b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3168b411b363SPhilipp Reisner 316981e84650SAndreas Gruenbacher return true; 3170b411b363SPhilipp Reisner } 3171b411b363SPhilipp Reisner 3172b411b363SPhilipp Reisner /** 3173b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3174b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3175b411b363SPhilipp Reisner */ 3176b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3177b411b363SPhilipp Reisner { 3178b411b363SPhilipp Reisner union drbd_state ms; 3179b411b363SPhilipp Reisner 3180b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3181b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3182b411b363SPhilipp Reisner 3183b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3184b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3185b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3186b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3187b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3188b411b363SPhilipp Reisner }; 3189b411b363SPhilipp Reisner 3190b411b363SPhilipp Reisner ms.i = ps.i; 3191b411b363SPhilipp Reisner 3192b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3193b411b363SPhilipp Reisner ms.peer = ps.role; 3194b411b363SPhilipp Reisner ms.role = ps.peer; 3195b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3196b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3197b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3198b411b363SPhilipp Reisner 3199b411b363SPhilipp Reisner return ms; 3200b411b363SPhilipp Reisner } 3201b411b363SPhilipp Reisner 3202d8763023SAndreas Gruenbacher static int receive_req_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3203d8763023SAndreas Gruenbacher unsigned int data_size) 3204b411b363SPhilipp Reisner { 3205e42325a5SPhilipp Reisner struct p_req_state *p = &mdev->tconn->data.rbuf.req_state; 3206b411b363SPhilipp Reisner union drbd_state mask, val; 3207bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3208b411b363SPhilipp Reisner 3209b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3210b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3211b411b363SPhilipp Reisner 321225703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 3213b411b363SPhilipp Reisner test_bit(CLUSTER_ST_CHANGE, &mdev->flags)) { 3214b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 321581e84650SAndreas Gruenbacher return true; 3216b411b363SPhilipp Reisner } 3217b411b363SPhilipp Reisner 3218b411b363SPhilipp Reisner mask = convert_state(mask); 3219b411b363SPhilipp Reisner val = convert_state(val); 3220b411b363SPhilipp Reisner 3221b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3222b411b363SPhilipp Reisner 3223b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3224b411b363SPhilipp Reisner drbd_md_sync(mdev); 3225b411b363SPhilipp Reisner 322681e84650SAndreas Gruenbacher return true; 3227b411b363SPhilipp Reisner } 3228b411b363SPhilipp Reisner 3229d8763023SAndreas Gruenbacher static int receive_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3230d8763023SAndreas Gruenbacher unsigned int data_size) 3231b411b363SPhilipp Reisner { 3232e42325a5SPhilipp Reisner struct p_state *p = &mdev->tconn->data.rbuf.state; 32334ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3234b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 323565d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3236b411b363SPhilipp Reisner int rv; 3237b411b363SPhilipp Reisner 3238b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3239b411b363SPhilipp Reisner 3240b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3241b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3242b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3243b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3244b411b363SPhilipp Reisner } 3245b411b363SPhilipp Reisner 324687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3247b411b363SPhilipp Reisner retry: 32484ac4aadaSLars Ellenberg os = ns = mdev->state; 324987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3250b411b363SPhilipp Reisner 3251e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3252e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3253e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3254e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3255e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3256e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3257e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3258e9ef7bb6SLars Ellenberg * syncing states. 3259e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3260e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3261e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3262e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3263e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3264e9ef7bb6SLars Ellenberg 3265e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3266e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3267e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3268e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3269e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3270e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3271e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 327281e84650SAndreas Gruenbacher return true; 3273e9ef7bb6SLars Ellenberg } 3274e9ef7bb6SLars Ellenberg } 3275e9ef7bb6SLars Ellenberg 3276e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3277e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3278e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3279e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3280e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3281e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3282e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3283e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3284e9ef7bb6SLars Ellenberg 32854ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 32864ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3287b411b363SPhilipp Reisner 328867531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 328967531718SPhilipp Reisner ns.conn = C_BEHIND; 329067531718SPhilipp Reisner 3291b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3292b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3293b411b363SPhilipp Reisner int cr; /* consider resync */ 3294b411b363SPhilipp Reisner 3295b411b363SPhilipp Reisner /* if we established a new connection */ 32964ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3297b411b363SPhilipp Reisner /* if we had an established connection 3298b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 32994ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3300b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 33014ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3302b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3303b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3304b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3305b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3306b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 33074ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3308b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3309b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3310b411b363SPhilipp Reisner 3311b411b363SPhilipp Reisner if (cr) 33124ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3313b411b363SPhilipp Reisner 3314b411b363SPhilipp Reisner put_ldev(mdev); 33154ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 33164ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3317b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 331882f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3319b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3320b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3321b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3322580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3323b411b363SPhilipp Reisner } else { 3324cf14c2e9SPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->flags)) 332581e84650SAndreas Gruenbacher return false; 33264ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 3327b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 332881e84650SAndreas Gruenbacher return false; 3329b411b363SPhilipp Reisner } 3330b411b363SPhilipp Reisner } 3331b411b363SPhilipp Reisner } 3332b411b363SPhilipp Reisner 333387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 33344ac4aadaSLars Ellenberg if (mdev->state.i != os.i) 3335b411b363SPhilipp Reisner goto retry; 3336b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3337b411b363SPhilipp Reisner ns.peer = peer_state.role; 3338b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3339b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 33404ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3341b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 33424ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 33434ac4aadaSLars Ellenberg if (ns.pdsk == D_CONSISTENT && is_susp(ns) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3344481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 33458554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3346481c6f50SPhilipp Reisner for temporal network outages! */ 334787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3348481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 3349481c6f50SPhilipp Reisner tl_clear(mdev); 3350481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3351481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 3352481c6f50SPhilipp Reisner drbd_force_state(mdev, NS2(conn, C_PROTOCOL_ERROR, susp, 0)); 335381e84650SAndreas Gruenbacher return false; 3354481c6f50SPhilipp Reisner } 335565d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 3356b411b363SPhilipp Reisner ns = mdev->state; 335787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3358b411b363SPhilipp Reisner 3359b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 3360b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 336181e84650SAndreas Gruenbacher return false; 3362b411b363SPhilipp Reisner } 3363b411b363SPhilipp Reisner 33644ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 33654ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3366b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3367b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3368b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3369b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3370b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3371b411b363SPhilipp Reisner drbd_send_state(mdev); 3372b411b363SPhilipp Reisner } 3373b411b363SPhilipp Reisner } 3374b411b363SPhilipp Reisner 337589e58e75SPhilipp Reisner mdev->tconn->net_conf->want_lose = 0; 3376b411b363SPhilipp Reisner 3377b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3378b411b363SPhilipp Reisner 337981e84650SAndreas Gruenbacher return true; 3380b411b363SPhilipp Reisner } 3381b411b363SPhilipp Reisner 3382d8763023SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_conf *mdev, enum drbd_packet cmd, 3383d8763023SAndreas Gruenbacher unsigned int data_size) 3384b411b363SPhilipp Reisner { 3385e42325a5SPhilipp Reisner struct p_rs_uuid *p = &mdev->tconn->data.rbuf.rs_uuid; 3386b411b363SPhilipp Reisner 3387b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3388b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3389c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3390b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3391b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3392b411b363SPhilipp Reisner 3393b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3394b411b363SPhilipp Reisner 3395b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3396b411b363SPhilipp Reisner _not_ be rotated into the history */ 3397b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3398b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3399b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3400b411b363SPhilipp Reisner 340162b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3402b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3403b411b363SPhilipp Reisner 3404b411b363SPhilipp Reisner put_ldev(mdev); 3405b411b363SPhilipp Reisner } else 3406b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3407b411b363SPhilipp Reisner 340881e84650SAndreas Gruenbacher return true; 3409b411b363SPhilipp Reisner } 3410b411b363SPhilipp Reisner 34112c46407dSAndreas Gruenbacher /** 34122c46407dSAndreas Gruenbacher * receive_bitmap_plain 34132c46407dSAndreas Gruenbacher * 34142c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 34152c46407dSAndreas Gruenbacher * code upon failure. 34162c46407dSAndreas Gruenbacher */ 34172c46407dSAndreas Gruenbacher static int 341802918be2SPhilipp Reisner receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size, 3419b411b363SPhilipp Reisner unsigned long *buffer, struct bm_xfer_ctx *c) 3420b411b363SPhilipp Reisner { 3421b411b363SPhilipp Reisner unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset); 3422b411b363SPhilipp Reisner unsigned want = num_words * sizeof(long); 34232c46407dSAndreas Gruenbacher int err; 3424b411b363SPhilipp Reisner 342502918be2SPhilipp Reisner if (want != data_size) { 342602918be2SPhilipp Reisner dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size); 34272c46407dSAndreas Gruenbacher return -EIO; 3428b411b363SPhilipp Reisner } 3429b411b363SPhilipp Reisner if (want == 0) 34302c46407dSAndreas Gruenbacher return 0; 34312c46407dSAndreas Gruenbacher err = drbd_recv(mdev, buffer, want); 34322c46407dSAndreas Gruenbacher if (err != want) { 34332c46407dSAndreas Gruenbacher if (err >= 0) 34342c46407dSAndreas Gruenbacher err = -EIO; 34352c46407dSAndreas Gruenbacher return err; 34362c46407dSAndreas Gruenbacher } 3437b411b363SPhilipp Reisner 3438b411b363SPhilipp Reisner drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer); 3439b411b363SPhilipp Reisner 3440b411b363SPhilipp Reisner c->word_offset += num_words; 3441b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3442b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3443b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3444b411b363SPhilipp Reisner 34452c46407dSAndreas Gruenbacher return 1; 3446b411b363SPhilipp Reisner } 3447b411b363SPhilipp Reisner 34482c46407dSAndreas Gruenbacher /** 34492c46407dSAndreas Gruenbacher * recv_bm_rle_bits 34502c46407dSAndreas Gruenbacher * 34512c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 34522c46407dSAndreas Gruenbacher * code upon failure. 34532c46407dSAndreas Gruenbacher */ 34542c46407dSAndreas Gruenbacher static int 3455b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3456b411b363SPhilipp Reisner struct p_compressed_bm *p, 3457c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3458c6d25cfeSPhilipp Reisner unsigned int len) 3459b411b363SPhilipp Reisner { 3460b411b363SPhilipp Reisner struct bitstream bs; 3461b411b363SPhilipp Reisner u64 look_ahead; 3462b411b363SPhilipp Reisner u64 rl; 3463b411b363SPhilipp Reisner u64 tmp; 3464b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3465b411b363SPhilipp Reisner unsigned long e; 3466b411b363SPhilipp Reisner int toggle = DCBP_get_start(p); 3467b411b363SPhilipp Reisner int have; 3468b411b363SPhilipp Reisner int bits; 3469b411b363SPhilipp Reisner 3470b411b363SPhilipp Reisner bitstream_init(&bs, p->code, len, DCBP_get_pad_bits(p)); 3471b411b363SPhilipp Reisner 3472b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3473b411b363SPhilipp Reisner if (bits < 0) 34742c46407dSAndreas Gruenbacher return -EIO; 3475b411b363SPhilipp Reisner 3476b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3477b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3478b411b363SPhilipp Reisner if (bits <= 0) 34792c46407dSAndreas Gruenbacher return -EIO; 3480b411b363SPhilipp Reisner 3481b411b363SPhilipp Reisner if (toggle) { 3482b411b363SPhilipp Reisner e = s + rl -1; 3483b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3484b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 34852c46407dSAndreas Gruenbacher return -EIO; 3486b411b363SPhilipp Reisner } 3487b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3488b411b363SPhilipp Reisner } 3489b411b363SPhilipp Reisner 3490b411b363SPhilipp Reisner if (have < bits) { 3491b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3492b411b363SPhilipp Reisner have, bits, look_ahead, 3493b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3494b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 34952c46407dSAndreas Gruenbacher return -EIO; 3496b411b363SPhilipp Reisner } 3497b411b363SPhilipp Reisner look_ahead >>= bits; 3498b411b363SPhilipp Reisner have -= bits; 3499b411b363SPhilipp Reisner 3500b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3501b411b363SPhilipp Reisner if (bits < 0) 35022c46407dSAndreas Gruenbacher return -EIO; 3503b411b363SPhilipp Reisner look_ahead |= tmp << have; 3504b411b363SPhilipp Reisner have += bits; 3505b411b363SPhilipp Reisner } 3506b411b363SPhilipp Reisner 3507b411b363SPhilipp Reisner c->bit_offset = s; 3508b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3509b411b363SPhilipp Reisner 35102c46407dSAndreas Gruenbacher return (s != c->bm_bits); 3511b411b363SPhilipp Reisner } 3512b411b363SPhilipp Reisner 35132c46407dSAndreas Gruenbacher /** 35142c46407dSAndreas Gruenbacher * decode_bitmap_c 35152c46407dSAndreas Gruenbacher * 35162c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 35172c46407dSAndreas Gruenbacher * code upon failure. 35182c46407dSAndreas Gruenbacher */ 35192c46407dSAndreas Gruenbacher static int 3520b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3521b411b363SPhilipp Reisner struct p_compressed_bm *p, 3522c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3523c6d25cfeSPhilipp Reisner unsigned int len) 3524b411b363SPhilipp Reisner { 3525b411b363SPhilipp Reisner if (DCBP_get_code(p) == RLE_VLI_Bits) 3526c6d25cfeSPhilipp Reisner return recv_bm_rle_bits(mdev, p, c, len); 3527b411b363SPhilipp Reisner 3528b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3529b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3530b411b363SPhilipp Reisner * during all our tests. */ 3531b411b363SPhilipp Reisner 3532b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 3533b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 35342c46407dSAndreas Gruenbacher return -EIO; 3535b411b363SPhilipp Reisner } 3536b411b363SPhilipp Reisner 3537b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3538b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3539b411b363SPhilipp Reisner { 3540b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 3541c012949aSPhilipp Reisner unsigned plain = sizeof(struct p_header) * 3542b411b363SPhilipp Reisner ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1) 3543b411b363SPhilipp Reisner + c->bm_words * sizeof(long); 3544b411b363SPhilipp Reisner unsigned total = c->bytes[0] + c->bytes[1]; 3545b411b363SPhilipp Reisner unsigned r; 3546b411b363SPhilipp Reisner 3547b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3548b411b363SPhilipp Reisner if (total == 0) 3549b411b363SPhilipp Reisner return; 3550b411b363SPhilipp Reisner 3551b411b363SPhilipp Reisner /* don't report if not compressed */ 3552b411b363SPhilipp Reisner if (total >= plain) 3553b411b363SPhilipp Reisner return; 3554b411b363SPhilipp Reisner 3555b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3556b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3557b411b363SPhilipp Reisner : (1000 * total / plain); 3558b411b363SPhilipp Reisner 3559b411b363SPhilipp Reisner if (r > 1000) 3560b411b363SPhilipp Reisner r = 1000; 3561b411b363SPhilipp Reisner 3562b411b363SPhilipp Reisner r = 1000 - r; 3563b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3564b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3565b411b363SPhilipp Reisner direction, 3566b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3567b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3568b411b363SPhilipp Reisner total, r/10, r % 10); 3569b411b363SPhilipp Reisner } 3570b411b363SPhilipp Reisner 3571b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3572b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3573b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3574b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3575b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3576b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3577b411b363SPhilipp Reisner 3578b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 3579d8763023SAndreas Gruenbacher static int receive_bitmap(struct drbd_conf *mdev, enum drbd_packet cmd, 3580d8763023SAndreas Gruenbacher unsigned int data_size) 3581b411b363SPhilipp Reisner { 3582b411b363SPhilipp Reisner struct bm_xfer_ctx c; 3583b411b363SPhilipp Reisner void *buffer; 35842c46407dSAndreas Gruenbacher int err; 358581e84650SAndreas Gruenbacher int ok = false; 3586257d0af6SPhilipp Reisner struct p_header *h = &mdev->tconn->data.rbuf.header; 3587b411b363SPhilipp Reisner 358820ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 358920ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 359020ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 3591b411b363SPhilipp Reisner 3592b411b363SPhilipp Reisner /* maybe we should use some per thread scratch page, 3593b411b363SPhilipp Reisner * and allocate that during initial device creation? */ 3594b411b363SPhilipp Reisner buffer = (unsigned long *) __get_free_page(GFP_NOIO); 3595b411b363SPhilipp Reisner if (!buffer) { 3596b411b363SPhilipp Reisner dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__); 3597b411b363SPhilipp Reisner goto out; 3598b411b363SPhilipp Reisner } 3599b411b363SPhilipp Reisner 3600b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3601b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3602b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3603b411b363SPhilipp Reisner }; 3604b411b363SPhilipp Reisner 36052c46407dSAndreas Gruenbacher for(;;) { 360602918be2SPhilipp Reisner if (cmd == P_BITMAP) { 36072c46407dSAndreas Gruenbacher err = receive_bitmap_plain(mdev, data_size, buffer, &c); 360802918be2SPhilipp Reisner } else if (cmd == P_COMPRESSED_BITMAP) { 3609b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3610b411b363SPhilipp Reisner * and the feature is enabled! */ 3611b411b363SPhilipp Reisner struct p_compressed_bm *p; 3612b411b363SPhilipp Reisner 361302918be2SPhilipp Reisner if (data_size > BM_PACKET_PAYLOAD_BYTES) { 3614b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 3615b411b363SPhilipp Reisner goto out; 3616b411b363SPhilipp Reisner } 3617b411b363SPhilipp Reisner /* use the page buff */ 3618b411b363SPhilipp Reisner p = buffer; 3619b411b363SPhilipp Reisner memcpy(p, h, sizeof(*h)); 362002918be2SPhilipp Reisner if (drbd_recv(mdev, p->head.payload, data_size) != data_size) 3621b411b363SPhilipp Reisner goto out; 3622004352faSLars Ellenberg if (data_size <= (sizeof(*p) - sizeof(p->head))) { 3623004352faSLars Ellenberg dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", data_size); 362478fcbdaeSAndreas Gruenbacher goto out; 3625b411b363SPhilipp Reisner } 3626c6d25cfeSPhilipp Reisner err = decode_bitmap_c(mdev, p, &c, data_size); 3627b411b363SPhilipp Reisner } else { 362802918be2SPhilipp Reisner dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", cmd); 3629b411b363SPhilipp Reisner goto out; 3630b411b363SPhilipp Reisner } 3631b411b363SPhilipp Reisner 363202918be2SPhilipp Reisner c.packets[cmd == P_BITMAP]++; 3633257d0af6SPhilipp Reisner c.bytes[cmd == P_BITMAP] += sizeof(struct p_header) + data_size; 3634b411b363SPhilipp Reisner 36352c46407dSAndreas Gruenbacher if (err <= 0) { 36362c46407dSAndreas Gruenbacher if (err < 0) 36372c46407dSAndreas Gruenbacher goto out; 3638b411b363SPhilipp Reisner break; 36392c46407dSAndreas Gruenbacher } 364002918be2SPhilipp Reisner if (!drbd_recv_header(mdev, &cmd, &data_size)) 3641b411b363SPhilipp Reisner goto out; 36422c46407dSAndreas Gruenbacher } 3643b411b363SPhilipp Reisner 3644b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3645b411b363SPhilipp Reisner 3646b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3647de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 3648de1f8e4aSAndreas Gruenbacher 3649b411b363SPhilipp Reisner ok = !drbd_send_bitmap(mdev); 3650b411b363SPhilipp Reisner if (!ok) 3651b411b363SPhilipp Reisner goto out; 3652b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3653de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3654de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 3655b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3656b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3657b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3658b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3659b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3660b411b363SPhilipp Reisner } 3661b411b363SPhilipp Reisner 366281e84650SAndreas Gruenbacher ok = true; 3663b411b363SPhilipp Reisner out: 366420ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 3665b411b363SPhilipp Reisner if (ok && mdev->state.conn == C_WF_BITMAP_S) 3666b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 3667b411b363SPhilipp Reisner free_page((unsigned long) buffer); 3668b411b363SPhilipp Reisner return ok; 3669b411b363SPhilipp Reisner } 3670b411b363SPhilipp Reisner 3671d8763023SAndreas Gruenbacher static int receive_skip(struct drbd_conf *mdev, enum drbd_packet cmd, 3672d8763023SAndreas Gruenbacher unsigned int data_size) 3673b411b363SPhilipp Reisner { 3674b411b363SPhilipp Reisner /* TODO zero copy sink :) */ 3675b411b363SPhilipp Reisner static char sink[128]; 3676b411b363SPhilipp Reisner int size, want, r; 3677b411b363SPhilipp Reisner 3678b411b363SPhilipp Reisner dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n", 367902918be2SPhilipp Reisner cmd, data_size); 3680b411b363SPhilipp Reisner 368102918be2SPhilipp Reisner size = data_size; 3682b411b363SPhilipp Reisner while (size > 0) { 3683b411b363SPhilipp Reisner want = min_t(int, size, sizeof(sink)); 3684b411b363SPhilipp Reisner r = drbd_recv(mdev, sink, want); 3685841ce241SAndreas Gruenbacher if (!expect(r > 0)) 3686841ce241SAndreas Gruenbacher break; 3687b411b363SPhilipp Reisner size -= r; 3688b411b363SPhilipp Reisner } 3689b411b363SPhilipp Reisner return size == 0; 3690b411b363SPhilipp Reisner } 3691b411b363SPhilipp Reisner 3692d8763023SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packet cmd, 3693d8763023SAndreas Gruenbacher unsigned int data_size) 3694b411b363SPhilipp Reisner { 3695b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3696b411b363SPhilipp Reisner * with the data requests being unplugged */ 3697e42325a5SPhilipp Reisner drbd_tcp_quickack(mdev->tconn->data.socket); 3698b411b363SPhilipp Reisner 369981e84650SAndreas Gruenbacher return true; 3700b411b363SPhilipp Reisner } 3701b411b363SPhilipp Reisner 3702d8763023SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_conf *mdev, enum drbd_packet cmd, 3703d8763023SAndreas Gruenbacher unsigned int data_size) 370473a01a18SPhilipp Reisner { 3705e42325a5SPhilipp Reisner struct p_block_desc *p = &mdev->tconn->data.rbuf.block_desc; 370673a01a18SPhilipp Reisner 3707f735e363SLars Ellenberg switch (mdev->state.conn) { 3708f735e363SLars Ellenberg case C_WF_SYNC_UUID: 3709f735e363SLars Ellenberg case C_WF_BITMAP_T: 3710f735e363SLars Ellenberg case C_BEHIND: 3711f735e363SLars Ellenberg break; 3712f735e363SLars Ellenberg default: 3713f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 3714f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 3715f735e363SLars Ellenberg } 3716f735e363SLars Ellenberg 371773a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 371873a01a18SPhilipp Reisner 371981e84650SAndreas Gruenbacher return true; 372073a01a18SPhilipp Reisner } 372173a01a18SPhilipp Reisner 3722d8763023SAndreas Gruenbacher typedef int (*drbd_cmd_handler_f)(struct drbd_conf *, enum drbd_packet cmd, 3723d8763023SAndreas Gruenbacher unsigned int to_receive); 3724b411b363SPhilipp Reisner 372502918be2SPhilipp Reisner struct data_cmd { 372602918be2SPhilipp Reisner int expect_payload; 372702918be2SPhilipp Reisner size_t pkt_size; 372802918be2SPhilipp Reisner drbd_cmd_handler_f function; 3729b411b363SPhilipp Reisner }; 3730b411b363SPhilipp Reisner 373102918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 373202918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 373302918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 373402918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 373502918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 3736257d0af6SPhilipp Reisner [P_BITMAP] = { 1, sizeof(struct p_header), receive_bitmap } , 3737257d0af6SPhilipp Reisner [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header), receive_bitmap } , 3738257d0af6SPhilipp Reisner [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header), receive_UnplugRemote }, 373902918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 374002918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 3741257d0af6SPhilipp Reisner [P_SYNC_PARAM] = { 1, sizeof(struct p_header), receive_SyncParam }, 3742257d0af6SPhilipp Reisner [P_SYNC_PARAM89] = { 1, sizeof(struct p_header), receive_SyncParam }, 374302918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 374402918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 374502918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 374602918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 374702918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 374802918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 374902918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 375002918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 375102918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 375202918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 375373a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 375402918be2SPhilipp Reisner /* anything missing from this table is in 375502918be2SPhilipp Reisner * the asender_tbl, see get_asender_cmd */ 375602918be2SPhilipp Reisner [P_MAX_CMD] = { 0, 0, NULL }, 375702918be2SPhilipp Reisner }; 375802918be2SPhilipp Reisner 375902918be2SPhilipp Reisner /* All handler functions that expect a sub-header get that sub-heder in 3760e42325a5SPhilipp Reisner mdev->tconn->data.rbuf.header.head.payload. 376102918be2SPhilipp Reisner 3762e42325a5SPhilipp Reisner Usually in mdev->tconn->data.rbuf.header.head the callback can find the usual 376302918be2SPhilipp Reisner p_header, but they may not rely on that. Since there is also p_header95 ! 376402918be2SPhilipp Reisner */ 3765b411b363SPhilipp Reisner 3766b411b363SPhilipp Reisner static void drbdd(struct drbd_conf *mdev) 3767b411b363SPhilipp Reisner { 3768c012949aSPhilipp Reisner struct p_header *header = &mdev->tconn->data.rbuf.header; 376902918be2SPhilipp Reisner unsigned int packet_size; 3770d8763023SAndreas Gruenbacher enum drbd_packet cmd; 377102918be2SPhilipp Reisner size_t shs; /* sub header size */ 377202918be2SPhilipp Reisner int rv; 3773b411b363SPhilipp Reisner 3774e6b3ea83SPhilipp Reisner while (get_t_state(&mdev->tconn->receiver) == RUNNING) { 3775bc31fe33SPhilipp Reisner drbd_thread_current_set_cpu(mdev, &mdev->tconn->receiver); 377602918be2SPhilipp Reisner if (!drbd_recv_header(mdev, &cmd, &packet_size)) 377702918be2SPhilipp Reisner goto err_out; 377802918be2SPhilipp Reisner 377902918be2SPhilipp Reisner if (unlikely(cmd >= P_MAX_CMD || !drbd_cmd_handler[cmd].function)) { 378002918be2SPhilipp Reisner dev_err(DEV, "unknown packet type %d, l: %d!\n", cmd, packet_size); 378102918be2SPhilipp Reisner goto err_out; 37820b33a916SLars Ellenberg } 3783b411b363SPhilipp Reisner 3784c012949aSPhilipp Reisner shs = drbd_cmd_handler[cmd].pkt_size - sizeof(struct p_header); 3785c13f7e1aSLars Ellenberg if (packet_size - shs > 0 && !drbd_cmd_handler[cmd].expect_payload) { 3786c13f7e1aSLars Ellenberg dev_err(DEV, "No payload expected %s l:%d\n", cmdname(cmd), packet_size); 3787c13f7e1aSLars Ellenberg goto err_out; 3788c13f7e1aSLars Ellenberg } 3789c13f7e1aSLars Ellenberg 3790c13f7e1aSLars Ellenberg if (shs) { 3791c012949aSPhilipp Reisner rv = drbd_recv(mdev, &header->payload, shs); 379202918be2SPhilipp Reisner if (unlikely(rv != shs)) { 37930ddc5549SLars Ellenberg if (!signal_pending(current)) 37940ddc5549SLars Ellenberg dev_warn(DEV, "short read while reading sub header: rv=%d\n", rv); 379502918be2SPhilipp Reisner goto err_out; 3796b411b363SPhilipp Reisner } 379702918be2SPhilipp Reisner } 379802918be2SPhilipp Reisner 379902918be2SPhilipp Reisner rv = drbd_cmd_handler[cmd].function(mdev, cmd, packet_size - shs); 380002918be2SPhilipp Reisner 380102918be2SPhilipp Reisner if (unlikely(!rv)) { 3802b411b363SPhilipp Reisner dev_err(DEV, "error receiving %s, l: %d!\n", 380302918be2SPhilipp Reisner cmdname(cmd), packet_size); 380402918be2SPhilipp Reisner goto err_out; 3805b411b363SPhilipp Reisner } 3806b411b363SPhilipp Reisner } 380702918be2SPhilipp Reisner 380802918be2SPhilipp Reisner if (0) { 380902918be2SPhilipp Reisner err_out: 3810b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 3811b411b363SPhilipp Reisner } 3812856c50c7SLars Ellenberg /* If we leave here, we probably want to update at least the 3813856c50c7SLars Ellenberg * "Connected" indicator on stable storage. Do so explicitly here. */ 3814856c50c7SLars Ellenberg drbd_md_sync(mdev); 3815b411b363SPhilipp Reisner } 3816b411b363SPhilipp Reisner 3817191d3cc8SPhilipp Reisner void drbd_flush_workqueue(struct drbd_tconn *tconn) 3818b411b363SPhilipp Reisner { 3819b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 3820b411b363SPhilipp Reisner 3821b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 3822b411b363SPhilipp Reisner init_completion(&barr.done); 3823191d3cc8SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 3824b411b363SPhilipp Reisner wait_for_completion(&barr.done); 3825b411b363SPhilipp Reisner } 3826b411b363SPhilipp Reisner 3827b411b363SPhilipp Reisner static void drbd_disconnect(struct drbd_conf *mdev) 3828b411b363SPhilipp Reisner { 3829b411b363SPhilipp Reisner enum drbd_fencing_p fp; 3830b411b363SPhilipp Reisner union drbd_state os, ns; 3831b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 3832b411b363SPhilipp Reisner unsigned int i; 3833b411b363SPhilipp Reisner 3834b411b363SPhilipp Reisner if (mdev->state.conn == C_STANDALONE) 3835b411b363SPhilipp Reisner return; 3836b411b363SPhilipp Reisner 3837b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 3838e6b3ea83SPhilipp Reisner drbd_thread_stop(&mdev->tconn->asender); 3839b411b363SPhilipp Reisner drbd_free_sock(mdev); 3840b411b363SPhilipp Reisner 384185719573SPhilipp Reisner /* wait for current activity to cease. */ 384287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3843b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 3844b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 3845b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 384687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3847b411b363SPhilipp Reisner 3848b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 3849b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 3850b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 3851b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 3852b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 3853b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 3854b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 3855b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 3856b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 3857b411b363SPhilipp Reisner * on the fly. */ 3858b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 3859b411b363SPhilipp Reisner mdev->rs_total = 0; 3860b411b363SPhilipp Reisner mdev->rs_failed = 0; 3861b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 3862b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 3863b411b363SPhilipp Reisner 38647fde2be9SPhilipp Reisner del_timer(&mdev->request_timer); 38657fde2be9SPhilipp Reisner 3866b411b363SPhilipp Reisner /* make sure syncer is stopped and w_resume_next_sg queued */ 3867b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 3868b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 3869b411b363SPhilipp Reisner 3870b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 3871b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 3872b411b363SPhilipp Reisner * to be "canceled" */ 3873191d3cc8SPhilipp Reisner drbd_flush_workqueue(mdev->tconn); 3874b411b363SPhilipp Reisner 3875b411b363SPhilipp Reisner /* This also does reclaim_net_ee(). If we do this too early, we might 3876b411b363SPhilipp Reisner * miss some resync ee and pages.*/ 3877b411b363SPhilipp Reisner drbd_process_done_ee(mdev); 3878b411b363SPhilipp Reisner 3879b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3880b411b363SPhilipp Reisner mdev->p_uuid = NULL; 3881b411b363SPhilipp Reisner 3882fb22c402SPhilipp Reisner if (!is_susp(mdev->state)) 3883b411b363SPhilipp Reisner tl_clear(mdev); 3884b411b363SPhilipp Reisner 3885b411b363SPhilipp Reisner dev_info(DEV, "Connection closed\n"); 3886b411b363SPhilipp Reisner 3887b411b363SPhilipp Reisner drbd_md_sync(mdev); 3888b411b363SPhilipp Reisner 3889b411b363SPhilipp Reisner fp = FP_DONT_CARE; 3890b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3891b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 3892b411b363SPhilipp Reisner put_ldev(mdev); 3893b411b363SPhilipp Reisner } 3894b411b363SPhilipp Reisner 389587f7be4cSPhilipp Reisner if (mdev->state.role == R_PRIMARY && fp >= FP_RESOURCE && mdev->state.pdsk >= D_UNKNOWN) 389687f7be4cSPhilipp Reisner drbd_try_outdate_peer_async(mdev); 3897b411b363SPhilipp Reisner 389887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3899b411b363SPhilipp Reisner os = mdev->state; 3900b411b363SPhilipp Reisner if (os.conn >= C_UNCONNECTED) { 3901b411b363SPhilipp Reisner /* Do not restart in case we are C_DISCONNECTING */ 3902b411b363SPhilipp Reisner ns = os; 3903b411b363SPhilipp Reisner ns.conn = C_UNCONNECTED; 3904b411b363SPhilipp Reisner rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 3905b411b363SPhilipp Reisner } 390687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3907b411b363SPhilipp Reisner 3908b411b363SPhilipp Reisner if (os.conn == C_DISCONNECTING) { 3909b2fb6dbeSPhilipp Reisner wait_event(mdev->tconn->net_cnt_wait, atomic_read(&mdev->tconn->net_cnt) == 0); 3910b411b363SPhilipp Reisner 3911a0638456SPhilipp Reisner crypto_free_hash(mdev->tconn->cram_hmac_tfm); 3912a0638456SPhilipp Reisner mdev->tconn->cram_hmac_tfm = NULL; 3913b411b363SPhilipp Reisner 391489e58e75SPhilipp Reisner kfree(mdev->tconn->net_conf); 391589e58e75SPhilipp Reisner mdev->tconn->net_conf = NULL; 3916b411b363SPhilipp Reisner drbd_request_state(mdev, NS(conn, C_STANDALONE)); 3917b411b363SPhilipp Reisner } 3918b411b363SPhilipp Reisner 391920ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 392020ceb2b2SLars Ellenberg * if any. */ 392120ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 392220ceb2b2SLars Ellenberg 3923b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 3924b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 3925b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 3926b411b363SPhilipp Reisner * 3927b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 3928b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 3929b411b363SPhilipp Reisner */ 3930b411b363SPhilipp Reisner i = drbd_release_ee(mdev, &mdev->net_ee); 3931b411b363SPhilipp Reisner if (i) 3932b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 3933435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 3934435f0740SLars Ellenberg if (i) 3935435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 3936b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 3937b411b363SPhilipp Reisner if (i) 393845bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 3939b411b363SPhilipp Reisner 3940b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 3941b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 3942b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 3943b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 3944b411b363SPhilipp Reisner 3945b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 3946b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 3947b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 3948b411b363SPhilipp Reisner } 3949b411b363SPhilipp Reisner 3950b411b363SPhilipp Reisner /* 3951b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 3952b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 3953b411b363SPhilipp Reisner * 3954b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 3955b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 3956b411b363SPhilipp Reisner * 3957b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 3958b411b363SPhilipp Reisner */ 3959b411b363SPhilipp Reisner static int drbd_send_handshake(struct drbd_conf *mdev) 3960b411b363SPhilipp Reisner { 3961e6b3ea83SPhilipp Reisner /* ASSERT current == mdev->tconn->receiver ... */ 3962e42325a5SPhilipp Reisner struct p_handshake *p = &mdev->tconn->data.sbuf.handshake; 3963b411b363SPhilipp Reisner int ok; 3964b411b363SPhilipp Reisner 3965e42325a5SPhilipp Reisner if (mutex_lock_interruptible(&mdev->tconn->data.mutex)) { 3966b411b363SPhilipp Reisner dev_err(DEV, "interrupted during initial handshake\n"); 3967b411b363SPhilipp Reisner return 0; /* interrupted. not ok. */ 3968b411b363SPhilipp Reisner } 3969b411b363SPhilipp Reisner 3970e42325a5SPhilipp Reisner if (mdev->tconn->data.socket == NULL) { 3971e42325a5SPhilipp Reisner mutex_unlock(&mdev->tconn->data.mutex); 3972b411b363SPhilipp Reisner return 0; 3973b411b363SPhilipp Reisner } 3974b411b363SPhilipp Reisner 3975b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 3976b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 3977b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 3978e42325a5SPhilipp Reisner ok = _drbd_send_cmd(mdev, mdev->tconn->data.socket, P_HAND_SHAKE, 3979c012949aSPhilipp Reisner &p->head, sizeof(*p), 0 ); 3980e42325a5SPhilipp Reisner mutex_unlock(&mdev->tconn->data.mutex); 3981b411b363SPhilipp Reisner return ok; 3982b411b363SPhilipp Reisner } 3983b411b363SPhilipp Reisner 3984b411b363SPhilipp Reisner /* 3985b411b363SPhilipp Reisner * return values: 3986b411b363SPhilipp Reisner * 1 yes, we have a valid connection 3987b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 3988b411b363SPhilipp Reisner * -1 peer talks different language, 3989b411b363SPhilipp Reisner * no point in trying again, please go standalone. 3990b411b363SPhilipp Reisner */ 3991b411b363SPhilipp Reisner static int drbd_do_handshake(struct drbd_conf *mdev) 3992b411b363SPhilipp Reisner { 3993e6b3ea83SPhilipp Reisner /* ASSERT current == mdev->tconn->receiver ... */ 3994e42325a5SPhilipp Reisner struct p_handshake *p = &mdev->tconn->data.rbuf.handshake; 399502918be2SPhilipp Reisner const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80); 399602918be2SPhilipp Reisner unsigned int length; 3997d8763023SAndreas Gruenbacher enum drbd_packet cmd; 3998b411b363SPhilipp Reisner int rv; 3999b411b363SPhilipp Reisner 4000b411b363SPhilipp Reisner rv = drbd_send_handshake(mdev); 4001b411b363SPhilipp Reisner if (!rv) 4002b411b363SPhilipp Reisner return 0; 4003b411b363SPhilipp Reisner 400402918be2SPhilipp Reisner rv = drbd_recv_header(mdev, &cmd, &length); 4005b411b363SPhilipp Reisner if (!rv) 4006b411b363SPhilipp Reisner return 0; 4007b411b363SPhilipp Reisner 400802918be2SPhilipp Reisner if (cmd != P_HAND_SHAKE) { 4009b411b363SPhilipp Reisner dev_err(DEV, "expected HandShake packet, received: %s (0x%04x)\n", 401002918be2SPhilipp Reisner cmdname(cmd), cmd); 4011b411b363SPhilipp Reisner return -1; 4012b411b363SPhilipp Reisner } 4013b411b363SPhilipp Reisner 401402918be2SPhilipp Reisner if (length != expect) { 4015b411b363SPhilipp Reisner dev_err(DEV, "expected HandShake length: %u, received: %u\n", 401602918be2SPhilipp Reisner expect, length); 4017b411b363SPhilipp Reisner return -1; 4018b411b363SPhilipp Reisner } 4019b411b363SPhilipp Reisner 4020b411b363SPhilipp Reisner rv = drbd_recv(mdev, &p->head.payload, expect); 4021b411b363SPhilipp Reisner 4022b411b363SPhilipp Reisner if (rv != expect) { 40230ddc5549SLars Ellenberg if (!signal_pending(current)) 40240ddc5549SLars Ellenberg dev_warn(DEV, "short read receiving handshake packet: l=%u\n", rv); 4025b411b363SPhilipp Reisner return 0; 4026b411b363SPhilipp Reisner } 4027b411b363SPhilipp Reisner 4028b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4029b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4030b411b363SPhilipp Reisner if (p->protocol_max == 0) 4031b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4032b411b363SPhilipp Reisner 4033b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4034b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4035b411b363SPhilipp Reisner goto incompat; 4036b411b363SPhilipp Reisner 403731890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4038b411b363SPhilipp Reisner 4039b411b363SPhilipp Reisner dev_info(DEV, "Handshake successful: " 404031890f4aSPhilipp Reisner "Agreed network protocol version %d\n", mdev->tconn->agreed_pro_version); 4041b411b363SPhilipp Reisner 4042b411b363SPhilipp Reisner return 1; 4043b411b363SPhilipp Reisner 4044b411b363SPhilipp Reisner incompat: 4045b411b363SPhilipp Reisner dev_err(DEV, "incompatible DRBD dialects: " 4046b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4047b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4048b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4049b411b363SPhilipp Reisner return -1; 4050b411b363SPhilipp Reisner } 4051b411b363SPhilipp Reisner 4052b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 4053b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev) 4054b411b363SPhilipp Reisner { 4055b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4056b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4057b10d96cbSJohannes Thoma return -1; 4058b411b363SPhilipp Reisner } 4059b411b363SPhilipp Reisner #else 4060b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4061b10d96cbSJohannes Thoma 4062b10d96cbSJohannes Thoma /* Return value: 4063b10d96cbSJohannes Thoma 1 - auth succeeded, 4064b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4065b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4066b10d96cbSJohannes Thoma */ 4067b10d96cbSJohannes Thoma 4068b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev) 4069b411b363SPhilipp Reisner { 4070b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4071b411b363SPhilipp Reisner struct scatterlist sg; 4072b411b363SPhilipp Reisner char *response = NULL; 4073b411b363SPhilipp Reisner char *right_response = NULL; 4074b411b363SPhilipp Reisner char *peers_ch = NULL; 407589e58e75SPhilipp Reisner unsigned int key_len = strlen(mdev->tconn->net_conf->shared_secret); 4076b411b363SPhilipp Reisner unsigned int resp_size; 4077b411b363SPhilipp Reisner struct hash_desc desc; 4078d8763023SAndreas Gruenbacher enum drbd_packet cmd; 407902918be2SPhilipp Reisner unsigned int length; 4080b411b363SPhilipp Reisner int rv; 4081b411b363SPhilipp Reisner 4082a0638456SPhilipp Reisner desc.tfm = mdev->tconn->cram_hmac_tfm; 4083b411b363SPhilipp Reisner desc.flags = 0; 4084b411b363SPhilipp Reisner 4085a0638456SPhilipp Reisner rv = crypto_hash_setkey(mdev->tconn->cram_hmac_tfm, 408689e58e75SPhilipp Reisner (u8 *)mdev->tconn->net_conf->shared_secret, key_len); 4087b411b363SPhilipp Reisner if (rv) { 4088b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_setkey() failed with %d\n", rv); 4089b10d96cbSJohannes Thoma rv = -1; 4090b411b363SPhilipp Reisner goto fail; 4091b411b363SPhilipp Reisner } 4092b411b363SPhilipp Reisner 4093b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4094b411b363SPhilipp Reisner 4095b411b363SPhilipp Reisner rv = drbd_send_cmd2(mdev, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN); 4096b411b363SPhilipp Reisner if (!rv) 4097b411b363SPhilipp Reisner goto fail; 4098b411b363SPhilipp Reisner 409902918be2SPhilipp Reisner rv = drbd_recv_header(mdev, &cmd, &length); 4100b411b363SPhilipp Reisner if (!rv) 4101b411b363SPhilipp Reisner goto fail; 4102b411b363SPhilipp Reisner 410302918be2SPhilipp Reisner if (cmd != P_AUTH_CHALLENGE) { 4104b411b363SPhilipp Reisner dev_err(DEV, "expected AuthChallenge packet, received: %s (0x%04x)\n", 410502918be2SPhilipp Reisner cmdname(cmd), cmd); 4106b411b363SPhilipp Reisner rv = 0; 4107b411b363SPhilipp Reisner goto fail; 4108b411b363SPhilipp Reisner } 4109b411b363SPhilipp Reisner 411002918be2SPhilipp Reisner if (length > CHALLENGE_LEN * 2) { 4111b411b363SPhilipp Reisner dev_err(DEV, "expected AuthChallenge payload too big.\n"); 4112b10d96cbSJohannes Thoma rv = -1; 4113b411b363SPhilipp Reisner goto fail; 4114b411b363SPhilipp Reisner } 4115b411b363SPhilipp Reisner 411602918be2SPhilipp Reisner peers_ch = kmalloc(length, GFP_NOIO); 4117b411b363SPhilipp Reisner if (peers_ch == NULL) { 4118b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of peers_ch failed\n"); 4119b10d96cbSJohannes Thoma rv = -1; 4120b411b363SPhilipp Reisner goto fail; 4121b411b363SPhilipp Reisner } 4122b411b363SPhilipp Reisner 412302918be2SPhilipp Reisner rv = drbd_recv(mdev, peers_ch, length); 4124b411b363SPhilipp Reisner 412502918be2SPhilipp Reisner if (rv != length) { 41260ddc5549SLars Ellenberg if (!signal_pending(current)) 41270ddc5549SLars Ellenberg dev_warn(DEV, "short read AuthChallenge: l=%u\n", rv); 4128b411b363SPhilipp Reisner rv = 0; 4129b411b363SPhilipp Reisner goto fail; 4130b411b363SPhilipp Reisner } 4131b411b363SPhilipp Reisner 4132a0638456SPhilipp Reisner resp_size = crypto_hash_digestsize(mdev->tconn->cram_hmac_tfm); 4133b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4134b411b363SPhilipp Reisner if (response == NULL) { 4135b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of response failed\n"); 4136b10d96cbSJohannes Thoma rv = -1; 4137b411b363SPhilipp Reisner goto fail; 4138b411b363SPhilipp Reisner } 4139b411b363SPhilipp Reisner 4140b411b363SPhilipp Reisner sg_init_table(&sg, 1); 414102918be2SPhilipp Reisner sg_set_buf(&sg, peers_ch, length); 4142b411b363SPhilipp Reisner 4143b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4144b411b363SPhilipp Reisner if (rv) { 4145b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv); 4146b10d96cbSJohannes Thoma rv = -1; 4147b411b363SPhilipp Reisner goto fail; 4148b411b363SPhilipp Reisner } 4149b411b363SPhilipp Reisner 4150b411b363SPhilipp Reisner rv = drbd_send_cmd2(mdev, P_AUTH_RESPONSE, response, resp_size); 4151b411b363SPhilipp Reisner if (!rv) 4152b411b363SPhilipp Reisner goto fail; 4153b411b363SPhilipp Reisner 415402918be2SPhilipp Reisner rv = drbd_recv_header(mdev, &cmd, &length); 4155b411b363SPhilipp Reisner if (!rv) 4156b411b363SPhilipp Reisner goto fail; 4157b411b363SPhilipp Reisner 415802918be2SPhilipp Reisner if (cmd != P_AUTH_RESPONSE) { 4159b411b363SPhilipp Reisner dev_err(DEV, "expected AuthResponse packet, received: %s (0x%04x)\n", 416002918be2SPhilipp Reisner cmdname(cmd), cmd); 4161b411b363SPhilipp Reisner rv = 0; 4162b411b363SPhilipp Reisner goto fail; 4163b411b363SPhilipp Reisner } 4164b411b363SPhilipp Reisner 416502918be2SPhilipp Reisner if (length != resp_size) { 4166b411b363SPhilipp Reisner dev_err(DEV, "expected AuthResponse payload of wrong size\n"); 4167b411b363SPhilipp Reisner rv = 0; 4168b411b363SPhilipp Reisner goto fail; 4169b411b363SPhilipp Reisner } 4170b411b363SPhilipp Reisner 4171b411b363SPhilipp Reisner rv = drbd_recv(mdev, response , resp_size); 4172b411b363SPhilipp Reisner 4173b411b363SPhilipp Reisner if (rv != resp_size) { 41740ddc5549SLars Ellenberg if (!signal_pending(current)) 41750ddc5549SLars Ellenberg dev_warn(DEV, "short read receiving AuthResponse: l=%u\n", rv); 4176b411b363SPhilipp Reisner rv = 0; 4177b411b363SPhilipp Reisner goto fail; 4178b411b363SPhilipp Reisner } 4179b411b363SPhilipp Reisner 4180b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 41812d1ee87dSJulia Lawall if (right_response == NULL) { 4182b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of right_response failed\n"); 4183b10d96cbSJohannes Thoma rv = -1; 4184b411b363SPhilipp Reisner goto fail; 4185b411b363SPhilipp Reisner } 4186b411b363SPhilipp Reisner 4187b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4188b411b363SPhilipp Reisner 4189b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4190b411b363SPhilipp Reisner if (rv) { 4191b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv); 4192b10d96cbSJohannes Thoma rv = -1; 4193b411b363SPhilipp Reisner goto fail; 4194b411b363SPhilipp Reisner } 4195b411b363SPhilipp Reisner 4196b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4197b411b363SPhilipp Reisner 4198b411b363SPhilipp Reisner if (rv) 4199b411b363SPhilipp Reisner dev_info(DEV, "Peer authenticated using %d bytes of '%s' HMAC\n", 420089e58e75SPhilipp Reisner resp_size, mdev->tconn->net_conf->cram_hmac_alg); 4201b10d96cbSJohannes Thoma else 4202b10d96cbSJohannes Thoma rv = -1; 4203b411b363SPhilipp Reisner 4204b411b363SPhilipp Reisner fail: 4205b411b363SPhilipp Reisner kfree(peers_ch); 4206b411b363SPhilipp Reisner kfree(response); 4207b411b363SPhilipp Reisner kfree(right_response); 4208b411b363SPhilipp Reisner 4209b411b363SPhilipp Reisner return rv; 4210b411b363SPhilipp Reisner } 4211b411b363SPhilipp Reisner #endif 4212b411b363SPhilipp Reisner 4213b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4214b411b363SPhilipp Reisner { 4215b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 4216b411b363SPhilipp Reisner unsigned int minor = mdev_to_minor(mdev); 4217b411b363SPhilipp Reisner int h; 4218b411b363SPhilipp Reisner 4219b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_receiver", minor); 4220b411b363SPhilipp Reisner 4221b411b363SPhilipp Reisner dev_info(DEV, "receiver (re)started\n"); 4222b411b363SPhilipp Reisner 4223b411b363SPhilipp Reisner do { 4224b411b363SPhilipp Reisner h = drbd_connect(mdev); 4225b411b363SPhilipp Reisner if (h == 0) { 4226b411b363SPhilipp Reisner drbd_disconnect(mdev); 422720ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4228b411b363SPhilipp Reisner } 4229b411b363SPhilipp Reisner if (h == -1) { 4230b411b363SPhilipp Reisner dev_warn(DEV, "Discarding network configuration.\n"); 4231b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 4232b411b363SPhilipp Reisner } 4233b411b363SPhilipp Reisner } while (h == 0); 4234b411b363SPhilipp Reisner 4235b411b363SPhilipp Reisner if (h > 0) { 4236b2fb6dbeSPhilipp Reisner if (get_net_conf(mdev->tconn)) { 4237b411b363SPhilipp Reisner drbdd(mdev); 4238b2fb6dbeSPhilipp Reisner put_net_conf(mdev->tconn); 4239b411b363SPhilipp Reisner } 4240b411b363SPhilipp Reisner } 4241b411b363SPhilipp Reisner 4242b411b363SPhilipp Reisner drbd_disconnect(mdev); 4243b411b363SPhilipp Reisner 4244b411b363SPhilipp Reisner dev_info(DEV, "receiver terminated\n"); 4245b411b363SPhilipp Reisner return 0; 4246b411b363SPhilipp Reisner } 4247b411b363SPhilipp Reisner 4248b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4249b411b363SPhilipp Reisner 4250d8763023SAndreas Gruenbacher static int got_RqSReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4251b411b363SPhilipp Reisner { 4252257d0af6SPhilipp Reisner struct p_req_state_reply *p = &mdev->tconn->meta.rbuf.req_state_reply; 4253b411b363SPhilipp Reisner 4254b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4255b411b363SPhilipp Reisner 4256b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4257b411b363SPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4258b411b363SPhilipp Reisner } else { 4259b411b363SPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4260b411b363SPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4261b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4262b411b363SPhilipp Reisner } 4263b411b363SPhilipp Reisner wake_up(&mdev->state_wait); 4264b411b363SPhilipp Reisner 426581e84650SAndreas Gruenbacher return true; 4266b411b363SPhilipp Reisner } 4267b411b363SPhilipp Reisner 4268d8763023SAndreas Gruenbacher static int got_Ping(struct drbd_conf *mdev, enum drbd_packet cmd) 4269b411b363SPhilipp Reisner { 4270b411b363SPhilipp Reisner return drbd_send_ping_ack(mdev); 4271b411b363SPhilipp Reisner 4272b411b363SPhilipp Reisner } 4273b411b363SPhilipp Reisner 4274d8763023SAndreas Gruenbacher static int got_PingAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4275b411b363SPhilipp Reisner { 4276b411b363SPhilipp Reisner /* restore idle timeout */ 4277e42325a5SPhilipp Reisner mdev->tconn->meta.socket->sk->sk_rcvtimeo = mdev->tconn->net_conf->ping_int*HZ; 4278309d1608SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &mdev->flags)) 4279309d1608SPhilipp Reisner wake_up(&mdev->misc_wait); 4280b411b363SPhilipp Reisner 428181e84650SAndreas Gruenbacher return true; 4282b411b363SPhilipp Reisner } 4283b411b363SPhilipp Reisner 4284d8763023SAndreas Gruenbacher static int got_IsInSync(struct drbd_conf *mdev, enum drbd_packet cmd) 4285b411b363SPhilipp Reisner { 4286257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4287b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4288b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4289b411b363SPhilipp Reisner 429031890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4291b411b363SPhilipp Reisner 4292b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4293b411b363SPhilipp Reisner 42941d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4295b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4296b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4297b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4298b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 42991d53f09eSLars Ellenberg put_ldev(mdev); 43001d53f09eSLars Ellenberg } 4301b411b363SPhilipp Reisner dec_rs_pending(mdev); 4302778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4303b411b363SPhilipp Reisner 430481e84650SAndreas Gruenbacher return true; 4305b411b363SPhilipp Reisner } 4306b411b363SPhilipp Reisner 4307bc9c5c41SAndreas Gruenbacher static int 4308bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4309bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4310bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4311b411b363SPhilipp Reisner { 4312b411b363SPhilipp Reisner struct drbd_request *req; 4313b411b363SPhilipp Reisner struct bio_and_error m; 4314b411b363SPhilipp Reisner 431587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4316bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4317b411b363SPhilipp Reisner if (unlikely(!req)) { 431887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 431981e84650SAndreas Gruenbacher return false; 4320b411b363SPhilipp Reisner } 4321b411b363SPhilipp Reisner __req_mod(req, what, &m); 432287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4323b411b363SPhilipp Reisner 4324b411b363SPhilipp Reisner if (m.bio) 4325b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 432681e84650SAndreas Gruenbacher return true; 4327b411b363SPhilipp Reisner } 4328b411b363SPhilipp Reisner 4329d8763023SAndreas Gruenbacher static int got_BlockAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4330b411b363SPhilipp Reisner { 4331257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4332b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4333b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4334b411b363SPhilipp Reisner enum drbd_req_event what; 4335b411b363SPhilipp Reisner 4336b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4337b411b363SPhilipp Reisner 4338579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4339b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4340b411b363SPhilipp Reisner dec_rs_pending(mdev); 434181e84650SAndreas Gruenbacher return true; 4342b411b363SPhilipp Reisner } 4343257d0af6SPhilipp Reisner switch (cmd) { 4344b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 434589e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 43468554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4347b411b363SPhilipp Reisner break; 4348b411b363SPhilipp Reisner case P_WRITE_ACK: 434989e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 43508554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4351b411b363SPhilipp Reisner break; 4352b411b363SPhilipp Reisner case P_RECV_ACK: 435389e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B); 43548554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4355b411b363SPhilipp Reisner break; 4356b411b363SPhilipp Reisner case P_DISCARD_ACK: 435789e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 43588554df1cSAndreas Gruenbacher what = CONFLICT_DISCARDED_BY_PEER; 4359b411b363SPhilipp Reisner break; 4360b411b363SPhilipp Reisner default: 4361b411b363SPhilipp Reisner D_ASSERT(0); 436281e84650SAndreas Gruenbacher return false; 4363b411b363SPhilipp Reisner } 4364b411b363SPhilipp Reisner 4365b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4366bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4367bc9c5c41SAndreas Gruenbacher what, false); 4368b411b363SPhilipp Reisner } 4369b411b363SPhilipp Reisner 4370d8763023SAndreas Gruenbacher static int got_NegAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4371b411b363SPhilipp Reisner { 4372257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4373b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 43742deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 437589e58e75SPhilipp Reisner bool missing_ok = mdev->tconn->net_conf->wire_protocol == DRBD_PROT_A || 437689e58e75SPhilipp Reisner mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B; 4377c3afd8f5SAndreas Gruenbacher bool found; 4378b411b363SPhilipp Reisner 4379b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4380b411b363SPhilipp Reisner 4381579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4382b411b363SPhilipp Reisner dec_rs_pending(mdev); 4383b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 438481e84650SAndreas Gruenbacher return true; 4385b411b363SPhilipp Reisner } 43862deb8336SPhilipp Reisner 4387c3afd8f5SAndreas Gruenbacher found = validate_req_change_req_state(mdev, p->block_id, sector, 4388bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 43898554df1cSAndreas Gruenbacher NEG_ACKED, missing_ok); 4390c3afd8f5SAndreas Gruenbacher if (!found) { 43912deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 43922deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4393c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 43942deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 43952deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4396c3afd8f5SAndreas Gruenbacher if (!missing_ok) 43972deb8336SPhilipp Reisner return false; 4398c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 43992deb8336SPhilipp Reisner } 44002deb8336SPhilipp Reisner return true; 4401b411b363SPhilipp Reisner } 4402b411b363SPhilipp Reisner 4403d8763023SAndreas Gruenbacher static int got_NegDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4404b411b363SPhilipp Reisner { 4405257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4406b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4407b411b363SPhilipp Reisner 4408b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4409b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4410b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4411b411b363SPhilipp Reisner 4412b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4413bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 44148554df1cSAndreas Gruenbacher NEG_ACKED, false); 4415b411b363SPhilipp Reisner } 4416b411b363SPhilipp Reisner 4417d8763023SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4418b411b363SPhilipp Reisner { 4419b411b363SPhilipp Reisner sector_t sector; 4420b411b363SPhilipp Reisner int size; 4421257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4422b411b363SPhilipp Reisner 4423b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4424b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4425b411b363SPhilipp Reisner 4426b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4427b411b363SPhilipp Reisner 4428b411b363SPhilipp Reisner dec_rs_pending(mdev); 4429b411b363SPhilipp Reisner 4430b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4431b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4432257d0af6SPhilipp Reisner switch (cmd) { 4433d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4434b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4435d612d309SPhilipp Reisner case P_RS_CANCEL: 4436d612d309SPhilipp Reisner break; 4437d612d309SPhilipp Reisner default: 4438d612d309SPhilipp Reisner D_ASSERT(0); 4439d612d309SPhilipp Reisner put_ldev(mdev); 4440d612d309SPhilipp Reisner return false; 4441d612d309SPhilipp Reisner } 4442b411b363SPhilipp Reisner put_ldev(mdev); 4443b411b363SPhilipp Reisner } 4444b411b363SPhilipp Reisner 444581e84650SAndreas Gruenbacher return true; 4446b411b363SPhilipp Reisner } 4447b411b363SPhilipp Reisner 4448d8763023SAndreas Gruenbacher static int got_BarrierAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4449b411b363SPhilipp Reisner { 4450257d0af6SPhilipp Reisner struct p_barrier_ack *p = &mdev->tconn->meta.rbuf.barrier_ack; 4451b411b363SPhilipp Reisner 4452b411b363SPhilipp Reisner tl_release(mdev, p->barrier, be32_to_cpu(p->set_size)); 4453b411b363SPhilipp Reisner 4454c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 4455c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 4456370a43e7SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) { 4457370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 4458370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 4459c4752ef1SPhilipp Reisner } 4460c4752ef1SPhilipp Reisner 446181e84650SAndreas Gruenbacher return true; 4462b411b363SPhilipp Reisner } 4463b411b363SPhilipp Reisner 4464d8763023SAndreas Gruenbacher static int got_OVResult(struct drbd_conf *mdev, enum drbd_packet cmd) 4465b411b363SPhilipp Reisner { 4466257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4467b411b363SPhilipp Reisner struct drbd_work *w; 4468b411b363SPhilipp Reisner sector_t sector; 4469b411b363SPhilipp Reisner int size; 4470b411b363SPhilipp Reisner 4471b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4472b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4473b411b363SPhilipp Reisner 4474b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4475b411b363SPhilipp Reisner 4476b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 4477b411b363SPhilipp Reisner drbd_ov_oos_found(mdev, sector, size); 4478b411b363SPhilipp Reisner else 4479b411b363SPhilipp Reisner ov_oos_print(mdev); 4480b411b363SPhilipp Reisner 44811d53f09eSLars Ellenberg if (!get_ldev(mdev)) 448281e84650SAndreas Gruenbacher return true; 44831d53f09eSLars Ellenberg 4484b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4485b411b363SPhilipp Reisner dec_rs_pending(mdev); 4486b411b363SPhilipp Reisner 4487ea5442afSLars Ellenberg --mdev->ov_left; 4488ea5442afSLars Ellenberg 4489ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 4490ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 4491ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 4492ea5442afSLars Ellenberg 4493ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 4494b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4495b411b363SPhilipp Reisner if (w) { 4496b411b363SPhilipp Reisner w->cb = w_ov_finished; 4497e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 4498b411b363SPhilipp Reisner } else { 4499b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 4500b411b363SPhilipp Reisner ov_oos_print(mdev); 4501b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4502b411b363SPhilipp Reisner } 4503b411b363SPhilipp Reisner } 45041d53f09eSLars Ellenberg put_ldev(mdev); 450581e84650SAndreas Gruenbacher return true; 4506b411b363SPhilipp Reisner } 4507b411b363SPhilipp Reisner 4508d8763023SAndreas Gruenbacher static int got_skip(struct drbd_conf *mdev, enum drbd_packet cmd) 45090ced55a3SPhilipp Reisner { 451081e84650SAndreas Gruenbacher return true; 45110ced55a3SPhilipp Reisner } 45120ced55a3SPhilipp Reisner 4513b411b363SPhilipp Reisner struct asender_cmd { 4514b411b363SPhilipp Reisner size_t pkt_size; 4515d8763023SAndreas Gruenbacher int (*process)(struct drbd_conf *mdev, enum drbd_packet cmd); 4516b411b363SPhilipp Reisner }; 4517b411b363SPhilipp Reisner 4518b411b363SPhilipp Reisner static struct asender_cmd *get_asender_cmd(int cmd) 4519b411b363SPhilipp Reisner { 4520b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 4521b411b363SPhilipp Reisner /* anything missing from this table is in 4522b411b363SPhilipp Reisner * the drbd_cmd_handler (drbd_default_handler) table, 4523b411b363SPhilipp Reisner * see the beginning of drbdd() */ 4524257d0af6SPhilipp Reisner [P_PING] = { sizeof(struct p_header), got_Ping }, 4525257d0af6SPhilipp Reisner [P_PING_ACK] = { sizeof(struct p_header), got_PingAck }, 4526b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4527b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4528b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4529b411b363SPhilipp Reisner [P_DISCARD_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4530b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 4531b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 4532b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply}, 4533b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 4534b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 4535b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 4536b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 453702918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 4538d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply}, 4539b411b363SPhilipp Reisner [P_MAX_CMD] = { 0, NULL }, 4540b411b363SPhilipp Reisner }; 4541b411b363SPhilipp Reisner if (cmd > P_MAX_CMD || asender_tbl[cmd].process == NULL) 4542b411b363SPhilipp Reisner return NULL; 4543b411b363SPhilipp Reisner return &asender_tbl[cmd]; 4544b411b363SPhilipp Reisner } 4545b411b363SPhilipp Reisner 4546b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4547b411b363SPhilipp Reisner { 4548b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 4549257d0af6SPhilipp Reisner struct p_header *h = &mdev->tconn->meta.rbuf.header; 4550b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 4551b411b363SPhilipp Reisner 4552257d0af6SPhilipp Reisner int rv; 4553b411b363SPhilipp Reisner void *buf = h; 4554b411b363SPhilipp Reisner int received = 0; 4555257d0af6SPhilipp Reisner int expect = sizeof(struct p_header); 4556f36af18cSLars Ellenberg int ping_timeout_active = 0; 4557257d0af6SPhilipp Reisner int empty, pkt_size; 4558d8763023SAndreas Gruenbacher enum drbd_packet cmd_nr; 4559b411b363SPhilipp Reisner 4560b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_asender", mdev_to_minor(mdev)); 4561b411b363SPhilipp Reisner 4562b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4563b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4564b411b363SPhilipp Reisner 4565e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 4566bc31fe33SPhilipp Reisner drbd_thread_current_set_cpu(mdev, thi); 4567b411b363SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &mdev->flags)) { 4568841ce241SAndreas Gruenbacher if (!drbd_send_ping(mdev)) { 4569841ce241SAndreas Gruenbacher dev_err(DEV, "drbd_send_ping has failed\n"); 4570841ce241SAndreas Gruenbacher goto reconnect; 4571841ce241SAndreas Gruenbacher } 4572e42325a5SPhilipp Reisner mdev->tconn->meta.socket->sk->sk_rcvtimeo = 457389e58e75SPhilipp Reisner mdev->tconn->net_conf->ping_timeo*HZ/10; 4574f36af18cSLars Ellenberg ping_timeout_active = 1; 4575b411b363SPhilipp Reisner } 4576b411b363SPhilipp Reisner 4577b411b363SPhilipp Reisner /* conditionally cork; 4578b411b363SPhilipp Reisner * it may hurt latency if we cork without much to send */ 457989e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->no_cork && 4580b411b363SPhilipp Reisner 3 < atomic_read(&mdev->unacked_cnt)) 4581e42325a5SPhilipp Reisner drbd_tcp_cork(mdev->tconn->meta.socket); 4582b411b363SPhilipp Reisner while (1) { 4583b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4584b411b363SPhilipp Reisner flush_signals(current); 45850f8488e1SLars Ellenberg if (!drbd_process_done_ee(mdev)) 4586b411b363SPhilipp Reisner goto reconnect; 4587b411b363SPhilipp Reisner /* to avoid race with newly queued ACKs */ 4588b411b363SPhilipp Reisner set_bit(SIGNAL_ASENDER, &mdev->flags); 458987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4590b411b363SPhilipp Reisner empty = list_empty(&mdev->done_ee); 459187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4592b411b363SPhilipp Reisner /* new ack may have been queued right here, 4593b411b363SPhilipp Reisner * but then there is also a signal pending, 4594b411b363SPhilipp Reisner * and we start over... */ 4595b411b363SPhilipp Reisner if (empty) 4596b411b363SPhilipp Reisner break; 4597b411b363SPhilipp Reisner } 4598b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 459989e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->no_cork) 4600e42325a5SPhilipp Reisner drbd_tcp_uncork(mdev->tconn->meta.socket); 4601b411b363SPhilipp Reisner 4602b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4603b411b363SPhilipp Reisner if (signal_pending(current)) 4604b411b363SPhilipp Reisner continue; 4605b411b363SPhilipp Reisner 4606e42325a5SPhilipp Reisner rv = drbd_recv_short(mdev, mdev->tconn->meta.socket, 4607b411b363SPhilipp Reisner buf, expect-received, 0); 4608b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4609b411b363SPhilipp Reisner 4610b411b363SPhilipp Reisner flush_signals(current); 4611b411b363SPhilipp Reisner 4612b411b363SPhilipp Reisner /* Note: 4613b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4614b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4615b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4616b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4617b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4618b411b363SPhilipp Reisner * rv == expected: full header or command 4619b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4620b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4621b411b363SPhilipp Reisner */ 4622b411b363SPhilipp Reisner if (likely(rv > 0)) { 4623b411b363SPhilipp Reisner received += rv; 4624b411b363SPhilipp Reisner buf += rv; 4625b411b363SPhilipp Reisner } else if (rv == 0) { 4626b411b363SPhilipp Reisner dev_err(DEV, "meta connection shut down by peer.\n"); 4627b411b363SPhilipp Reisner goto reconnect; 4628b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4629cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 4630cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 463131890f4aSPhilipp Reisner if (time_after(mdev->tconn->last_received, 4632e42325a5SPhilipp Reisner jiffies - mdev->tconn->meta.socket->sk->sk_rcvtimeo)) 4633cb6518cbSLars Ellenberg continue; 4634f36af18cSLars Ellenberg if (ping_timeout_active) { 4635b411b363SPhilipp Reisner dev_err(DEV, "PingAck did not arrive in time.\n"); 4636b411b363SPhilipp Reisner goto reconnect; 4637b411b363SPhilipp Reisner } 4638b411b363SPhilipp Reisner set_bit(SEND_PING, &mdev->flags); 4639b411b363SPhilipp Reisner continue; 4640b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4641b411b363SPhilipp Reisner continue; 4642b411b363SPhilipp Reisner } else { 4643b411b363SPhilipp Reisner dev_err(DEV, "sock_recvmsg returned %d\n", rv); 4644b411b363SPhilipp Reisner goto reconnect; 4645b411b363SPhilipp Reisner } 4646b411b363SPhilipp Reisner 4647b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 4648257d0af6SPhilipp Reisner if (!decode_header(mdev, h, &cmd_nr, &pkt_size)) 4649b411b363SPhilipp Reisner goto reconnect; 4650257d0af6SPhilipp Reisner cmd = get_asender_cmd(cmd_nr); 4651b411b363SPhilipp Reisner if (unlikely(cmd == NULL)) { 4652257d0af6SPhilipp Reisner dev_err(DEV, "unknown command %d on meta (l: %d)\n", 4653257d0af6SPhilipp Reisner cmd_nr, pkt_size); 4654b411b363SPhilipp Reisner goto disconnect; 4655b411b363SPhilipp Reisner } 4656b411b363SPhilipp Reisner expect = cmd->pkt_size; 4657257d0af6SPhilipp Reisner if (pkt_size != expect - sizeof(struct p_header)) { 4658257d0af6SPhilipp Reisner dev_err(DEV, "Wrong packet size on meta (c: %d, l: %d)\n", 4659257d0af6SPhilipp Reisner cmd_nr, pkt_size); 4660b411b363SPhilipp Reisner goto reconnect; 4661b411b363SPhilipp Reisner } 4662257d0af6SPhilipp Reisner } 4663b411b363SPhilipp Reisner if (received == expect) { 466431890f4aSPhilipp Reisner mdev->tconn->last_received = jiffies; 4665b411b363SPhilipp Reisner D_ASSERT(cmd != NULL); 4666257d0af6SPhilipp Reisner if (!cmd->process(mdev, cmd_nr)) 4667b411b363SPhilipp Reisner goto reconnect; 4668b411b363SPhilipp Reisner 4669f36af18cSLars Ellenberg /* the idle_timeout (ping-int) 4670f36af18cSLars Ellenberg * has been restored in got_PingAck() */ 4671f36af18cSLars Ellenberg if (cmd == get_asender_cmd(P_PING_ACK)) 4672f36af18cSLars Ellenberg ping_timeout_active = 0; 4673f36af18cSLars Ellenberg 4674b411b363SPhilipp Reisner buf = h; 4675b411b363SPhilipp Reisner received = 0; 4676257d0af6SPhilipp Reisner expect = sizeof(struct p_header); 4677b411b363SPhilipp Reisner cmd = NULL; 4678b411b363SPhilipp Reisner } 4679b411b363SPhilipp Reisner } 4680b411b363SPhilipp Reisner 4681b411b363SPhilipp Reisner if (0) { 4682b411b363SPhilipp Reisner reconnect: 4683b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_NETWORK_FAILURE)); 4684856c50c7SLars Ellenberg drbd_md_sync(mdev); 4685b411b363SPhilipp Reisner } 4686b411b363SPhilipp Reisner if (0) { 4687b411b363SPhilipp Reisner disconnect: 4688b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 4689856c50c7SLars Ellenberg drbd_md_sync(mdev); 4690b411b363SPhilipp Reisner } 4691b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4692b411b363SPhilipp Reisner 4693b411b363SPhilipp Reisner D_ASSERT(mdev->state.conn < C_CONNECTED); 4694b411b363SPhilipp Reisner dev_info(DEV, "asender terminated\n"); 4695b411b363SPhilipp Reisner 4696b411b363SPhilipp Reisner return 0; 4697b411b363SPhilipp Reisner } 4698