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 { 192b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 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) { 201b411b363SPhilipp Reisner e = list_entry(le, struct drbd_epoch_entry, w.list); 20245bb912bSLars Ellenberg if (drbd_ee_has_active_page(e)) 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); 211b411b363SPhilipp Reisner struct drbd_epoch_entry *e, *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 217b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &reclaimed, w.list) 218435f0740SLars Ellenberg drbd_free_net_ee(mdev, e); 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 312b411b363SPhilipp Reisner struct drbd_epoch_entry *drbd_alloc_ee(struct drbd_conf *mdev, 313b411b363SPhilipp Reisner u64 id, 314b411b363SPhilipp Reisner sector_t sector, 315b411b363SPhilipp Reisner unsigned int data_size, 316b411b363SPhilipp Reisner gfp_t gfp_mask) __must_hold(local) 317b411b363SPhilipp Reisner { 318b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 319b411b363SPhilipp Reisner struct page *page; 32045bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 321b411b363SPhilipp Reisner 3220cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE)) 323b411b363SPhilipp Reisner return NULL; 324b411b363SPhilipp Reisner 325b411b363SPhilipp Reisner e = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 326b411b363SPhilipp Reisner if (!e) { 327b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 328b411b363SPhilipp Reisner dev_err(DEV, "alloc_ee: Allocation of an EE failed\n"); 329b411b363SPhilipp Reisner return NULL; 330b411b363SPhilipp Reisner } 331b411b363SPhilipp Reisner 33245bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT)); 33345bb912bSLars Ellenberg if (!page) 33445bb912bSLars Ellenberg goto fail; 335b411b363SPhilipp Reisner 3368b946255SAndreas Gruenbacher drbd_clear_interval(&e->i); 337b411b363SPhilipp Reisner e->epoch = NULL; 33845bb912bSLars Ellenberg e->mdev = mdev; 33945bb912bSLars Ellenberg e->pages = page; 34045bb912bSLars Ellenberg atomic_set(&e->pending_bios, 0); 341010f6e67SAndreas Gruenbacher e->i.size = data_size; 342b411b363SPhilipp Reisner e->flags = 0; 343010f6e67SAndreas Gruenbacher e->i.sector = sector; 3449a8e7753SAndreas Gruenbacher /* 3459a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3469a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3479a8e7753SAndreas Gruenbacher */ 34845bb912bSLars Ellenberg e->block_id = id; 349b411b363SPhilipp Reisner 350b411b363SPhilipp Reisner return e; 351b411b363SPhilipp Reisner 35245bb912bSLars Ellenberg fail: 353b411b363SPhilipp Reisner mempool_free(e, drbd_ee_mempool); 354b411b363SPhilipp Reisner return NULL; 355b411b363SPhilipp Reisner } 356b411b363SPhilipp Reisner 357435f0740SLars Ellenberg void drbd_free_some_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e, int is_net) 358b411b363SPhilipp Reisner { 359c36c3cedSLars Ellenberg if (e->flags & EE_HAS_DIGEST) 360c36c3cedSLars Ellenberg kfree(e->digest); 361435f0740SLars Ellenberg drbd_pp_free(mdev, e->pages, is_net); 36245bb912bSLars Ellenberg D_ASSERT(atomic_read(&e->pending_bios) == 0); 3638b946255SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&e->i)); 364b411b363SPhilipp Reisner mempool_free(e, drbd_ee_mempool); 365b411b363SPhilipp Reisner } 366b411b363SPhilipp Reisner 367b411b363SPhilipp Reisner int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list) 368b411b363SPhilipp Reisner { 369b411b363SPhilipp Reisner LIST_HEAD(work_list); 370b411b363SPhilipp Reisner struct drbd_epoch_entry *e, *t; 371b411b363SPhilipp Reisner int count = 0; 372435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 373b411b363SPhilipp Reisner 37487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 375b411b363SPhilipp Reisner list_splice_init(list, &work_list); 37687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 377b411b363SPhilipp Reisner 378b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &work_list, w.list) { 379435f0740SLars Ellenberg drbd_free_some_ee(mdev, e, is_net); 380b411b363SPhilipp Reisner count++; 381b411b363SPhilipp Reisner } 382b411b363SPhilipp Reisner return count; 383b411b363SPhilipp Reisner } 384b411b363SPhilipp Reisner 385b411b363SPhilipp Reisner 386b411b363SPhilipp Reisner /* 387b411b363SPhilipp Reisner * This function is called from _asender only_ 3888554df1cSAndreas Gruenbacher * but see also comments in _req_mod(,BARRIER_ACKED) 389b411b363SPhilipp Reisner * and receive_Barrier. 390b411b363SPhilipp Reisner * 391b411b363SPhilipp Reisner * Move entries from net_ee to done_ee, if ready. 392b411b363SPhilipp Reisner * Grab done_ee, call all callbacks, free the entries. 393b411b363SPhilipp Reisner * The callbacks typically send out ACKs. 394b411b363SPhilipp Reisner */ 395b411b363SPhilipp Reisner static int drbd_process_done_ee(struct drbd_conf *mdev) 396b411b363SPhilipp Reisner { 397b411b363SPhilipp Reisner LIST_HEAD(work_list); 398b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 399b411b363SPhilipp Reisner struct drbd_epoch_entry *e, *t; 400b411b363SPhilipp Reisner int ok = (mdev->state.conn >= C_WF_REPORT_PARAMS); 401b411b363SPhilipp Reisner 40287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 403b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 404b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 40587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 406b411b363SPhilipp Reisner 407b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &reclaimed, w.list) 408435f0740SLars Ellenberg drbd_free_net_ee(mdev, e); 409b411b363SPhilipp Reisner 410b411b363SPhilipp Reisner /* possible callbacks here: 411b411b363SPhilipp Reisner * e_end_block, and e_end_resync_block, e_send_discard_ack. 412b411b363SPhilipp Reisner * all ignore the last argument. 413b411b363SPhilipp Reisner */ 414b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &work_list, w.list) { 415b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 416b411b363SPhilipp Reisner ok = e->w.cb(mdev, &e->w, !ok) && ok; 417b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 418b411b363SPhilipp Reisner } 419b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 420b411b363SPhilipp Reisner 421b411b363SPhilipp Reisner return ok; 422b411b363SPhilipp Reisner } 423b411b363SPhilipp Reisner 424b411b363SPhilipp Reisner void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 425b411b363SPhilipp Reisner { 426b411b363SPhilipp Reisner DEFINE_WAIT(wait); 427b411b363SPhilipp Reisner 428b411b363SPhilipp Reisner /* avoids spin_lock/unlock 429b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 430b411b363SPhilipp Reisner while (!list_empty(head)) { 431b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 43287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4337eaceaccSJens Axboe io_schedule(); 434b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 43587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 436b411b363SPhilipp Reisner } 437b411b363SPhilipp Reisner } 438b411b363SPhilipp Reisner 439b411b363SPhilipp Reisner void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 440b411b363SPhilipp Reisner { 44187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 442b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 44387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 444b411b363SPhilipp Reisner } 445b411b363SPhilipp Reisner 446b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 447b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 448b411b363SPhilipp Reisner static int drbd_accept(struct drbd_conf *mdev, const char **what, 449b411b363SPhilipp Reisner struct socket *sock, struct socket **newsock) 450b411b363SPhilipp Reisner { 451b411b363SPhilipp Reisner struct sock *sk = sock->sk; 452b411b363SPhilipp Reisner int err = 0; 453b411b363SPhilipp Reisner 454b411b363SPhilipp Reisner *what = "listen"; 455b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 456b411b363SPhilipp Reisner if (err < 0) 457b411b363SPhilipp Reisner goto out; 458b411b363SPhilipp Reisner 459b411b363SPhilipp Reisner *what = "sock_create_lite"; 460b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 461b411b363SPhilipp Reisner newsock); 462b411b363SPhilipp Reisner if (err < 0) 463b411b363SPhilipp Reisner goto out; 464b411b363SPhilipp Reisner 465b411b363SPhilipp Reisner *what = "accept"; 466b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 467b411b363SPhilipp Reisner if (err < 0) { 468b411b363SPhilipp Reisner sock_release(*newsock); 469b411b363SPhilipp Reisner *newsock = NULL; 470b411b363SPhilipp Reisner goto out; 471b411b363SPhilipp Reisner } 472b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 473b411b363SPhilipp Reisner 474b411b363SPhilipp Reisner out: 475b411b363SPhilipp Reisner return err; 476b411b363SPhilipp Reisner } 477b411b363SPhilipp Reisner 478b411b363SPhilipp Reisner static int drbd_recv_short(struct drbd_conf *mdev, struct socket *sock, 479b411b363SPhilipp Reisner void *buf, size_t size, int flags) 480b411b363SPhilipp Reisner { 481b411b363SPhilipp Reisner mm_segment_t oldfs; 482b411b363SPhilipp Reisner struct kvec iov = { 483b411b363SPhilipp Reisner .iov_base = buf, 484b411b363SPhilipp Reisner .iov_len = size, 485b411b363SPhilipp Reisner }; 486b411b363SPhilipp Reisner struct msghdr msg = { 487b411b363SPhilipp Reisner .msg_iovlen = 1, 488b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 489b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 490b411b363SPhilipp Reisner }; 491b411b363SPhilipp Reisner int rv; 492b411b363SPhilipp Reisner 493b411b363SPhilipp Reisner oldfs = get_fs(); 494b411b363SPhilipp Reisner set_fs(KERNEL_DS); 495b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 496b411b363SPhilipp Reisner set_fs(oldfs); 497b411b363SPhilipp Reisner 498b411b363SPhilipp Reisner return rv; 499b411b363SPhilipp Reisner } 500b411b363SPhilipp Reisner 501b411b363SPhilipp Reisner static int drbd_recv(struct drbd_conf *mdev, void *buf, size_t size) 502b411b363SPhilipp Reisner { 503b411b363SPhilipp Reisner mm_segment_t oldfs; 504b411b363SPhilipp Reisner struct kvec iov = { 505b411b363SPhilipp Reisner .iov_base = buf, 506b411b363SPhilipp Reisner .iov_len = size, 507b411b363SPhilipp Reisner }; 508b411b363SPhilipp Reisner struct msghdr msg = { 509b411b363SPhilipp Reisner .msg_iovlen = 1, 510b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 511b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 512b411b363SPhilipp Reisner }; 513b411b363SPhilipp Reisner int rv; 514b411b363SPhilipp Reisner 515b411b363SPhilipp Reisner oldfs = get_fs(); 516b411b363SPhilipp Reisner set_fs(KERNEL_DS); 517b411b363SPhilipp Reisner 518b411b363SPhilipp Reisner for (;;) { 519e42325a5SPhilipp Reisner rv = sock_recvmsg(mdev->tconn->data.socket, &msg, size, msg.msg_flags); 520b411b363SPhilipp Reisner if (rv == size) 521b411b363SPhilipp Reisner break; 522b411b363SPhilipp Reisner 523b411b363SPhilipp Reisner /* Note: 524b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 525b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 526b411b363SPhilipp Reisner */ 527b411b363SPhilipp Reisner 528b411b363SPhilipp Reisner if (rv < 0) { 529b411b363SPhilipp Reisner if (rv == -ECONNRESET) 530b411b363SPhilipp Reisner dev_info(DEV, "sock was reset by peer\n"); 531b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 532b411b363SPhilipp Reisner dev_err(DEV, "sock_recvmsg returned %d\n", rv); 533b411b363SPhilipp Reisner break; 534b411b363SPhilipp Reisner } else if (rv == 0) { 535b411b363SPhilipp Reisner dev_info(DEV, "sock was shut down by peer\n"); 536b411b363SPhilipp Reisner break; 537b411b363SPhilipp Reisner } else { 538b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 539b411b363SPhilipp Reisner * after we read a partial message 540b411b363SPhilipp Reisner */ 541b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 542b411b363SPhilipp Reisner break; 543b411b363SPhilipp Reisner } 544b411b363SPhilipp Reisner }; 545b411b363SPhilipp Reisner 546b411b363SPhilipp Reisner set_fs(oldfs); 547b411b363SPhilipp Reisner 548b411b363SPhilipp Reisner if (rv != size) 549b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_BROKEN_PIPE)); 550b411b363SPhilipp Reisner 551b411b363SPhilipp Reisner return rv; 552b411b363SPhilipp Reisner } 553b411b363SPhilipp Reisner 5545dbf1673SLars Ellenberg /* quoting tcp(7): 5555dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5565dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5575dbf1673SLars Ellenberg * This is our wrapper to do so. 5585dbf1673SLars Ellenberg */ 5595dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5605dbf1673SLars Ellenberg unsigned int rcv) 5615dbf1673SLars Ellenberg { 5625dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5635dbf1673SLars Ellenberg if (snd) { 5645dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5655dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5665dbf1673SLars Ellenberg } 5675dbf1673SLars Ellenberg if (rcv) { 5685dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5695dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5705dbf1673SLars Ellenberg } 5715dbf1673SLars Ellenberg } 5725dbf1673SLars Ellenberg 573b411b363SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_conf *mdev) 574b411b363SPhilipp Reisner { 575b411b363SPhilipp Reisner const char *what; 576b411b363SPhilipp Reisner struct socket *sock; 577b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 578b411b363SPhilipp Reisner int err; 579b411b363SPhilipp Reisner int disconnect_on_error = 1; 580b411b363SPhilipp Reisner 581b2fb6dbeSPhilipp Reisner if (!get_net_conf(mdev->tconn)) 582b411b363SPhilipp Reisner return NULL; 583b411b363SPhilipp Reisner 584b411b363SPhilipp Reisner what = "sock_create_kern"; 58589e58e75SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)mdev->tconn->net_conf->my_addr)->sa_family, 586b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 587b411b363SPhilipp Reisner if (err < 0) { 588b411b363SPhilipp Reisner sock = NULL; 589b411b363SPhilipp Reisner goto out; 590b411b363SPhilipp Reisner } 591b411b363SPhilipp Reisner 592b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 59389e58e75SPhilipp Reisner sock->sk->sk_sndtimeo = mdev->tconn->net_conf->try_connect_int*HZ; 59489e58e75SPhilipp Reisner drbd_setbufsize(sock, mdev->tconn->net_conf->sndbuf_size, 59589e58e75SPhilipp Reisner mdev->tconn->net_conf->rcvbuf_size); 596b411b363SPhilipp Reisner 597b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 598b411b363SPhilipp Reisner * for the outgoing connections. 599b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 600b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 601b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 602b411b363SPhilipp Reisner * a free one dynamically. 603b411b363SPhilipp Reisner */ 60489e58e75SPhilipp Reisner memcpy(&src_in6, mdev->tconn->net_conf->my_addr, 60589e58e75SPhilipp Reisner min_t(int, mdev->tconn->net_conf->my_addr_len, sizeof(src_in6))); 60689e58e75SPhilipp Reisner if (((struct sockaddr *)mdev->tconn->net_conf->my_addr)->sa_family == AF_INET6) 607b411b363SPhilipp Reisner src_in6.sin6_port = 0; 608b411b363SPhilipp Reisner else 609b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 610b411b363SPhilipp Reisner 611b411b363SPhilipp Reisner what = "bind before connect"; 612b411b363SPhilipp Reisner err = sock->ops->bind(sock, 613b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 61489e58e75SPhilipp Reisner mdev->tconn->net_conf->my_addr_len); 615b411b363SPhilipp Reisner if (err < 0) 616b411b363SPhilipp Reisner goto out; 617b411b363SPhilipp Reisner 618b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 619b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 620b411b363SPhilipp Reisner disconnect_on_error = 0; 621b411b363SPhilipp Reisner what = "connect"; 622b411b363SPhilipp Reisner err = sock->ops->connect(sock, 62389e58e75SPhilipp Reisner (struct sockaddr *)mdev->tconn->net_conf->peer_addr, 62489e58e75SPhilipp Reisner mdev->tconn->net_conf->peer_addr_len, 0); 625b411b363SPhilipp Reisner 626b411b363SPhilipp Reisner out: 627b411b363SPhilipp Reisner if (err < 0) { 628b411b363SPhilipp Reisner if (sock) { 629b411b363SPhilipp Reisner sock_release(sock); 630b411b363SPhilipp Reisner sock = NULL; 631b411b363SPhilipp Reisner } 632b411b363SPhilipp Reisner switch (-err) { 633b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 634b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 635b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 636b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 637b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 638b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 639b411b363SPhilipp Reisner disconnect_on_error = 0; 640b411b363SPhilipp Reisner break; 641b411b363SPhilipp Reisner default: 642b411b363SPhilipp Reisner dev_err(DEV, "%s failed, err = %d\n", what, err); 643b411b363SPhilipp Reisner } 644b411b363SPhilipp Reisner if (disconnect_on_error) 645b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 646b411b363SPhilipp Reisner } 647b2fb6dbeSPhilipp Reisner put_net_conf(mdev->tconn); 648b411b363SPhilipp Reisner return sock; 649b411b363SPhilipp Reisner } 650b411b363SPhilipp Reisner 651b411b363SPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_conf *mdev) 652b411b363SPhilipp Reisner { 653b411b363SPhilipp Reisner int timeo, err; 654b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 655b411b363SPhilipp Reisner const char *what; 656b411b363SPhilipp Reisner 657b2fb6dbeSPhilipp Reisner if (!get_net_conf(mdev->tconn)) 658b411b363SPhilipp Reisner return NULL; 659b411b363SPhilipp Reisner 660b411b363SPhilipp Reisner what = "sock_create_kern"; 66189e58e75SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)mdev->tconn->net_conf->my_addr)->sa_family, 662b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 663b411b363SPhilipp Reisner if (err) { 664b411b363SPhilipp Reisner s_listen = NULL; 665b411b363SPhilipp Reisner goto out; 666b411b363SPhilipp Reisner } 667b411b363SPhilipp Reisner 66889e58e75SPhilipp Reisner timeo = mdev->tconn->net_conf->try_connect_int * HZ; 669b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 670b411b363SPhilipp Reisner 671b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 672b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 673b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 67489e58e75SPhilipp Reisner drbd_setbufsize(s_listen, mdev->tconn->net_conf->sndbuf_size, 67589e58e75SPhilipp Reisner mdev->tconn->net_conf->rcvbuf_size); 676b411b363SPhilipp Reisner 677b411b363SPhilipp Reisner what = "bind before listen"; 678b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 67989e58e75SPhilipp Reisner (struct sockaddr *) mdev->tconn->net_conf->my_addr, 68089e58e75SPhilipp Reisner mdev->tconn->net_conf->my_addr_len); 681b411b363SPhilipp Reisner if (err < 0) 682b411b363SPhilipp Reisner goto out; 683b411b363SPhilipp Reisner 684b411b363SPhilipp Reisner err = drbd_accept(mdev, &what, s_listen, &s_estab); 685b411b363SPhilipp Reisner 686b411b363SPhilipp Reisner out: 687b411b363SPhilipp Reisner if (s_listen) 688b411b363SPhilipp Reisner sock_release(s_listen); 689b411b363SPhilipp Reisner if (err < 0) { 690b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 691b411b363SPhilipp Reisner dev_err(DEV, "%s failed, err = %d\n", what, err); 692b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 693b411b363SPhilipp Reisner } 694b411b363SPhilipp Reisner } 695b2fb6dbeSPhilipp Reisner put_net_conf(mdev->tconn); 696b411b363SPhilipp Reisner 697b411b363SPhilipp Reisner return s_estab; 698b411b363SPhilipp Reisner } 699b411b363SPhilipp Reisner 700d8763023SAndreas Gruenbacher static int drbd_send_fp(struct drbd_conf *mdev, struct socket *sock, 701d8763023SAndreas Gruenbacher enum drbd_packet cmd) 702b411b363SPhilipp Reisner { 703c012949aSPhilipp Reisner struct p_header *h = &mdev->tconn->data.sbuf.header; 704b411b363SPhilipp Reisner 705b411b363SPhilipp Reisner return _drbd_send_cmd(mdev, sock, cmd, h, sizeof(*h), 0); 706b411b363SPhilipp Reisner } 707b411b363SPhilipp Reisner 708d8763023SAndreas Gruenbacher static enum drbd_packet drbd_recv_fp(struct drbd_conf *mdev, 709d8763023SAndreas Gruenbacher struct socket *sock) 710b411b363SPhilipp Reisner { 711e42325a5SPhilipp Reisner struct p_header80 *h = &mdev->tconn->data.rbuf.header.h80; 712b411b363SPhilipp Reisner int rr; 713b411b363SPhilipp Reisner 714b411b363SPhilipp Reisner rr = drbd_recv_short(mdev, sock, h, sizeof(*h), 0); 715b411b363SPhilipp Reisner 716ca9bc12bSAndreas Gruenbacher if (rr == sizeof(*h) && h->magic == cpu_to_be32(DRBD_MAGIC)) 717b411b363SPhilipp Reisner return be16_to_cpu(h->command); 718b411b363SPhilipp Reisner 719b411b363SPhilipp Reisner return 0xffff; 720b411b363SPhilipp Reisner } 721b411b363SPhilipp Reisner 722b411b363SPhilipp Reisner /** 723b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 724b411b363SPhilipp Reisner * @mdev: DRBD device. 725b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 726b411b363SPhilipp Reisner */ 727b411b363SPhilipp Reisner static int drbd_socket_okay(struct drbd_conf *mdev, struct socket **sock) 728b411b363SPhilipp Reisner { 729b411b363SPhilipp Reisner int rr; 730b411b363SPhilipp Reisner char tb[4]; 731b411b363SPhilipp Reisner 732b411b363SPhilipp Reisner if (!*sock) 73381e84650SAndreas Gruenbacher return false; 734b411b363SPhilipp Reisner 735b411b363SPhilipp Reisner rr = drbd_recv_short(mdev, *sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 736b411b363SPhilipp Reisner 737b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 73881e84650SAndreas Gruenbacher return true; 739b411b363SPhilipp Reisner } else { 740b411b363SPhilipp Reisner sock_release(*sock); 741b411b363SPhilipp Reisner *sock = NULL; 74281e84650SAndreas Gruenbacher return false; 743b411b363SPhilipp Reisner } 744b411b363SPhilipp Reisner } 745b411b363SPhilipp Reisner 746b411b363SPhilipp Reisner /* 747b411b363SPhilipp Reisner * return values: 748b411b363SPhilipp Reisner * 1 yes, we have a valid connection 749b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 750b411b363SPhilipp Reisner * -1 peer talks different language, 751b411b363SPhilipp Reisner * no point in trying again, please go standalone. 752b411b363SPhilipp Reisner * -2 We do not have a network config... 753b411b363SPhilipp Reisner */ 754b411b363SPhilipp Reisner static int drbd_connect(struct drbd_conf *mdev) 755b411b363SPhilipp Reisner { 756b411b363SPhilipp Reisner struct socket *s, *sock, *msock; 757b411b363SPhilipp Reisner int try, h, ok; 758b411b363SPhilipp Reisner 759e42325a5SPhilipp Reisner D_ASSERT(!mdev->tconn->data.socket); 760b411b363SPhilipp Reisner 761b411b363SPhilipp Reisner if (drbd_request_state(mdev, NS(conn, C_WF_CONNECTION)) < SS_SUCCESS) 762b411b363SPhilipp Reisner return -2; 763b411b363SPhilipp Reisner 764b411b363SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &mdev->flags); 765fd340c12SPhilipp Reisner mdev->tconn->agreed_pro_version = 99; 766fd340c12SPhilipp Reisner /* agreed_pro_version must be smaller than 100 so we send the old 767fd340c12SPhilipp Reisner header (h80) in the first packet and in the handshake packet. */ 768b411b363SPhilipp Reisner 769b411b363SPhilipp Reisner sock = NULL; 770b411b363SPhilipp Reisner msock = NULL; 771b411b363SPhilipp Reisner 772b411b363SPhilipp Reisner do { 773b411b363SPhilipp Reisner for (try = 0;;) { 774b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 775b411b363SPhilipp Reisner s = drbd_try_connect(mdev); 776b411b363SPhilipp Reisner if (s || ++try >= 3) 777b411b363SPhilipp Reisner break; 778b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 77920ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 780b411b363SPhilipp Reisner } 781b411b363SPhilipp Reisner 782b411b363SPhilipp Reisner if (s) { 783b411b363SPhilipp Reisner if (!sock) { 784b411b363SPhilipp Reisner drbd_send_fp(mdev, s, P_HAND_SHAKE_S); 785b411b363SPhilipp Reisner sock = s; 786b411b363SPhilipp Reisner s = NULL; 787b411b363SPhilipp Reisner } else if (!msock) { 788b411b363SPhilipp Reisner drbd_send_fp(mdev, s, P_HAND_SHAKE_M); 789b411b363SPhilipp Reisner msock = s; 790b411b363SPhilipp Reisner s = NULL; 791b411b363SPhilipp Reisner } else { 792b411b363SPhilipp Reisner dev_err(DEV, "Logic error in drbd_connect()\n"); 793b411b363SPhilipp Reisner goto out_release_sockets; 794b411b363SPhilipp Reisner } 795b411b363SPhilipp Reisner } 796b411b363SPhilipp Reisner 797b411b363SPhilipp Reisner if (sock && msock) { 79889e58e75SPhilipp Reisner schedule_timeout_interruptible(mdev->tconn->net_conf->ping_timeo*HZ/10); 799b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &sock); 800b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &msock) && ok; 801b411b363SPhilipp Reisner if (ok) 802b411b363SPhilipp Reisner break; 803b411b363SPhilipp Reisner } 804b411b363SPhilipp Reisner 805b411b363SPhilipp Reisner retry: 806b411b363SPhilipp Reisner s = drbd_wait_for_connect(mdev); 807b411b363SPhilipp Reisner if (s) { 808b411b363SPhilipp Reisner try = drbd_recv_fp(mdev, s); 809b411b363SPhilipp Reisner drbd_socket_okay(mdev, &sock); 810b411b363SPhilipp Reisner drbd_socket_okay(mdev, &msock); 811b411b363SPhilipp Reisner switch (try) { 812b411b363SPhilipp Reisner case P_HAND_SHAKE_S: 813b411b363SPhilipp Reisner if (sock) { 814b411b363SPhilipp Reisner dev_warn(DEV, "initial packet S crossed\n"); 815b411b363SPhilipp Reisner sock_release(sock); 816b411b363SPhilipp Reisner } 817b411b363SPhilipp Reisner sock = s; 818b411b363SPhilipp Reisner break; 819b411b363SPhilipp Reisner case P_HAND_SHAKE_M: 820b411b363SPhilipp Reisner if (msock) { 821b411b363SPhilipp Reisner dev_warn(DEV, "initial packet M crossed\n"); 822b411b363SPhilipp Reisner sock_release(msock); 823b411b363SPhilipp Reisner } 824b411b363SPhilipp Reisner msock = s; 825b411b363SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &mdev->flags); 826b411b363SPhilipp Reisner break; 827b411b363SPhilipp Reisner default: 828b411b363SPhilipp Reisner dev_warn(DEV, "Error receiving initial packet\n"); 829b411b363SPhilipp Reisner sock_release(s); 830b411b363SPhilipp Reisner if (random32() & 1) 831b411b363SPhilipp Reisner goto retry; 832b411b363SPhilipp Reisner } 833b411b363SPhilipp Reisner } 834b411b363SPhilipp Reisner 835b411b363SPhilipp Reisner if (mdev->state.conn <= C_DISCONNECTING) 836b411b363SPhilipp Reisner goto out_release_sockets; 837b411b363SPhilipp Reisner if (signal_pending(current)) { 838b411b363SPhilipp Reisner flush_signals(current); 839b411b363SPhilipp Reisner smp_rmb(); 840e6b3ea83SPhilipp Reisner if (get_t_state(&mdev->tconn->receiver) == EXITING) 841b411b363SPhilipp Reisner goto out_release_sockets; 842b411b363SPhilipp Reisner } 843b411b363SPhilipp Reisner 844b411b363SPhilipp Reisner if (sock && msock) { 845b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &sock); 846b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &msock) && ok; 847b411b363SPhilipp Reisner if (ok) 848b411b363SPhilipp Reisner break; 849b411b363SPhilipp Reisner } 850b411b363SPhilipp Reisner } while (1); 851b411b363SPhilipp Reisner 852b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 853b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 854b411b363SPhilipp Reisner 855b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 856b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 857b411b363SPhilipp Reisner 858b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 859b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 860b411b363SPhilipp Reisner 861b411b363SPhilipp Reisner /* NOT YET ... 86289e58e75SPhilipp Reisner * sock->sk->sk_sndtimeo = mdev->tconn->net_conf->timeout*HZ/10; 863b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 864b411b363SPhilipp Reisner * first set it to the P_HAND_SHAKE timeout, 865b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 866b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 86789e58e75SPhilipp Reisner sock->sk->sk_rcvtimeo = mdev->tconn->net_conf->ping_timeo*4*HZ/10; 868b411b363SPhilipp Reisner 86989e58e75SPhilipp Reisner msock->sk->sk_sndtimeo = mdev->tconn->net_conf->timeout*HZ/10; 87089e58e75SPhilipp Reisner msock->sk->sk_rcvtimeo = mdev->tconn->net_conf->ping_int*HZ; 871b411b363SPhilipp Reisner 872b411b363SPhilipp Reisner /* we don't want delays. 87325985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 874b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 875b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 876b411b363SPhilipp Reisner 877e42325a5SPhilipp Reisner mdev->tconn->data.socket = sock; 878e42325a5SPhilipp Reisner mdev->tconn->meta.socket = msock; 87931890f4aSPhilipp Reisner mdev->tconn->last_received = jiffies; 880b411b363SPhilipp Reisner 881e6b3ea83SPhilipp Reisner D_ASSERT(mdev->tconn->asender.task == NULL); 882b411b363SPhilipp Reisner 883b411b363SPhilipp Reisner h = drbd_do_handshake(mdev); 884b411b363SPhilipp Reisner if (h <= 0) 885b411b363SPhilipp Reisner return h; 886b411b363SPhilipp Reisner 887a0638456SPhilipp Reisner if (mdev->tconn->cram_hmac_tfm) { 888b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 889b10d96cbSJohannes Thoma switch (drbd_do_auth(mdev)) { 890b10d96cbSJohannes Thoma case -1: 891b411b363SPhilipp Reisner dev_err(DEV, "Authentication of peer failed\n"); 892b411b363SPhilipp Reisner return -1; 893b10d96cbSJohannes Thoma case 0: 894b10d96cbSJohannes Thoma dev_err(DEV, "Authentication of peer failed, trying again.\n"); 895b10d96cbSJohannes Thoma return 0; 896b411b363SPhilipp Reisner } 897b411b363SPhilipp Reisner } 898b411b363SPhilipp Reisner 899b411b363SPhilipp Reisner if (drbd_request_state(mdev, NS(conn, C_WF_REPORT_PARAMS)) < SS_SUCCESS) 900b411b363SPhilipp Reisner return 0; 901b411b363SPhilipp Reisner 90289e58e75SPhilipp Reisner sock->sk->sk_sndtimeo = mdev->tconn->net_conf->timeout*HZ/10; 903b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 904b411b363SPhilipp Reisner 905b411b363SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 906b411b363SPhilipp Reisner mdev->peer_seq = 0; 907b411b363SPhilipp Reisner 908e6b3ea83SPhilipp Reisner drbd_thread_start(&mdev->tconn->asender); 909b411b363SPhilipp Reisner 910148efa16SPhilipp Reisner if (drbd_send_protocol(mdev) == -1) 9117e2455c1SPhilipp Reisner return -1; 912b411b363SPhilipp Reisner drbd_send_sync_param(mdev, &mdev->sync_conf); 913e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, 0); 914b411b363SPhilipp Reisner drbd_send_uuids(mdev); 915b411b363SPhilipp Reisner drbd_send_state(mdev); 916b411b363SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 917b411b363SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 9187fde2be9SPhilipp Reisner mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */ 919b411b363SPhilipp Reisner 920b411b363SPhilipp Reisner return 1; 921b411b363SPhilipp Reisner 922b411b363SPhilipp Reisner out_release_sockets: 923b411b363SPhilipp Reisner if (sock) 924b411b363SPhilipp Reisner sock_release(sock); 925b411b363SPhilipp Reisner if (msock) 926b411b363SPhilipp Reisner sock_release(msock); 927b411b363SPhilipp Reisner return -1; 928b411b363SPhilipp Reisner } 929b411b363SPhilipp Reisner 930d8763023SAndreas Gruenbacher static bool decode_header(struct drbd_conf *mdev, struct p_header *h, 931d8763023SAndreas Gruenbacher enum drbd_packet *cmd, unsigned int *packet_size) 932b411b363SPhilipp Reisner { 933fd340c12SPhilipp Reisner if (h->h80.magic == cpu_to_be32(DRBD_MAGIC)) { 93402918be2SPhilipp Reisner *cmd = be16_to_cpu(h->h80.command); 93502918be2SPhilipp Reisner *packet_size = be16_to_cpu(h->h80.length); 936ca9bc12bSAndreas Gruenbacher } else if (h->h95.magic == cpu_to_be16(DRBD_MAGIC_BIG)) { 93702918be2SPhilipp Reisner *cmd = be16_to_cpu(h->h95.command); 938fd340c12SPhilipp Reisner *packet_size = be32_to_cpu(h->h95.length) & 0x00ffffff; 93902918be2SPhilipp Reisner } else { 940004352faSLars Ellenberg dev_err(DEV, "magic?? on data m: 0x%08x c: %d l: %d\n", 941004352faSLars Ellenberg be32_to_cpu(h->h80.magic), 942004352faSLars Ellenberg be16_to_cpu(h->h80.command), 943004352faSLars Ellenberg be16_to_cpu(h->h80.length)); 94481e84650SAndreas Gruenbacher return false; 945b411b363SPhilipp Reisner } 946257d0af6SPhilipp Reisner return true; 947257d0af6SPhilipp Reisner } 948257d0af6SPhilipp Reisner 949d8763023SAndreas Gruenbacher static int drbd_recv_header(struct drbd_conf *mdev, enum drbd_packet *cmd, 950d8763023SAndreas Gruenbacher unsigned int *packet_size) 951257d0af6SPhilipp Reisner { 952257d0af6SPhilipp Reisner struct p_header *h = &mdev->tconn->data.rbuf.header; 953257d0af6SPhilipp Reisner int r; 954257d0af6SPhilipp Reisner 955257d0af6SPhilipp Reisner r = drbd_recv(mdev, h, sizeof(*h)); 956257d0af6SPhilipp Reisner if (unlikely(r != sizeof(*h))) { 957257d0af6SPhilipp Reisner if (!signal_pending(current)) 958257d0af6SPhilipp Reisner dev_warn(DEV, "short read expecting header on sock: r=%d\n", r); 959257d0af6SPhilipp Reisner return false; 960257d0af6SPhilipp Reisner } 961257d0af6SPhilipp Reisner 962257d0af6SPhilipp Reisner r = decode_header(mdev, h, cmd, packet_size); 96331890f4aSPhilipp Reisner mdev->tconn->last_received = jiffies; 964b411b363SPhilipp Reisner 965257d0af6SPhilipp Reisner return r; 966b411b363SPhilipp Reisner } 967b411b363SPhilipp Reisner 9682451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 969b411b363SPhilipp Reisner { 970b411b363SPhilipp Reisner int rv; 971b411b363SPhilipp Reisner 972b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 973fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 974dd3932edSChristoph Hellwig NULL); 975b411b363SPhilipp Reisner if (rv) { 976b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 977b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 978b411b363SPhilipp Reisner * don't try again for ANY return value != 0 979b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 980b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 981b411b363SPhilipp Reisner } 982b411b363SPhilipp Reisner put_ldev(mdev); 983b411b363SPhilipp Reisner } 984b411b363SPhilipp Reisner } 985b411b363SPhilipp Reisner 986b411b363SPhilipp Reisner /** 987b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 988b411b363SPhilipp Reisner * @mdev: DRBD device. 989b411b363SPhilipp Reisner * @epoch: Epoch object. 990b411b363SPhilipp Reisner * @ev: Epoch event. 991b411b363SPhilipp Reisner */ 992b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 993b411b363SPhilipp Reisner struct drbd_epoch *epoch, 994b411b363SPhilipp Reisner enum epoch_event ev) 995b411b363SPhilipp Reisner { 9962451fc3bSPhilipp Reisner int epoch_size; 997b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 998b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 999b411b363SPhilipp Reisner 1000b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1001b411b363SPhilipp Reisner do { 1002b411b363SPhilipp Reisner next_epoch = NULL; 1003b411b363SPhilipp Reisner 1004b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1005b411b363SPhilipp Reisner 1006b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1007b411b363SPhilipp Reisner case EV_PUT: 1008b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1009b411b363SPhilipp Reisner break; 1010b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1011b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1012b411b363SPhilipp Reisner break; 1013b411b363SPhilipp Reisner case EV_BECAME_LAST: 1014b411b363SPhilipp Reisner /* nothing to do*/ 1015b411b363SPhilipp Reisner break; 1016b411b363SPhilipp Reisner } 1017b411b363SPhilipp Reisner 1018b411b363SPhilipp Reisner if (epoch_size != 0 && 1019b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 10202451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1021b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1022b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1023b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1024b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1025b411b363SPhilipp Reisner } 1026b411b363SPhilipp Reisner dec_unacked(mdev); 1027b411b363SPhilipp Reisner 1028b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1029b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1030b411b363SPhilipp Reisner list_del(&epoch->list); 1031b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1032b411b363SPhilipp Reisner mdev->epochs--; 1033b411b363SPhilipp Reisner kfree(epoch); 1034b411b363SPhilipp Reisner 1035b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1036b411b363SPhilipp Reisner rv = FE_DESTROYED; 1037b411b363SPhilipp Reisner } else { 1038b411b363SPhilipp Reisner epoch->flags = 0; 1039b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1040698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1041b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1042b411b363SPhilipp Reisner rv = FE_RECYCLED; 10432451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1044b411b363SPhilipp Reisner } 1045b411b363SPhilipp Reisner } 1046b411b363SPhilipp Reisner 1047b411b363SPhilipp Reisner if (!next_epoch) 1048b411b363SPhilipp Reisner break; 1049b411b363SPhilipp Reisner 1050b411b363SPhilipp Reisner epoch = next_epoch; 1051b411b363SPhilipp Reisner } while (1); 1052b411b363SPhilipp Reisner 1053b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1054b411b363SPhilipp Reisner 1055b411b363SPhilipp Reisner return rv; 1056b411b363SPhilipp Reisner } 1057b411b363SPhilipp Reisner 1058b411b363SPhilipp Reisner /** 1059b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1060b411b363SPhilipp Reisner * @mdev: DRBD device. 1061b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1062b411b363SPhilipp Reisner */ 1063b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1064b411b363SPhilipp Reisner { 1065b411b363SPhilipp Reisner enum write_ordering_e pwo; 1066b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1067b411b363SPhilipp Reisner [WO_none] = "none", 1068b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1069b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1070b411b363SPhilipp Reisner }; 1071b411b363SPhilipp Reisner 1072b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1073b411b363SPhilipp Reisner wo = min(pwo, wo); 1074b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1075b411b363SPhilipp Reisner wo = WO_drain_io; 1076b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1077b411b363SPhilipp Reisner wo = WO_none; 1078b411b363SPhilipp Reisner mdev->write_ordering = wo; 10792451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1080b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1081b411b363SPhilipp Reisner } 1082b411b363SPhilipp Reisner 1083b411b363SPhilipp Reisner /** 108445bb912bSLars Ellenberg * drbd_submit_ee() 108545bb912bSLars Ellenberg * @mdev: DRBD device. 108645bb912bSLars Ellenberg * @e: epoch entry 108745bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 108810f6d992SLars Ellenberg * 108910f6d992SLars Ellenberg * May spread the pages to multiple bios, 109010f6d992SLars Ellenberg * depending on bio_add_page restrictions. 109110f6d992SLars Ellenberg * 109210f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 109310f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 109410f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 109510f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 109610f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 109710f6d992SLars Ellenberg * on certain Xen deployments. 109845bb912bSLars Ellenberg */ 109945bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 110045bb912bSLars Ellenberg int drbd_submit_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e, 110145bb912bSLars Ellenberg const unsigned rw, const int fault_type) 110245bb912bSLars Ellenberg { 110345bb912bSLars Ellenberg struct bio *bios = NULL; 110445bb912bSLars Ellenberg struct bio *bio; 110545bb912bSLars Ellenberg struct page *page = e->pages; 1106010f6e67SAndreas Gruenbacher sector_t sector = e->i.sector; 1107010f6e67SAndreas Gruenbacher unsigned ds = e->i.size; 110845bb912bSLars Ellenberg unsigned n_bios = 0; 110945bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 111010f6d992SLars Ellenberg int err = -ENOMEM; 111145bb912bSLars Ellenberg 111245bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 111345bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 111445bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 111545bb912bSLars Ellenberg * request in more than one bio. */ 111645bb912bSLars Ellenberg next_bio: 111745bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 111845bb912bSLars Ellenberg if (!bio) { 111945bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 112045bb912bSLars Ellenberg goto fail; 112145bb912bSLars Ellenberg } 1122010f6e67SAndreas Gruenbacher /* > e->i.sector, unless this is the first bio */ 112345bb912bSLars Ellenberg bio->bi_sector = sector; 112445bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 112545bb912bSLars Ellenberg bio->bi_rw = rw; 112645bb912bSLars Ellenberg bio->bi_private = e; 112745bb912bSLars Ellenberg bio->bi_end_io = drbd_endio_sec; 112845bb912bSLars Ellenberg 112945bb912bSLars Ellenberg bio->bi_next = bios; 113045bb912bSLars Ellenberg bios = bio; 113145bb912bSLars Ellenberg ++n_bios; 113245bb912bSLars Ellenberg 113345bb912bSLars Ellenberg page_chain_for_each(page) { 113445bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 113545bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 113610f6d992SLars Ellenberg /* A single page must always be possible! 113710f6d992SLars Ellenberg * But in case it fails anyways, 113810f6d992SLars Ellenberg * we deal with it, and complain (below). */ 113910f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 114010f6d992SLars Ellenberg dev_err(DEV, 114110f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 114210f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 114310f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 114410f6d992SLars Ellenberg err = -ENOSPC; 114510f6d992SLars Ellenberg goto fail; 114610f6d992SLars Ellenberg } 114745bb912bSLars Ellenberg goto next_bio; 114845bb912bSLars Ellenberg } 114945bb912bSLars Ellenberg ds -= len; 115045bb912bSLars Ellenberg sector += len >> 9; 115145bb912bSLars Ellenberg --nr_pages; 115245bb912bSLars Ellenberg } 115345bb912bSLars Ellenberg D_ASSERT(page == NULL); 115445bb912bSLars Ellenberg D_ASSERT(ds == 0); 115545bb912bSLars Ellenberg 115645bb912bSLars Ellenberg atomic_set(&e->pending_bios, n_bios); 115745bb912bSLars Ellenberg do { 115845bb912bSLars Ellenberg bio = bios; 115945bb912bSLars Ellenberg bios = bios->bi_next; 116045bb912bSLars Ellenberg bio->bi_next = NULL; 116145bb912bSLars Ellenberg 116245bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 116345bb912bSLars Ellenberg } while (bios); 116445bb912bSLars Ellenberg return 0; 116545bb912bSLars Ellenberg 116645bb912bSLars Ellenberg fail: 116745bb912bSLars Ellenberg while (bios) { 116845bb912bSLars Ellenberg bio = bios; 116945bb912bSLars Ellenberg bios = bios->bi_next; 117045bb912bSLars Ellenberg bio_put(bio); 117145bb912bSLars Ellenberg } 117210f6d992SLars Ellenberg return err; 117345bb912bSLars Ellenberg } 117445bb912bSLars Ellenberg 1175d8763023SAndreas Gruenbacher static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packet cmd, 1176d8763023SAndreas Gruenbacher unsigned int data_size) 1177b411b363SPhilipp Reisner { 11782451fc3bSPhilipp Reisner int rv; 1179e42325a5SPhilipp Reisner struct p_barrier *p = &mdev->tconn->data.rbuf.barrier; 1180b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1181b411b363SPhilipp Reisner 1182b411b363SPhilipp Reisner inc_unacked(mdev); 1183b411b363SPhilipp Reisner 1184b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1185b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1186b411b363SPhilipp Reisner 1187b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1188b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1189b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1190b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1191b411b363SPhilipp Reisner * completed. */ 1192b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1193b411b363SPhilipp Reisner case WO_none: 1194b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 119581e84650SAndreas Gruenbacher return true; 1196b411b363SPhilipp Reisner 1197b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1198b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1199b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12002451fc3bSPhilipp Reisner if (epoch) 12012451fc3bSPhilipp Reisner break; 12022451fc3bSPhilipp Reisner else 1203b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 12042451fc3bSPhilipp Reisner /* Fall through */ 12052451fc3bSPhilipp Reisner 12062451fc3bSPhilipp Reisner case WO_bdev_flush: 12072451fc3bSPhilipp Reisner case WO_drain_io: 1208b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 12092451fc3bSPhilipp Reisner drbd_flush(mdev); 12102451fc3bSPhilipp Reisner 12112451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 12122451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12132451fc3bSPhilipp Reisner if (epoch) 12142451fc3bSPhilipp Reisner break; 1215b411b363SPhilipp Reisner } 1216b411b363SPhilipp Reisner 12172451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 12182451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 12192451fc3bSPhilipp Reisner 12202451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 12212451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1222b411b363SPhilipp Reisner 122381e84650SAndreas Gruenbacher return true; 12242451fc3bSPhilipp Reisner default: 12252451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 122681e84650SAndreas Gruenbacher return false; 1227b411b363SPhilipp Reisner } 1228b411b363SPhilipp Reisner 1229b411b363SPhilipp Reisner epoch->flags = 0; 1230b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1231b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1232b411b363SPhilipp Reisner 1233b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1234b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1235b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1236b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1237b411b363SPhilipp Reisner mdev->epochs++; 1238b411b363SPhilipp Reisner } else { 1239b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1240b411b363SPhilipp Reisner kfree(epoch); 1241b411b363SPhilipp Reisner } 1242b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1243b411b363SPhilipp Reisner 124481e84650SAndreas Gruenbacher return true; 1245b411b363SPhilipp Reisner } 1246b411b363SPhilipp Reisner 1247b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1248b411b363SPhilipp Reisner * and from receive_Data */ 1249b411b363SPhilipp Reisner static struct drbd_epoch_entry * 1250b411b363SPhilipp Reisner read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, int data_size) __must_hold(local) 1251b411b363SPhilipp Reisner { 12526666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1253b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 1254b411b363SPhilipp Reisner struct page *page; 125545bb912bSLars Ellenberg int dgs, ds, rr; 1256a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1257a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 12586b4388acSPhilipp Reisner unsigned long *data; 1259b411b363SPhilipp Reisner 1260a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1261a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1262b411b363SPhilipp Reisner 1263b411b363SPhilipp Reisner if (dgs) { 1264b411b363SPhilipp Reisner rr = drbd_recv(mdev, dig_in, dgs); 1265b411b363SPhilipp Reisner if (rr != dgs) { 12660ddc5549SLars Ellenberg if (!signal_pending(current)) 12670ddc5549SLars Ellenberg dev_warn(DEV, 12680ddc5549SLars Ellenberg "short read receiving data digest: read %d expected %d\n", 1269b411b363SPhilipp Reisner rr, dgs); 1270b411b363SPhilipp Reisner return NULL; 1271b411b363SPhilipp Reisner } 1272b411b363SPhilipp Reisner } 1273b411b363SPhilipp Reisner 1274b411b363SPhilipp Reisner data_size -= dgs; 1275b411b363SPhilipp Reisner 1276841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1277841ce241SAndreas Gruenbacher return NULL; 1278841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1279841ce241SAndreas Gruenbacher return NULL; 1280841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1281841ce241SAndreas Gruenbacher return NULL; 1282b411b363SPhilipp Reisner 12836666032aSLars Ellenberg /* even though we trust out peer, 12846666032aSLars Ellenberg * we sometimes have to double check. */ 12856666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1286fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1287fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 12886666032aSLars Ellenberg (unsigned long long)capacity, 12896666032aSLars Ellenberg (unsigned long long)sector, data_size); 12906666032aSLars Ellenberg return NULL; 12916666032aSLars Ellenberg } 12926666032aSLars Ellenberg 1293b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1294b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1295b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1296b411b363SPhilipp Reisner e = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO); 1297b411b363SPhilipp Reisner if (!e) 1298b411b363SPhilipp Reisner return NULL; 129945bb912bSLars Ellenberg 1300b411b363SPhilipp Reisner ds = data_size; 130145bb912bSLars Ellenberg page = e->pages; 130245bb912bSLars Ellenberg page_chain_for_each(page) { 130345bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 13046b4388acSPhilipp Reisner data = kmap(page); 130545bb912bSLars Ellenberg rr = drbd_recv(mdev, data, len); 13060cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 13076b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 13086b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 13096b4388acSPhilipp Reisner } 1310b411b363SPhilipp Reisner kunmap(page); 131145bb912bSLars Ellenberg if (rr != len) { 1312b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 13130ddc5549SLars Ellenberg if (!signal_pending(current)) 1314b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 131545bb912bSLars Ellenberg rr, len); 1316b411b363SPhilipp Reisner return NULL; 1317b411b363SPhilipp Reisner } 1318b411b363SPhilipp Reisner ds -= rr; 1319b411b363SPhilipp Reisner } 1320b411b363SPhilipp Reisner 1321b411b363SPhilipp Reisner if (dgs) { 1322a0638456SPhilipp Reisner drbd_csum_ee(mdev, mdev->tconn->integrity_r_tfm, e, dig_vv); 1323b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1324470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1325470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1326b411b363SPhilipp Reisner drbd_bcast_ee(mdev, "digest failed", 1327b411b363SPhilipp Reisner dgs, dig_in, dig_vv, e); 1328b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 1329b411b363SPhilipp Reisner return NULL; 1330b411b363SPhilipp Reisner } 1331b411b363SPhilipp Reisner } 1332b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1333b411b363SPhilipp Reisner return e; 1334b411b363SPhilipp Reisner } 1335b411b363SPhilipp Reisner 1336b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1337b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1338b411b363SPhilipp Reisner */ 1339b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1340b411b363SPhilipp Reisner { 1341b411b363SPhilipp Reisner struct page *page; 1342b411b363SPhilipp Reisner int rr, rv = 1; 1343b411b363SPhilipp Reisner void *data; 1344b411b363SPhilipp Reisner 1345c3470cdeSLars Ellenberg if (!data_size) 134681e84650SAndreas Gruenbacher return true; 1347c3470cdeSLars Ellenberg 134845bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, 1, 1); 1349b411b363SPhilipp Reisner 1350b411b363SPhilipp Reisner data = kmap(page); 1351b411b363SPhilipp Reisner while (data_size) { 1352b411b363SPhilipp Reisner rr = drbd_recv(mdev, data, min_t(int, data_size, PAGE_SIZE)); 1353b411b363SPhilipp Reisner if (rr != min_t(int, data_size, PAGE_SIZE)) { 1354b411b363SPhilipp Reisner rv = 0; 13550ddc5549SLars Ellenberg if (!signal_pending(current)) 13560ddc5549SLars Ellenberg dev_warn(DEV, 13570ddc5549SLars Ellenberg "short read receiving data: read %d expected %d\n", 1358b411b363SPhilipp Reisner rr, min_t(int, data_size, PAGE_SIZE)); 1359b411b363SPhilipp Reisner break; 1360b411b363SPhilipp Reisner } 1361b411b363SPhilipp Reisner data_size -= rr; 1362b411b363SPhilipp Reisner } 1363b411b363SPhilipp Reisner kunmap(page); 1364435f0740SLars Ellenberg drbd_pp_free(mdev, page, 0); 1365b411b363SPhilipp Reisner return rv; 1366b411b363SPhilipp Reisner } 1367b411b363SPhilipp Reisner 1368b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1369b411b363SPhilipp Reisner sector_t sector, int data_size) 1370b411b363SPhilipp Reisner { 1371b411b363SPhilipp Reisner struct bio_vec *bvec; 1372b411b363SPhilipp Reisner struct bio *bio; 1373b411b363SPhilipp Reisner int dgs, rr, i, expect; 1374a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1375a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1376b411b363SPhilipp Reisner 1377a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1378a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1379b411b363SPhilipp Reisner 1380b411b363SPhilipp Reisner if (dgs) { 1381b411b363SPhilipp Reisner rr = drbd_recv(mdev, dig_in, dgs); 1382b411b363SPhilipp Reisner if (rr != dgs) { 13830ddc5549SLars Ellenberg if (!signal_pending(current)) 13840ddc5549SLars Ellenberg dev_warn(DEV, 13850ddc5549SLars Ellenberg "short read receiving data reply digest: read %d expected %d\n", 1386b411b363SPhilipp Reisner rr, dgs); 1387b411b363SPhilipp Reisner return 0; 1388b411b363SPhilipp Reisner } 1389b411b363SPhilipp Reisner } 1390b411b363SPhilipp Reisner 1391b411b363SPhilipp Reisner data_size -= dgs; 1392b411b363SPhilipp Reisner 1393b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1394b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1395b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1396b411b363SPhilipp Reisner 1397b411b363SPhilipp Reisner bio = req->master_bio; 1398b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1399b411b363SPhilipp Reisner 1400b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1401b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1402b411b363SPhilipp Reisner rr = drbd_recv(mdev, 1403b411b363SPhilipp Reisner kmap(bvec->bv_page)+bvec->bv_offset, 1404b411b363SPhilipp Reisner expect); 1405b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1406b411b363SPhilipp Reisner if (rr != expect) { 14070ddc5549SLars Ellenberg if (!signal_pending(current)) 1408b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply: " 1409b411b363SPhilipp Reisner "read %d expected %d\n", 1410b411b363SPhilipp Reisner rr, expect); 1411b411b363SPhilipp Reisner return 0; 1412b411b363SPhilipp Reisner } 1413b411b363SPhilipp Reisner data_size -= rr; 1414b411b363SPhilipp Reisner } 1415b411b363SPhilipp Reisner 1416b411b363SPhilipp Reisner if (dgs) { 1417a0638456SPhilipp Reisner drbd_csum_bio(mdev, mdev->tconn->integrity_r_tfm, bio, dig_vv); 1418b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1419b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 1420b411b363SPhilipp Reisner return 0; 1421b411b363SPhilipp Reisner } 1422b411b363SPhilipp Reisner } 1423b411b363SPhilipp Reisner 1424b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 1425b411b363SPhilipp Reisner return 1; 1426b411b363SPhilipp Reisner } 1427b411b363SPhilipp Reisner 1428b411b363SPhilipp Reisner /* e_end_resync_block() is called via 1429b411b363SPhilipp Reisner * drbd_process_done_ee() by asender only */ 1430b411b363SPhilipp Reisner static int e_end_resync_block(struct drbd_conf *mdev, struct drbd_work *w, int unused) 1431b411b363SPhilipp Reisner { 1432b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1433010f6e67SAndreas Gruenbacher sector_t sector = e->i.sector; 1434b411b363SPhilipp Reisner int ok; 1435b411b363SPhilipp Reisner 14368b946255SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&e->i)); 1437b411b363SPhilipp Reisner 143845bb912bSLars Ellenberg if (likely((e->flags & EE_WAS_ERROR) == 0)) { 1439010f6e67SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, e->i.size); 1440b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_RS_WRITE_ACK, e); 1441b411b363SPhilipp Reisner } else { 1442b411b363SPhilipp Reisner /* Record failure to sync */ 1443010f6e67SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, e->i.size); 1444b411b363SPhilipp Reisner 1445b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_NEG_ACK, e); 1446b411b363SPhilipp Reisner } 1447b411b363SPhilipp Reisner dec_unacked(mdev); 1448b411b363SPhilipp Reisner 1449b411b363SPhilipp Reisner return ok; 1450b411b363SPhilipp Reisner } 1451b411b363SPhilipp Reisner 1452b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1453b411b363SPhilipp Reisner { 1454b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 1455b411b363SPhilipp Reisner 1456b411b363SPhilipp Reisner e = read_in_block(mdev, ID_SYNCER, sector, data_size); 145745bb912bSLars Ellenberg if (!e) 145845bb912bSLars Ellenberg goto fail; 1459b411b363SPhilipp Reisner 1460b411b363SPhilipp Reisner dec_rs_pending(mdev); 1461b411b363SPhilipp Reisner 1462b411b363SPhilipp Reisner inc_unacked(mdev); 1463b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1464b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1465b411b363SPhilipp Reisner 146645bb912bSLars Ellenberg e->w.cb = e_end_resync_block; 146745bb912bSLars Ellenberg 146887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1469b411b363SPhilipp Reisner list_add(&e->w.list, &mdev->sync_ee); 147087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1471b411b363SPhilipp Reisner 14720f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 147345bb912bSLars Ellenberg if (drbd_submit_ee(mdev, e, WRITE, DRBD_FAULT_RS_WR) == 0) 147481e84650SAndreas Gruenbacher return true; 147545bb912bSLars Ellenberg 147610f6d992SLars Ellenberg /* don't care for the reason here */ 147710f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 147887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 147922cc37a9SLars Ellenberg list_del(&e->w.list); 148087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 148122cc37a9SLars Ellenberg 148245bb912bSLars Ellenberg drbd_free_ee(mdev, e); 148345bb912bSLars Ellenberg fail: 148445bb912bSLars Ellenberg put_ldev(mdev); 148581e84650SAndreas Gruenbacher return false; 1486b411b363SPhilipp Reisner } 1487b411b363SPhilipp Reisner 1488668eebc6SAndreas Gruenbacher static struct drbd_request * 1489bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1490bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1491668eebc6SAndreas Gruenbacher { 1492668eebc6SAndreas Gruenbacher struct drbd_request *req; 1493668eebc6SAndreas Gruenbacher 1494bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1495bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 1496bc9c5c41SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i)) 1497668eebc6SAndreas Gruenbacher return req; 1498c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1499c3afd8f5SAndreas Gruenbacher dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func, 1500c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1501c3afd8f5SAndreas Gruenbacher } 1502668eebc6SAndreas Gruenbacher return NULL; 1503668eebc6SAndreas Gruenbacher } 1504668eebc6SAndreas Gruenbacher 1505d8763023SAndreas Gruenbacher static int receive_DataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1506d8763023SAndreas Gruenbacher unsigned int data_size) 1507b411b363SPhilipp Reisner { 1508b411b363SPhilipp Reisner struct drbd_request *req; 1509b411b363SPhilipp Reisner sector_t sector; 1510b411b363SPhilipp Reisner int ok; 1511e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1512b411b363SPhilipp Reisner 1513b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1514b411b363SPhilipp Reisner 151587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1516bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 151787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1518c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 151981e84650SAndreas Gruenbacher return false; 1520b411b363SPhilipp Reisner 152124c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1522b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1523b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1524b411b363SPhilipp Reisner ok = recv_dless_read(mdev, req, sector, data_size); 1525b411b363SPhilipp Reisner 1526b411b363SPhilipp Reisner if (ok) 15278554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1528b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1529b411b363SPhilipp Reisner * I don't think we may complete this just yet 1530b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1531b411b363SPhilipp Reisner 1532b411b363SPhilipp Reisner return ok; 1533b411b363SPhilipp Reisner } 1534b411b363SPhilipp Reisner 1535d8763023SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1536d8763023SAndreas Gruenbacher unsigned int data_size) 1537b411b363SPhilipp Reisner { 1538b411b363SPhilipp Reisner sector_t sector; 1539b411b363SPhilipp Reisner int ok; 1540e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1541b411b363SPhilipp Reisner 1542b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1543b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1544b411b363SPhilipp Reisner 1545b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1546b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1547b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 15489c50842aSAndreas Gruenbacher * or in drbd_endio_sec. */ 1549b411b363SPhilipp Reisner ok = recv_resync_read(mdev, sector, data_size); 1550b411b363SPhilipp Reisner } else { 1551b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1552b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1553b411b363SPhilipp Reisner 1554b411b363SPhilipp Reisner ok = drbd_drain_block(mdev, data_size); 1555b411b363SPhilipp Reisner 15562b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1557b411b363SPhilipp Reisner } 1558b411b363SPhilipp Reisner 1559778f271dSPhilipp Reisner atomic_add(data_size >> 9, &mdev->rs_sect_in); 1560778f271dSPhilipp Reisner 1561b411b363SPhilipp Reisner return ok; 1562b411b363SPhilipp Reisner } 1563b411b363SPhilipp Reisner 1564b411b363SPhilipp Reisner /* e_end_block() is called via drbd_process_done_ee(). 1565b411b363SPhilipp Reisner * this means this function only runs in the asender thread 1566b411b363SPhilipp Reisner */ 1567b411b363SPhilipp Reisner static int e_end_block(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1568b411b363SPhilipp Reisner { 1569b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1570010f6e67SAndreas Gruenbacher sector_t sector = e->i.sector; 1571b411b363SPhilipp Reisner int ok = 1, pcmd; 1572b411b363SPhilipp Reisner 157389e58e75SPhilipp Reisner if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C) { 157445bb912bSLars Ellenberg if (likely((e->flags & EE_WAS_ERROR) == 0)) { 1575b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1576b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1577b411b363SPhilipp Reisner e->flags & EE_MAY_SET_IN_SYNC) ? 1578b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1579b411b363SPhilipp Reisner ok &= drbd_send_ack(mdev, pcmd, e); 1580b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1581010f6e67SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, e->i.size); 1582b411b363SPhilipp Reisner } else { 1583b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_NEG_ACK, e); 1584b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1585b411b363SPhilipp Reisner * maybe assert this? */ 1586b411b363SPhilipp Reisner } 1587b411b363SPhilipp Reisner dec_unacked(mdev); 1588b411b363SPhilipp Reisner } 1589b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1590b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 159189e58e75SPhilipp Reisner if (mdev->tconn->net_conf->two_primaries) { 159287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 15938b946255SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&e->i)); 15948b946255SAndreas Gruenbacher drbd_remove_interval(&mdev->epoch_entries, &e->i); 15958b946255SAndreas Gruenbacher drbd_clear_interval(&e->i); 159687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1597bb3bfe96SAndreas Gruenbacher } else 15988b946255SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&e->i)); 1599b411b363SPhilipp Reisner 1600b411b363SPhilipp Reisner drbd_may_finish_epoch(mdev, e->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1601b411b363SPhilipp Reisner 1602b411b363SPhilipp Reisner return ok; 1603b411b363SPhilipp Reisner } 1604b411b363SPhilipp Reisner 1605b411b363SPhilipp Reisner static int e_send_discard_ack(struct drbd_conf *mdev, struct drbd_work *w, int unused) 1606b411b363SPhilipp Reisner { 1607b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1608b411b363SPhilipp Reisner int ok = 1; 1609b411b363SPhilipp Reisner 161089e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 1611b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_DISCARD_ACK, e); 1612b411b363SPhilipp Reisner 161387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 16148b946255SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&e->i)); 16158b946255SAndreas Gruenbacher drbd_remove_interval(&mdev->epoch_entries, &e->i); 16168b946255SAndreas Gruenbacher drbd_clear_interval(&e->i); 161787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1618b411b363SPhilipp Reisner 1619b411b363SPhilipp Reisner dec_unacked(mdev); 1620b411b363SPhilipp Reisner 1621b411b363SPhilipp Reisner return ok; 1622b411b363SPhilipp Reisner } 1623b411b363SPhilipp Reisner 16243e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 16253e394da1SAndreas Gruenbacher { 16263e394da1SAndreas Gruenbacher /* 16273e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 16283e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 16293e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 16303e394da1SAndreas Gruenbacher */ 16313e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 16323e394da1SAndreas Gruenbacher } 16333e394da1SAndreas Gruenbacher 16343e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 16353e394da1SAndreas Gruenbacher { 16363e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 16373e394da1SAndreas Gruenbacher } 16383e394da1SAndreas Gruenbacher 16393e394da1SAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int new_seq) 16403e394da1SAndreas Gruenbacher { 16413e394da1SAndreas Gruenbacher unsigned int m; 16423e394da1SAndreas Gruenbacher 16433e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 16443e394da1SAndreas Gruenbacher m = seq_max(mdev->peer_seq, new_seq); 16453e394da1SAndreas Gruenbacher mdev->peer_seq = m; 16463e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 16473e394da1SAndreas Gruenbacher if (m == new_seq) 16483e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 16493e394da1SAndreas Gruenbacher } 16503e394da1SAndreas Gruenbacher 1651b411b363SPhilipp Reisner /* Called from receive_Data. 1652b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1653b411b363SPhilipp Reisner * 1654b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1655b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1656b411b363SPhilipp Reisner * been sent. 1657b411b363SPhilipp Reisner * 1658b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1659b411b363SPhilipp Reisner * 1660b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1661b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1662b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1663b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1664b411b363SPhilipp Reisner * 1665b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1666b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1667b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1668b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1669b411b363SPhilipp Reisner * 1670b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1671b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 1672b411b363SPhilipp Reisner static int drbd_wait_peer_seq(struct drbd_conf *mdev, const u32 packet_seq) 1673b411b363SPhilipp Reisner { 1674b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1675b411b363SPhilipp Reisner unsigned int p_seq; 1676b411b363SPhilipp Reisner long timeout; 1677b411b363SPhilipp Reisner int ret = 0; 1678b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1679b411b363SPhilipp Reisner for (;;) { 1680b411b363SPhilipp Reisner prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 16813e394da1SAndreas Gruenbacher if (!seq_greater(packet_seq, mdev->peer_seq + 1)) 1682b411b363SPhilipp Reisner break; 1683b411b363SPhilipp Reisner if (signal_pending(current)) { 1684b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1685b411b363SPhilipp Reisner break; 1686b411b363SPhilipp Reisner } 1687b411b363SPhilipp Reisner p_seq = mdev->peer_seq; 1688b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1689b411b363SPhilipp Reisner timeout = schedule_timeout(30*HZ); 1690b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1691b411b363SPhilipp Reisner if (timeout == 0 && p_seq == mdev->peer_seq) { 1692b411b363SPhilipp Reisner ret = -ETIMEDOUT; 1693b411b363SPhilipp Reisner dev_err(DEV, "ASSERT FAILED waited 30 seconds for sequence update, forcing reconnect\n"); 1694b411b363SPhilipp Reisner break; 1695b411b363SPhilipp Reisner } 1696b411b363SPhilipp Reisner } 1697b411b363SPhilipp Reisner finish_wait(&mdev->seq_wait, &wait); 1698b411b363SPhilipp Reisner if (mdev->peer_seq+1 == packet_seq) 1699b411b363SPhilipp Reisner mdev->peer_seq++; 1700b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1701b411b363SPhilipp Reisner return ret; 1702b411b363SPhilipp Reisner } 1703b411b363SPhilipp Reisner 1704688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1705688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1706688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1707688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 170876d2e7ecSPhilipp Reisner { 170976d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 171076d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1711688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 171276d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 171376d2e7ecSPhilipp Reisner } 171476d2e7ecSPhilipp Reisner 1715b411b363SPhilipp Reisner /* mirrored write */ 1716d8763023SAndreas Gruenbacher static int receive_Data(struct drbd_conf *mdev, enum drbd_packet cmd, 1717d8763023SAndreas Gruenbacher unsigned int data_size) 1718b411b363SPhilipp Reisner { 1719b411b363SPhilipp Reisner sector_t sector; 1720b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 1721e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1722b411b363SPhilipp Reisner int rw = WRITE; 1723b411b363SPhilipp Reisner u32 dp_flags; 1724b411b363SPhilipp Reisner 1725b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 1726b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1727b411b363SPhilipp Reisner if (mdev->peer_seq+1 == be32_to_cpu(p->seq_num)) 1728b411b363SPhilipp Reisner mdev->peer_seq++; 1729b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1730b411b363SPhilipp Reisner 17312b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1732b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 1733b411b363SPhilipp Reisner return drbd_drain_block(mdev, data_size); 1734b411b363SPhilipp Reisner } 1735b411b363SPhilipp Reisner 1736b411b363SPhilipp Reisner /* get_ldev(mdev) successful. 1737b411b363SPhilipp Reisner * Corresponding put_ldev done either below (on various errors), 17389c50842aSAndreas Gruenbacher * or in drbd_endio_sec, if we successfully submit the data at 1739b411b363SPhilipp Reisner * the end of this function. */ 1740b411b363SPhilipp Reisner 1741b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1742b411b363SPhilipp Reisner e = read_in_block(mdev, p->block_id, sector, data_size); 1743b411b363SPhilipp Reisner if (!e) { 1744b411b363SPhilipp Reisner put_ldev(mdev); 174581e84650SAndreas Gruenbacher return false; 1746b411b363SPhilipp Reisner } 1747b411b363SPhilipp Reisner 1748b411b363SPhilipp Reisner e->w.cb = e_end_block; 1749b411b363SPhilipp Reisner 1750688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 1751688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 1752688593c5SLars Ellenberg 1753688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 1754688593c5SLars Ellenberg e->flags |= EE_MAY_SET_IN_SYNC; 1755688593c5SLars Ellenberg 1756b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1757b411b363SPhilipp Reisner e->epoch = mdev->current_epoch; 1758b411b363SPhilipp Reisner atomic_inc(&e->epoch->epoch_size); 1759b411b363SPhilipp Reisner atomic_inc(&e->epoch->active); 1760b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1761b411b363SPhilipp Reisner 1762b411b363SPhilipp Reisner /* I'm the receiver, I do hold a net_cnt reference. */ 176389e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->two_primaries) { 176487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1765b411b363SPhilipp Reisner } else { 1766b411b363SPhilipp Reisner /* don't get the req_lock yet, 1767b411b363SPhilipp Reisner * we may sleep in drbd_wait_peer_seq */ 1768010f6e67SAndreas Gruenbacher const int size = e->i.size; 1769b411b363SPhilipp Reisner const int discard = test_bit(DISCARD_CONCURRENT, &mdev->flags); 1770b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1771b411b363SPhilipp Reisner int first; 1772b411b363SPhilipp Reisner 177389e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 1774b411b363SPhilipp Reisner 1775b411b363SPhilipp Reisner /* conflict detection and handling: 1776b411b363SPhilipp Reisner * 1. wait on the sequence number, 1777b411b363SPhilipp Reisner * in case this data packet overtook ACK packets. 1778bb3bfe96SAndreas Gruenbacher * 2. check our interval trees for conflicting requests: 1779bb3bfe96SAndreas Gruenbacher * we only need to check the write_requests tree; the 1780bb3bfe96SAndreas Gruenbacher * epoch_entries tree cannot contain any overlaps because 1781bb3bfe96SAndreas Gruenbacher * they were already eliminated on the submitting node. 1782b411b363SPhilipp Reisner * 1783b411b363SPhilipp Reisner * Note: for two_primaries, we are protocol C, 1784b411b363SPhilipp Reisner * so there cannot be any request that is DONE 1785b411b363SPhilipp Reisner * but still on the transfer log. 1786b411b363SPhilipp Reisner * 1787bb3bfe96SAndreas Gruenbacher * unconditionally add to the epoch_entries tree. 1788b411b363SPhilipp Reisner * 1789b411b363SPhilipp Reisner * if no conflicting request is found: 1790b411b363SPhilipp Reisner * submit. 1791b411b363SPhilipp Reisner * 1792b411b363SPhilipp Reisner * if any conflicting request is found 1793b411b363SPhilipp Reisner * that has not yet been acked, 1794b411b363SPhilipp Reisner * AND I have the "discard concurrent writes" flag: 1795b411b363SPhilipp Reisner * queue (via done_ee) the P_DISCARD_ACK; OUT. 1796b411b363SPhilipp Reisner * 1797b411b363SPhilipp Reisner * if any conflicting request is found: 1798b411b363SPhilipp Reisner * block the receiver, waiting on misc_wait 1799b411b363SPhilipp Reisner * until no more conflicting requests are there, 1800b411b363SPhilipp Reisner * or we get interrupted (disconnect). 1801b411b363SPhilipp Reisner * 1802b411b363SPhilipp Reisner * we do not just write after local io completion of those 1803b411b363SPhilipp Reisner * requests, but only after req is done completely, i.e. 1804b411b363SPhilipp Reisner * we wait for the P_DISCARD_ACK to arrive! 1805b411b363SPhilipp Reisner * 1806b411b363SPhilipp Reisner * then proceed normally, i.e. submit. 1807b411b363SPhilipp Reisner */ 1808b411b363SPhilipp Reisner if (drbd_wait_peer_seq(mdev, be32_to_cpu(p->seq_num))) 1809b411b363SPhilipp Reisner goto out_interrupted; 1810b411b363SPhilipp Reisner 181187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1812b411b363SPhilipp Reisner 18138b946255SAndreas Gruenbacher drbd_insert_interval(&mdev->epoch_entries, &e->i); 1814b411b363SPhilipp Reisner 1815b411b363SPhilipp Reisner first = 1; 1816b411b363SPhilipp Reisner for (;;) { 1817de696716SAndreas Gruenbacher struct drbd_interval *i; 1818b411b363SPhilipp Reisner int have_unacked = 0; 1819b411b363SPhilipp Reisner int have_conflict = 0; 1820b411b363SPhilipp Reisner prepare_to_wait(&mdev->misc_wait, &wait, 1821b411b363SPhilipp Reisner TASK_INTERRUPTIBLE); 1822de696716SAndreas Gruenbacher 1823de696716SAndreas Gruenbacher i = drbd_find_overlap(&mdev->write_requests, sector, size); 1824de696716SAndreas Gruenbacher if (i) { 1825de696716SAndreas Gruenbacher struct drbd_request *req2 = 1826de696716SAndreas Gruenbacher container_of(i, struct drbd_request, i); 1827de696716SAndreas Gruenbacher 1828b411b363SPhilipp Reisner /* only ALERT on first iteration, 1829b411b363SPhilipp Reisner * we may be woken up early... */ 1830b411b363SPhilipp Reisner if (first) 1831b411b363SPhilipp Reisner dev_alert(DEV, "%s[%u] Concurrent local write detected!" 1832b411b363SPhilipp Reisner " new: %llus +%u; pending: %llus +%u\n", 1833b411b363SPhilipp Reisner current->comm, current->pid, 1834b411b363SPhilipp Reisner (unsigned long long)sector, size, 1835de696716SAndreas Gruenbacher (unsigned long long)req2->i.sector, req2->i.size); 1836de696716SAndreas Gruenbacher if (req2->rq_state & RQ_NET_PENDING) 1837b411b363SPhilipp Reisner ++have_unacked; 1838b411b363SPhilipp Reisner ++have_conflict; 1839b411b363SPhilipp Reisner } 1840b411b363SPhilipp Reisner if (!have_conflict) 1841b411b363SPhilipp Reisner break; 1842b411b363SPhilipp Reisner 1843b411b363SPhilipp Reisner /* Discard Ack only for the _first_ iteration */ 1844b411b363SPhilipp Reisner if (first && discard && have_unacked) { 1845b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [DISCARD BY FLAG] sec=%llus\n", 1846b411b363SPhilipp Reisner (unsigned long long)sector); 1847b411b363SPhilipp Reisner inc_unacked(mdev); 1848b411b363SPhilipp Reisner e->w.cb = e_send_discard_ack; 1849b411b363SPhilipp Reisner list_add_tail(&e->w.list, &mdev->done_ee); 1850b411b363SPhilipp Reisner 185187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1852b411b363SPhilipp Reisner 1853b411b363SPhilipp Reisner /* we could probably send that P_DISCARD_ACK ourselves, 1854b411b363SPhilipp Reisner * but I don't like the receiver using the msock */ 1855b411b363SPhilipp Reisner 1856b411b363SPhilipp Reisner put_ldev(mdev); 1857b411b363SPhilipp Reisner wake_asender(mdev); 1858b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 185981e84650SAndreas Gruenbacher return true; 1860b411b363SPhilipp Reisner } 1861b411b363SPhilipp Reisner 1862b411b363SPhilipp Reisner if (signal_pending(current)) { 18638b946255SAndreas Gruenbacher drbd_remove_interval(&mdev->epoch_entries, &e->i); 18648b946255SAndreas Gruenbacher drbd_clear_interval(&e->i); 1865b411b363SPhilipp Reisner 186687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1867b411b363SPhilipp Reisner 1868b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1869b411b363SPhilipp Reisner goto out_interrupted; 1870b411b363SPhilipp Reisner } 1871b411b363SPhilipp Reisner 187287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1873b411b363SPhilipp Reisner if (first) { 1874b411b363SPhilipp Reisner first = 0; 1875b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [W AFTERWARDS] " 1876b411b363SPhilipp Reisner "sec=%llus\n", (unsigned long long)sector); 1877b411b363SPhilipp Reisner } else if (discard) { 1878b411b363SPhilipp Reisner /* we had none on the first iteration. 1879b411b363SPhilipp Reisner * there must be none now. */ 1880b411b363SPhilipp Reisner D_ASSERT(have_unacked == 0); 1881b411b363SPhilipp Reisner } 1882b411b363SPhilipp Reisner schedule(); 188387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1884b411b363SPhilipp Reisner } 1885b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1886b411b363SPhilipp Reisner } 1887b411b363SPhilipp Reisner 1888b411b363SPhilipp Reisner list_add(&e->w.list, &mdev->active_ee); 188987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1890b411b363SPhilipp Reisner 189189e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->wire_protocol) { 1892b411b363SPhilipp Reisner case DRBD_PROT_C: 1893b411b363SPhilipp Reisner inc_unacked(mdev); 1894b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 1895b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1896b411b363SPhilipp Reisner break; 1897b411b363SPhilipp Reisner case DRBD_PROT_B: 1898b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 1899b411b363SPhilipp Reisner * sends on the msock, but anyways */ 1900b411b363SPhilipp Reisner drbd_send_ack(mdev, P_RECV_ACK, e); 1901b411b363SPhilipp Reisner break; 1902b411b363SPhilipp Reisner case DRBD_PROT_A: 1903b411b363SPhilipp Reisner /* nothing to do */ 1904b411b363SPhilipp Reisner break; 1905b411b363SPhilipp Reisner } 1906b411b363SPhilipp Reisner 19076719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 1908b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 1909010f6e67SAndreas Gruenbacher drbd_set_out_of_sync(mdev, e->i.sector, e->i.size); 1910b411b363SPhilipp Reisner e->flags |= EE_CALL_AL_COMPLETE_IO; 19116719fb03SLars Ellenberg e->flags &= ~EE_MAY_SET_IN_SYNC; 1912010f6e67SAndreas Gruenbacher drbd_al_begin_io(mdev, e->i.sector); 1913b411b363SPhilipp Reisner } 1914b411b363SPhilipp Reisner 191545bb912bSLars Ellenberg if (drbd_submit_ee(mdev, e, rw, DRBD_FAULT_DT_WR) == 0) 191681e84650SAndreas Gruenbacher return true; 1917b411b363SPhilipp Reisner 191810f6d992SLars Ellenberg /* don't care for the reason here */ 191910f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 192087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 192122cc37a9SLars Ellenberg list_del(&e->w.list); 19228b946255SAndreas Gruenbacher drbd_remove_interval(&mdev->epoch_entries, &e->i); 19238b946255SAndreas Gruenbacher drbd_clear_interval(&e->i); 192487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 192522cc37a9SLars Ellenberg if (e->flags & EE_CALL_AL_COMPLETE_IO) 1926010f6e67SAndreas Gruenbacher drbd_al_complete_io(mdev, e->i.sector); 192722cc37a9SLars Ellenberg 1928b411b363SPhilipp Reisner out_interrupted: 192910f6d992SLars Ellenberg drbd_may_finish_epoch(mdev, e->epoch, EV_PUT + EV_CLEANUP); 1930b411b363SPhilipp Reisner put_ldev(mdev); 1931b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 193281e84650SAndreas Gruenbacher return false; 1933b411b363SPhilipp Reisner } 1934b411b363SPhilipp Reisner 19350f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 19360f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 19370f0601f4SLars Ellenberg * 19380f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 19390f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 19400f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 19410f0601f4SLars Ellenberg * activity, it obviously is "busy". 19420f0601f4SLars Ellenberg * 19430f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 19440f0601f4SLars Ellenberg * to have a short time average so we can react faster. 19450f0601f4SLars Ellenberg */ 1946e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 19470f0601f4SLars Ellenberg { 19480f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 19490f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 1950e3555d85SPhilipp Reisner struct lc_element *tmp; 19510f0601f4SLars Ellenberg int curr_events; 19520f0601f4SLars Ellenberg int throttle = 0; 19530f0601f4SLars Ellenberg 19540f0601f4SLars Ellenberg /* feature disabled? */ 19550f0601f4SLars Ellenberg if (mdev->sync_conf.c_min_rate == 0) 19560f0601f4SLars Ellenberg return 0; 19570f0601f4SLars Ellenberg 1958e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 1959e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 1960e3555d85SPhilipp Reisner if (tmp) { 1961e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 1962e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 1963e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 1964e3555d85SPhilipp Reisner return 0; 1965e3555d85SPhilipp Reisner } 1966e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 1967e3555d85SPhilipp Reisner } 1968e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 1969e3555d85SPhilipp Reisner 19700f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 19710f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 19720f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 1973e3555d85SPhilipp Reisner 19740f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 19750f0601f4SLars Ellenberg unsigned long rs_left; 19760f0601f4SLars Ellenberg int i; 19770f0601f4SLars Ellenberg 19780f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 19790f0601f4SLars Ellenberg 19800f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 19810f0601f4SLars Ellenberg * approx. */ 19822649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 19832649f080SLars Ellenberg 19842649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 19852649f080SLars Ellenberg rs_left = mdev->ov_left; 19862649f080SLars Ellenberg else 19870f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 19880f0601f4SLars Ellenberg 19890f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 19900f0601f4SLars Ellenberg if (!dt) 19910f0601f4SLars Ellenberg dt++; 19920f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 19930f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 19940f0601f4SLars Ellenberg 19950f0601f4SLars Ellenberg if (dbdt > mdev->sync_conf.c_min_rate) 19960f0601f4SLars Ellenberg throttle = 1; 19970f0601f4SLars Ellenberg } 19980f0601f4SLars Ellenberg return throttle; 19990f0601f4SLars Ellenberg } 20000f0601f4SLars Ellenberg 20010f0601f4SLars Ellenberg 2002d8763023SAndreas Gruenbacher static int receive_DataRequest(struct drbd_conf *mdev, enum drbd_packet cmd, 2003d8763023SAndreas Gruenbacher unsigned int digest_size) 2004b411b363SPhilipp Reisner { 2005b411b363SPhilipp Reisner sector_t sector; 2006b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 2007b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 2008b411b363SPhilipp Reisner struct digest_info *di = NULL; 2009b18b37beSPhilipp Reisner int size, verb; 2010b411b363SPhilipp Reisner unsigned int fault_type; 2011e42325a5SPhilipp Reisner struct p_block_req *p = &mdev->tconn->data.rbuf.block_req; 2012b411b363SPhilipp Reisner 2013b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2014b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2015b411b363SPhilipp Reisner 20161816a2b4SLars Ellenberg if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_BIO_SIZE) { 2017b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2018b411b363SPhilipp Reisner (unsigned long long)sector, size); 201981e84650SAndreas Gruenbacher return false; 2020b411b363SPhilipp Reisner } 2021b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2022b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2023b411b363SPhilipp Reisner (unsigned long long)sector, size); 202481e84650SAndreas Gruenbacher return false; 2025b411b363SPhilipp Reisner } 2026b411b363SPhilipp Reisner 2027b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2028b18b37beSPhilipp Reisner verb = 1; 2029b18b37beSPhilipp Reisner switch (cmd) { 2030b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2031b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2032b18b37beSPhilipp Reisner break; 2033b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2034b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2035b18b37beSPhilipp Reisner case P_OV_REQUEST: 2036b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2037b18b37beSPhilipp Reisner break; 2038b18b37beSPhilipp Reisner case P_OV_REPLY: 2039b18b37beSPhilipp Reisner verb = 0; 2040b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2041b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2042b18b37beSPhilipp Reisner break; 2043b18b37beSPhilipp Reisner default: 2044b18b37beSPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 2045b18b37beSPhilipp Reisner cmdname(cmd)); 2046b18b37beSPhilipp Reisner } 2047b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2048b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2049b411b363SPhilipp Reisner "no local data.\n"); 2050b18b37beSPhilipp Reisner 2051a821cc4aSLars Ellenberg /* drain possibly payload */ 2052a821cc4aSLars Ellenberg return drbd_drain_block(mdev, digest_size); 2053b411b363SPhilipp Reisner } 2054b411b363SPhilipp Reisner 2055b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2056b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2057b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2058b411b363SPhilipp Reisner e = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO); 2059b411b363SPhilipp Reisner if (!e) { 2060b411b363SPhilipp Reisner put_ldev(mdev); 206181e84650SAndreas Gruenbacher return false; 2062b411b363SPhilipp Reisner } 2063b411b363SPhilipp Reisner 206402918be2SPhilipp Reisner switch (cmd) { 2065b411b363SPhilipp Reisner case P_DATA_REQUEST: 2066b411b363SPhilipp Reisner e->w.cb = w_e_end_data_req; 2067b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 206880a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 206980a40e43SLars Ellenberg goto submit; 207080a40e43SLars Ellenberg 2071b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2072b411b363SPhilipp Reisner e->w.cb = w_e_end_rsdata_req; 2073b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 20745f9915bbSLars Ellenberg /* used in the sector offset progress display */ 20755f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2076b411b363SPhilipp Reisner break; 2077b411b363SPhilipp Reisner 2078b411b363SPhilipp Reisner case P_OV_REPLY: 2079b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2080b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2081b411b363SPhilipp Reisner di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO); 2082b411b363SPhilipp Reisner if (!di) 2083b411b363SPhilipp Reisner goto out_free_e; 2084b411b363SPhilipp Reisner 2085b411b363SPhilipp Reisner di->digest_size = digest_size; 2086b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2087b411b363SPhilipp Reisner 2088c36c3cedSLars Ellenberg e->digest = di; 2089c36c3cedSLars Ellenberg e->flags |= EE_HAS_DIGEST; 2090c36c3cedSLars Ellenberg 2091b411b363SPhilipp Reisner if (drbd_recv(mdev, di->digest, digest_size) != digest_size) 2092b411b363SPhilipp Reisner goto out_free_e; 2093b411b363SPhilipp Reisner 209402918be2SPhilipp Reisner if (cmd == P_CSUM_RS_REQUEST) { 209531890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2096b411b363SPhilipp Reisner e->w.cb = w_e_end_csum_rs_req; 20975f9915bbSLars Ellenberg /* used in the sector offset progress display */ 20985f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 209902918be2SPhilipp Reisner } else if (cmd == P_OV_REPLY) { 21002649f080SLars Ellenberg /* track progress, we may need to throttle */ 21012649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2102b411b363SPhilipp Reisner e->w.cb = w_e_end_ov_reply; 2103b411b363SPhilipp Reisner dec_rs_pending(mdev); 21040f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 21050f0601f4SLars Ellenberg * but accounting still needs to be done. */ 21060f0601f4SLars Ellenberg goto submit_for_resync; 2107b411b363SPhilipp Reisner } 2108b411b363SPhilipp Reisner break; 2109b411b363SPhilipp Reisner 2110b411b363SPhilipp Reisner case P_OV_REQUEST: 2111b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 211231890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2113de228bbaSLars Ellenberg unsigned long now = jiffies; 2114de228bbaSLars Ellenberg int i; 2115b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2116b411b363SPhilipp Reisner mdev->ov_position = sector; 211730b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 211830b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2119de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2120de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2121de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2122de228bbaSLars Ellenberg } 2123b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2124b411b363SPhilipp Reisner (unsigned long long)sector); 2125b411b363SPhilipp Reisner } 2126b411b363SPhilipp Reisner e->w.cb = w_e_end_ov_req; 2127b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2128b411b363SPhilipp Reisner break; 2129b411b363SPhilipp Reisner 2130b411b363SPhilipp Reisner default: 2131b411b363SPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 213202918be2SPhilipp Reisner cmdname(cmd)); 2133b411b363SPhilipp Reisner fault_type = DRBD_FAULT_MAX; 213480a40e43SLars Ellenberg goto out_free_e; 2135b411b363SPhilipp Reisner } 2136b411b363SPhilipp Reisner 21370f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 21380f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 21390f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 21400f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 21410f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 21420f0601f4SLars Ellenberg * 21430f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 21440f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 21450f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 21460f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 21470f0601f4SLars Ellenberg * a while, anyways. 21480f0601f4SLars Ellenberg */ 2149b411b363SPhilipp Reisner 21500f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 21510f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 21520f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 21530f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 21540f0601f4SLars Ellenberg * 21550f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 21560f0601f4SLars Ellenberg * we would also throttle its application reads. 21570f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 21580f0601f4SLars Ellenberg */ 2159e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2160e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2161e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 216280a40e43SLars Ellenberg goto out_free_e; 2163b411b363SPhilipp Reisner 21640f0601f4SLars Ellenberg submit_for_resync: 21650f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 21660f0601f4SLars Ellenberg 216780a40e43SLars Ellenberg submit: 2168b411b363SPhilipp Reisner inc_unacked(mdev); 216987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 217080a40e43SLars Ellenberg list_add_tail(&e->w.list, &mdev->read_ee); 217187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2172b411b363SPhilipp Reisner 217345bb912bSLars Ellenberg if (drbd_submit_ee(mdev, e, READ, fault_type) == 0) 217481e84650SAndreas Gruenbacher return true; 2175b411b363SPhilipp Reisner 217610f6d992SLars Ellenberg /* don't care for the reason here */ 217710f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 217887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 217922cc37a9SLars Ellenberg list_del(&e->w.list); 218087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 218122cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 218222cc37a9SLars Ellenberg 2183b411b363SPhilipp Reisner out_free_e: 2184b411b363SPhilipp Reisner put_ldev(mdev); 2185b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 218681e84650SAndreas Gruenbacher return false; 2187b411b363SPhilipp Reisner } 2188b411b363SPhilipp Reisner 2189b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2190b411b363SPhilipp Reisner { 2191b411b363SPhilipp Reisner int self, peer, rv = -100; 2192b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2193b411b363SPhilipp Reisner 2194b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2195b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2196b411b363SPhilipp Reisner 2197b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2198b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2199b411b363SPhilipp Reisner 220089e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_0p) { 2201b411b363SPhilipp Reisner case ASB_CONSENSUS: 2202b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2203b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2204b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2205b411b363SPhilipp Reisner break; 2206b411b363SPhilipp Reisner case ASB_DISCONNECT: 2207b411b363SPhilipp Reisner break; 2208b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2209b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2210b411b363SPhilipp Reisner rv = -1; 2211b411b363SPhilipp Reisner break; 2212b411b363SPhilipp Reisner } 2213b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2214b411b363SPhilipp Reisner rv = 1; 2215b411b363SPhilipp Reisner break; 2216b411b363SPhilipp Reisner } 2217b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2218b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_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... */ 2228ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2229b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2230b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2231b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 2232b411b363SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->flags) 2233b411b363SPhilipp Reisner ? -1 : 1; 2234b411b363SPhilipp Reisner break; 2235b411b363SPhilipp Reisner } else { 2236b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2237b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2238b411b363SPhilipp Reisner } 223989e58e75SPhilipp Reisner if (mdev->tconn->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2240b411b363SPhilipp Reisner break; 2241b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2242b411b363SPhilipp Reisner if (ch_self < ch_peer) 2243b411b363SPhilipp Reisner rv = -1; 2244b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2245b411b363SPhilipp Reisner rv = 1; 2246b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2247b411b363SPhilipp Reisner /* Well, then use something else. */ 2248b411b363SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->flags) 2249b411b363SPhilipp Reisner ? -1 : 1; 2250b411b363SPhilipp Reisner break; 2251b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2252b411b363SPhilipp Reisner rv = -1; 2253b411b363SPhilipp Reisner break; 2254b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2255b411b363SPhilipp Reisner rv = 1; 2256b411b363SPhilipp Reisner } 2257b411b363SPhilipp Reisner 2258b411b363SPhilipp Reisner return rv; 2259b411b363SPhilipp Reisner } 2260b411b363SPhilipp Reisner 2261b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2262b411b363SPhilipp Reisner { 22636184ea21SAndreas Gruenbacher int hg, rv = -100; 2264b411b363SPhilipp Reisner 226589e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_1p) { 2266b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2267b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2268b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2269b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2270b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2271b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2272b411b363SPhilipp Reisner break; 2273b411b363SPhilipp Reisner case ASB_DISCONNECT: 2274b411b363SPhilipp Reisner break; 2275b411b363SPhilipp Reisner case ASB_CONSENSUS: 2276b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2277b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2278b411b363SPhilipp Reisner rv = hg; 2279b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2280b411b363SPhilipp Reisner rv = hg; 2281b411b363SPhilipp Reisner break; 2282b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2283b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2284b411b363SPhilipp Reisner break; 2285b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2286b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2287b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2288b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2289b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2290bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2291bb437946SAndreas Gruenbacher 2292bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2293b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2294b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2295b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2296bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2297bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2298b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2299b411b363SPhilipp Reisner } else { 2300b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2301b411b363SPhilipp Reisner rv = hg; 2302b411b363SPhilipp Reisner } 2303b411b363SPhilipp Reisner } else 2304b411b363SPhilipp Reisner rv = hg; 2305b411b363SPhilipp Reisner } 2306b411b363SPhilipp Reisner 2307b411b363SPhilipp Reisner return rv; 2308b411b363SPhilipp Reisner } 2309b411b363SPhilipp Reisner 2310b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2311b411b363SPhilipp Reisner { 23126184ea21SAndreas Gruenbacher int hg, rv = -100; 2313b411b363SPhilipp Reisner 231489e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_2p) { 2315b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2316b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2317b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2318b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2319b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2320b411b363SPhilipp Reisner case ASB_CONSENSUS: 2321b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2322b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2323b411b363SPhilipp Reisner break; 2324b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2325b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2326b411b363SPhilipp Reisner break; 2327b411b363SPhilipp Reisner case ASB_DISCONNECT: 2328b411b363SPhilipp Reisner break; 2329b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2330b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2331b411b363SPhilipp Reisner if (hg == -1) { 2332bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2333bb437946SAndreas Gruenbacher 2334b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2335b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2336b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2337bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2338bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2339b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2340b411b363SPhilipp Reisner } else { 2341b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2342b411b363SPhilipp Reisner rv = hg; 2343b411b363SPhilipp Reisner } 2344b411b363SPhilipp Reisner } else 2345b411b363SPhilipp Reisner rv = hg; 2346b411b363SPhilipp Reisner } 2347b411b363SPhilipp Reisner 2348b411b363SPhilipp Reisner return rv; 2349b411b363SPhilipp Reisner } 2350b411b363SPhilipp Reisner 2351b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2352b411b363SPhilipp Reisner u64 bits, u64 flags) 2353b411b363SPhilipp Reisner { 2354b411b363SPhilipp Reisner if (!uuid) { 2355b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2356b411b363SPhilipp Reisner return; 2357b411b363SPhilipp Reisner } 2358b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2359b411b363SPhilipp Reisner text, 2360b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2361b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2362b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2363b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2364b411b363SPhilipp Reisner (unsigned long long)bits, 2365b411b363SPhilipp Reisner (unsigned long long)flags); 2366b411b363SPhilipp Reisner } 2367b411b363SPhilipp Reisner 2368b411b363SPhilipp Reisner /* 2369b411b363SPhilipp Reisner 100 after split brain try auto recover 2370b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2371b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2372b411b363SPhilipp Reisner 0 no Sync 2373b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2374b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2375b411b363SPhilipp Reisner -100 after split brain, disconnect 2376b411b363SPhilipp Reisner -1000 unrelated data 23774a23f264SPhilipp Reisner -1091 requires proto 91 23784a23f264SPhilipp Reisner -1096 requires proto 96 2379b411b363SPhilipp Reisner */ 2380b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2381b411b363SPhilipp Reisner { 2382b411b363SPhilipp Reisner u64 self, peer; 2383b411b363SPhilipp Reisner int i, j; 2384b411b363SPhilipp Reisner 2385b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2386b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2387b411b363SPhilipp Reisner 2388b411b363SPhilipp Reisner *rule_nr = 10; 2389b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2390b411b363SPhilipp Reisner return 0; 2391b411b363SPhilipp Reisner 2392b411b363SPhilipp Reisner *rule_nr = 20; 2393b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2394b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2395b411b363SPhilipp Reisner return -2; 2396b411b363SPhilipp Reisner 2397b411b363SPhilipp Reisner *rule_nr = 30; 2398b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2399b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2400b411b363SPhilipp Reisner return 2; 2401b411b363SPhilipp Reisner 2402b411b363SPhilipp Reisner if (self == peer) { 2403b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2404b411b363SPhilipp Reisner 2405b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2406b411b363SPhilipp Reisner 240731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 24084a23f264SPhilipp Reisner return -1091; 2409b411b363SPhilipp Reisner 2410b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2411b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2412b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2413b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2414b411b363SPhilipp Reisner 2415b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2416b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2417b411b363SPhilipp Reisner *rule_nr = 34; 2418b411b363SPhilipp Reisner } else { 2419b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2420b411b363SPhilipp Reisner *rule_nr = 36; 2421b411b363SPhilipp Reisner } 2422b411b363SPhilipp Reisner 2423b411b363SPhilipp Reisner return 1; 2424b411b363SPhilipp Reisner } 2425b411b363SPhilipp Reisner 2426b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2427b411b363SPhilipp Reisner 242831890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 24294a23f264SPhilipp Reisner return -1091; 2430b411b363SPhilipp Reisner 2431b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2432b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2433b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2434b411b363SPhilipp Reisner 2435b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2436b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2437b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2438b411b363SPhilipp Reisner 2439b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2440b411b363SPhilipp Reisner *rule_nr = 35; 2441b411b363SPhilipp Reisner } else { 2442b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2443b411b363SPhilipp Reisner *rule_nr = 37; 2444b411b363SPhilipp Reisner } 2445b411b363SPhilipp Reisner 2446b411b363SPhilipp Reisner return -1; 2447b411b363SPhilipp Reisner } 2448b411b363SPhilipp Reisner 2449b411b363SPhilipp Reisner /* Common power [off|failure] */ 2450b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2451b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2452b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2453b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2454b411b363SPhilipp Reisner *rule_nr = 40; 2455b411b363SPhilipp Reisner 2456b411b363SPhilipp Reisner switch (rct) { 2457b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2458b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2459b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2460b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 2461b411b363SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->flags); 2462b411b363SPhilipp Reisner return dc ? -1 : 1; 2463b411b363SPhilipp Reisner } 2464b411b363SPhilipp Reisner } 2465b411b363SPhilipp Reisner 2466b411b363SPhilipp Reisner *rule_nr = 50; 2467b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2468b411b363SPhilipp Reisner if (self == peer) 2469b411b363SPhilipp Reisner return -1; 2470b411b363SPhilipp Reisner 2471b411b363SPhilipp Reisner *rule_nr = 51; 2472b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2473b411b363SPhilipp Reisner if (self == peer) { 247431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 24754a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 24764a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 24774a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2478b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2479b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2480b411b363SPhilipp Reisner 248131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 24824a23f264SPhilipp Reisner return -1091; 2483b411b363SPhilipp Reisner 2484b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2485b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 24864a23f264SPhilipp Reisner 24874a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 24884a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 24894a23f264SPhilipp Reisner 2490b411b363SPhilipp Reisner return -1; 2491b411b363SPhilipp Reisner } 2492b411b363SPhilipp Reisner } 2493b411b363SPhilipp Reisner 2494b411b363SPhilipp Reisner *rule_nr = 60; 2495b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2496b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2497b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2498b411b363SPhilipp Reisner if (self == peer) 2499b411b363SPhilipp Reisner return -2; 2500b411b363SPhilipp Reisner } 2501b411b363SPhilipp Reisner 2502b411b363SPhilipp Reisner *rule_nr = 70; 2503b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2504b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2505b411b363SPhilipp Reisner if (self == peer) 2506b411b363SPhilipp Reisner return 1; 2507b411b363SPhilipp Reisner 2508b411b363SPhilipp Reisner *rule_nr = 71; 2509b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2510b411b363SPhilipp Reisner if (self == peer) { 251131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 25124a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 25134a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 25144a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2515b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2516b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2517b411b363SPhilipp Reisner 251831890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25194a23f264SPhilipp Reisner return -1091; 2520b411b363SPhilipp Reisner 2521b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2522b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2523b411b363SPhilipp Reisner 25244a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2525b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2526b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2527b411b363SPhilipp Reisner 2528b411b363SPhilipp Reisner return 1; 2529b411b363SPhilipp Reisner } 2530b411b363SPhilipp Reisner } 2531b411b363SPhilipp Reisner 2532b411b363SPhilipp Reisner 2533b411b363SPhilipp Reisner *rule_nr = 80; 2534d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2535b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2536b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2537b411b363SPhilipp Reisner if (self == peer) 2538b411b363SPhilipp Reisner return 2; 2539b411b363SPhilipp Reisner } 2540b411b363SPhilipp Reisner 2541b411b363SPhilipp Reisner *rule_nr = 90; 2542b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2543b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2544b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2545b411b363SPhilipp Reisner return 100; 2546b411b363SPhilipp Reisner 2547b411b363SPhilipp Reisner *rule_nr = 100; 2548b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2549b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2550b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2551b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2552b411b363SPhilipp Reisner if (self == peer) 2553b411b363SPhilipp Reisner return -100; 2554b411b363SPhilipp Reisner } 2555b411b363SPhilipp Reisner } 2556b411b363SPhilipp Reisner 2557b411b363SPhilipp Reisner return -1000; 2558b411b363SPhilipp Reisner } 2559b411b363SPhilipp Reisner 2560b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2561b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2562b411b363SPhilipp Reisner */ 2563b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2564b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2565b411b363SPhilipp Reisner { 2566b411b363SPhilipp Reisner int hg, rule_nr; 2567b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2568b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2569b411b363SPhilipp Reisner 2570b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2571b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2572b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2573b411b363SPhilipp Reisner 2574b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2575b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2576b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2577b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2578b411b363SPhilipp Reisner 2579b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2580b411b363SPhilipp Reisner 2581b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2582b411b363SPhilipp Reisner 2583b411b363SPhilipp Reisner if (hg == -1000) { 2584b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2585b411b363SPhilipp Reisner return C_MASK; 2586b411b363SPhilipp Reisner } 25874a23f264SPhilipp Reisner if (hg < -1000) { 25884a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2589b411b363SPhilipp Reisner return C_MASK; 2590b411b363SPhilipp Reisner } 2591b411b363SPhilipp Reisner 2592b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2593b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2594b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2595b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2596b411b363SPhilipp Reisner if (f) 2597b411b363SPhilipp Reisner hg = hg*2; 2598b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2599b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2600b411b363SPhilipp Reisner } 2601b411b363SPhilipp Reisner 26023a11a487SAdam Gandelman if (abs(hg) == 100) 26033a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 26043a11a487SAdam Gandelman 260589e58e75SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->tconn->net_conf->always_asbp)) { 2606b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2607b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2608b411b363SPhilipp Reisner int forced = (hg == -100); 2609b411b363SPhilipp Reisner 2610b411b363SPhilipp Reisner switch (pcount) { 2611b411b363SPhilipp Reisner case 0: 2612b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2613b411b363SPhilipp Reisner break; 2614b411b363SPhilipp Reisner case 1: 2615b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2616b411b363SPhilipp Reisner break; 2617b411b363SPhilipp Reisner case 2: 2618b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2619b411b363SPhilipp Reisner break; 2620b411b363SPhilipp Reisner } 2621b411b363SPhilipp Reisner if (abs(hg) < 100) { 2622b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2623b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2624b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2625b411b363SPhilipp Reisner if (forced) { 2626b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2627b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2628b411b363SPhilipp Reisner hg = hg*2; 2629b411b363SPhilipp Reisner } 2630b411b363SPhilipp Reisner } 2631b411b363SPhilipp Reisner } 2632b411b363SPhilipp Reisner 2633b411b363SPhilipp Reisner if (hg == -100) { 263489e58e75SPhilipp Reisner if (mdev->tconn->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2635b411b363SPhilipp Reisner hg = -1; 263689e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2637b411b363SPhilipp Reisner hg = 1; 2638b411b363SPhilipp Reisner 2639b411b363SPhilipp Reisner if (abs(hg) < 100) 2640b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2641b411b363SPhilipp Reisner "Sync from %s node\n", 2642b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2643b411b363SPhilipp Reisner } 2644b411b363SPhilipp Reisner 2645b411b363SPhilipp Reisner if (hg == -100) { 2646580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2647580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2648580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2649580b9767SLars Ellenberg * to that disk, in a way... */ 26503a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2651b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2652b411b363SPhilipp Reisner return C_MASK; 2653b411b363SPhilipp Reisner } 2654b411b363SPhilipp Reisner 2655b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2656b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2657b411b363SPhilipp Reisner return C_MASK; 2658b411b363SPhilipp Reisner } 2659b411b363SPhilipp Reisner 2660b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2661b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 266289e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->rr_conflict) { 2663b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2664b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2665b411b363SPhilipp Reisner /* fall through */ 2666b411b363SPhilipp Reisner case ASB_DISCONNECT: 2667b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2668b411b363SPhilipp Reisner return C_MASK; 2669b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2670b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2671b411b363SPhilipp Reisner "assumption\n"); 2672b411b363SPhilipp Reisner } 2673b411b363SPhilipp Reisner } 2674b411b363SPhilipp Reisner 267589e58e75SPhilipp Reisner if (mdev->tconn->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->flags)) { 2676cf14c2e9SPhilipp Reisner if (hg == 0) 2677cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2678cf14c2e9SPhilipp Reisner else 2679cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2680cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2681cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2682cf14c2e9SPhilipp Reisner return C_MASK; 2683cf14c2e9SPhilipp Reisner } 2684cf14c2e9SPhilipp Reisner 2685b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2686b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 268720ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 268820ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2689b411b363SPhilipp Reisner return C_MASK; 2690b411b363SPhilipp Reisner } 2691b411b363SPhilipp Reisner 2692b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2693b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2694b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2695b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2696b411b363SPhilipp Reisner } else { 2697b411b363SPhilipp Reisner rv = C_CONNECTED; 2698b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2699b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2700b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2701b411b363SPhilipp Reisner } 2702b411b363SPhilipp Reisner } 2703b411b363SPhilipp Reisner 2704b411b363SPhilipp Reisner return rv; 2705b411b363SPhilipp Reisner } 2706b411b363SPhilipp Reisner 2707b411b363SPhilipp Reisner /* returns 1 if invalid */ 2708b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2709b411b363SPhilipp Reisner { 2710b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2711b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2712b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2713b411b363SPhilipp Reisner return 0; 2714b411b363SPhilipp Reisner 2715b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2716b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2717b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2718b411b363SPhilipp Reisner return 1; 2719b411b363SPhilipp Reisner 2720b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2721b411b363SPhilipp Reisner if (peer == self) 2722b411b363SPhilipp Reisner return 0; 2723b411b363SPhilipp Reisner 2724b411b363SPhilipp Reisner /* everything es is invalid. */ 2725b411b363SPhilipp Reisner return 1; 2726b411b363SPhilipp Reisner } 2727b411b363SPhilipp Reisner 2728d8763023SAndreas Gruenbacher static int receive_protocol(struct drbd_conf *mdev, enum drbd_packet cmd, 2729d8763023SAndreas Gruenbacher unsigned int data_size) 2730b411b363SPhilipp Reisner { 2731e42325a5SPhilipp Reisner struct p_protocol *p = &mdev->tconn->data.rbuf.protocol; 2732b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2733cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2734b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2735b411b363SPhilipp Reisner 2736b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2737b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2738b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2739b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2740b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2741cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2742cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2743cf14c2e9SPhilipp Reisner 2744cf14c2e9SPhilipp Reisner clear_bit(CONN_DRY_RUN, &mdev->flags); 2745cf14c2e9SPhilipp Reisner 2746cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 2747cf14c2e9SPhilipp Reisner set_bit(CONN_DRY_RUN, &mdev->flags); 2748b411b363SPhilipp Reisner 274989e58e75SPhilipp Reisner if (p_proto != mdev->tconn->net_conf->wire_protocol) { 2750b411b363SPhilipp Reisner dev_err(DEV, "incompatible communication protocols\n"); 2751b411b363SPhilipp Reisner goto disconnect; 2752b411b363SPhilipp Reisner } 2753b411b363SPhilipp Reisner 275489e58e75SPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, mdev->tconn->net_conf->after_sb_0p)) { 2755b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-0pri settings\n"); 2756b411b363SPhilipp Reisner goto disconnect; 2757b411b363SPhilipp Reisner } 2758b411b363SPhilipp Reisner 275989e58e75SPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, mdev->tconn->net_conf->after_sb_1p)) { 2760b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-1pri settings\n"); 2761b411b363SPhilipp Reisner goto disconnect; 2762b411b363SPhilipp Reisner } 2763b411b363SPhilipp Reisner 276489e58e75SPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, mdev->tconn->net_conf->after_sb_2p)) { 2765b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-2pri settings\n"); 2766b411b363SPhilipp Reisner goto disconnect; 2767b411b363SPhilipp Reisner } 2768b411b363SPhilipp Reisner 276989e58e75SPhilipp Reisner if (p_want_lose && mdev->tconn->net_conf->want_lose) { 2770b411b363SPhilipp Reisner dev_err(DEV, "both sides have the 'want_lose' flag set\n"); 2771b411b363SPhilipp Reisner goto disconnect; 2772b411b363SPhilipp Reisner } 2773b411b363SPhilipp Reisner 277489e58e75SPhilipp Reisner if (p_two_primaries != mdev->tconn->net_conf->two_primaries) { 2775b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the two-primaries options\n"); 2776b411b363SPhilipp Reisner goto disconnect; 2777b411b363SPhilipp Reisner } 2778b411b363SPhilipp Reisner 277931890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version >= 87) { 278089e58e75SPhilipp Reisner unsigned char *my_alg = mdev->tconn->net_conf->integrity_alg; 2781b411b363SPhilipp Reisner 2782b411b363SPhilipp Reisner if (drbd_recv(mdev, p_integrity_alg, data_size) != data_size) 278381e84650SAndreas Gruenbacher return false; 2784b411b363SPhilipp Reisner 2785b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2786b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 2787b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the data-integrity-alg\n"); 2788b411b363SPhilipp Reisner goto disconnect; 2789b411b363SPhilipp Reisner } 2790b411b363SPhilipp Reisner dev_info(DEV, "data-integrity-alg: %s\n", 2791b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2792b411b363SPhilipp Reisner } 2793b411b363SPhilipp Reisner 279481e84650SAndreas Gruenbacher return true; 2795b411b363SPhilipp Reisner 2796b411b363SPhilipp Reisner disconnect: 2797b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 279881e84650SAndreas Gruenbacher return false; 2799b411b363SPhilipp Reisner } 2800b411b363SPhilipp Reisner 2801b411b363SPhilipp Reisner /* helper function 2802b411b363SPhilipp Reisner * input: alg name, feature name 2803b411b363SPhilipp Reisner * return: NULL (alg name was "") 2804b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2805b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2806b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2807b411b363SPhilipp Reisner const char *alg, const char *name) 2808b411b363SPhilipp Reisner { 2809b411b363SPhilipp Reisner struct crypto_hash *tfm; 2810b411b363SPhilipp Reisner 2811b411b363SPhilipp Reisner if (!alg[0]) 2812b411b363SPhilipp Reisner return NULL; 2813b411b363SPhilipp Reisner 2814b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2815b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 2816b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 2817b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 2818b411b363SPhilipp Reisner return tfm; 2819b411b363SPhilipp Reisner } 2820b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 2821b411b363SPhilipp Reisner crypto_free_hash(tfm); 2822b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 2823b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 2824b411b363SPhilipp Reisner } 2825b411b363SPhilipp Reisner return tfm; 2826b411b363SPhilipp Reisner } 2827b411b363SPhilipp Reisner 2828d8763023SAndreas Gruenbacher static int receive_SyncParam(struct drbd_conf *mdev, enum drbd_packet cmd, 2829d8763023SAndreas Gruenbacher unsigned int packet_size) 2830b411b363SPhilipp Reisner { 283181e84650SAndreas Gruenbacher int ok = true; 2832e42325a5SPhilipp Reisner struct p_rs_param_95 *p = &mdev->tconn->data.rbuf.rs_param_95; 2833b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 2834b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 2835b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 283631890f4aSPhilipp Reisner const int apv = mdev->tconn->agreed_pro_version; 2837778f271dSPhilipp Reisner int *rs_plan_s = NULL; 2838778f271dSPhilipp Reisner int fifo_size = 0; 2839b411b363SPhilipp Reisner 2840b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 2841b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 2842b411b363SPhilipp Reisner + SHARED_SECRET_MAX 28438e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 28448e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 2845b411b363SPhilipp Reisner 284602918be2SPhilipp Reisner if (packet_size > exp_max_sz) { 2847b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 284802918be2SPhilipp Reisner packet_size, exp_max_sz); 284981e84650SAndreas Gruenbacher return false; 2850b411b363SPhilipp Reisner } 2851b411b363SPhilipp Reisner 2852b411b363SPhilipp Reisner if (apv <= 88) { 2853257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param) - sizeof(struct p_header); 285402918be2SPhilipp Reisner data_size = packet_size - header_size; 28558e26f9ccSPhilipp Reisner } else if (apv <= 94) { 2856257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header); 285702918be2SPhilipp Reisner data_size = packet_size - header_size; 2858b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 28598e26f9ccSPhilipp Reisner } else { 2860257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header); 286102918be2SPhilipp Reisner data_size = packet_size - header_size; 2862b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 2863b411b363SPhilipp Reisner } 2864b411b363SPhilipp Reisner 2865b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 2866b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 2867b411b363SPhilipp Reisner 286802918be2SPhilipp Reisner if (drbd_recv(mdev, &p->head.payload, header_size) != header_size) 286981e84650SAndreas Gruenbacher return false; 2870b411b363SPhilipp Reisner 2871b411b363SPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 2872b411b363SPhilipp Reisner 2873b411b363SPhilipp Reisner if (apv >= 88) { 2874b411b363SPhilipp Reisner if (apv == 88) { 2875b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 2876b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 2877b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 2878b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 287981e84650SAndreas Gruenbacher return false; 2880b411b363SPhilipp Reisner } 2881b411b363SPhilipp Reisner 2882b411b363SPhilipp Reisner if (drbd_recv(mdev, p->verify_alg, data_size) != data_size) 288381e84650SAndreas Gruenbacher return false; 2884b411b363SPhilipp Reisner 2885b411b363SPhilipp Reisner /* we expect NUL terminated string */ 2886b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2887b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 2888b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 2889b411b363SPhilipp Reisner 2890b411b363SPhilipp Reisner } else /* apv >= 89 */ { 2891b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 2892b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2893b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 2894b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 2895b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 2896b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 2897b411b363SPhilipp Reisner } 2898b411b363SPhilipp Reisner 2899b411b363SPhilipp Reisner if (strcmp(mdev->sync_conf.verify_alg, p->verify_alg)) { 2900b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2901b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 2902b411b363SPhilipp Reisner mdev->sync_conf.verify_alg, p->verify_alg); 2903b411b363SPhilipp Reisner goto disconnect; 2904b411b363SPhilipp Reisner } 2905b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 2906b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 2907b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 2908b411b363SPhilipp Reisner verify_tfm = NULL; 2909b411b363SPhilipp Reisner goto disconnect; 2910b411b363SPhilipp Reisner } 2911b411b363SPhilipp Reisner } 2912b411b363SPhilipp Reisner 2913b411b363SPhilipp Reisner if (apv >= 89 && strcmp(mdev->sync_conf.csums_alg, p->csums_alg)) { 2914b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2915b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 2916b411b363SPhilipp Reisner mdev->sync_conf.csums_alg, p->csums_alg); 2917b411b363SPhilipp Reisner goto disconnect; 2918b411b363SPhilipp Reisner } 2919b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 2920b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 2921b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 2922b411b363SPhilipp Reisner csums_tfm = NULL; 2923b411b363SPhilipp Reisner goto disconnect; 2924b411b363SPhilipp Reisner } 2925b411b363SPhilipp Reisner } 2926b411b363SPhilipp Reisner 29278e26f9ccSPhilipp Reisner if (apv > 94) { 29288e26f9ccSPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 29298e26f9ccSPhilipp Reisner mdev->sync_conf.c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 29308e26f9ccSPhilipp Reisner mdev->sync_conf.c_delay_target = be32_to_cpu(p->c_delay_target); 29318e26f9ccSPhilipp Reisner mdev->sync_conf.c_fill_target = be32_to_cpu(p->c_fill_target); 29328e26f9ccSPhilipp Reisner mdev->sync_conf.c_max_rate = be32_to_cpu(p->c_max_rate); 2933778f271dSPhilipp Reisner 2934778f271dSPhilipp Reisner fifo_size = (mdev->sync_conf.c_plan_ahead * 10 * SLEEP_TIME) / HZ; 2935778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) { 2936778f271dSPhilipp Reisner rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL); 2937778f271dSPhilipp Reisner if (!rs_plan_s) { 2938778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 2939778f271dSPhilipp Reisner goto disconnect; 2940778f271dSPhilipp Reisner } 2941778f271dSPhilipp Reisner } 29428e26f9ccSPhilipp Reisner } 2943b411b363SPhilipp Reisner 2944b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 2945b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 2946b411b363SPhilipp Reisner if (verify_tfm) { 2947b411b363SPhilipp Reisner strcpy(mdev->sync_conf.verify_alg, p->verify_alg); 2948b411b363SPhilipp Reisner mdev->sync_conf.verify_alg_len = strlen(p->verify_alg) + 1; 2949b411b363SPhilipp Reisner crypto_free_hash(mdev->verify_tfm); 2950b411b363SPhilipp Reisner mdev->verify_tfm = verify_tfm; 2951b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 2952b411b363SPhilipp Reisner } 2953b411b363SPhilipp Reisner if (csums_tfm) { 2954b411b363SPhilipp Reisner strcpy(mdev->sync_conf.csums_alg, p->csums_alg); 2955b411b363SPhilipp Reisner mdev->sync_conf.csums_alg_len = strlen(p->csums_alg) + 1; 2956b411b363SPhilipp Reisner crypto_free_hash(mdev->csums_tfm); 2957b411b363SPhilipp Reisner mdev->csums_tfm = csums_tfm; 2958b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 2959b411b363SPhilipp Reisner } 2960778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size) { 2961778f271dSPhilipp Reisner kfree(mdev->rs_plan_s.values); 2962778f271dSPhilipp Reisner mdev->rs_plan_s.values = rs_plan_s; 2963778f271dSPhilipp Reisner mdev->rs_plan_s.size = fifo_size; 2964778f271dSPhilipp Reisner mdev->rs_planed = 0; 2965778f271dSPhilipp Reisner } 2966b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 2967b411b363SPhilipp Reisner } 2968b411b363SPhilipp Reisner 2969b411b363SPhilipp Reisner return ok; 2970b411b363SPhilipp Reisner disconnect: 2971b411b363SPhilipp Reisner /* just for completeness: actually not needed, 2972b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 2973b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 2974b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 2975b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 2976b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 297781e84650SAndreas Gruenbacher return false; 2978b411b363SPhilipp Reisner } 2979b411b363SPhilipp Reisner 2980b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 2981b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 2982b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 2983b411b363SPhilipp Reisner { 2984b411b363SPhilipp Reisner sector_t d; 2985b411b363SPhilipp Reisner if (a == 0 || b == 0) 2986b411b363SPhilipp Reisner return; 2987b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 2988b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 2989b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 2990b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 2991b411b363SPhilipp Reisner } 2992b411b363SPhilipp Reisner 2993d8763023SAndreas Gruenbacher static int receive_sizes(struct drbd_conf *mdev, enum drbd_packet cmd, 2994d8763023SAndreas Gruenbacher unsigned int data_size) 2995b411b363SPhilipp Reisner { 2996e42325a5SPhilipp Reisner struct p_sizes *p = &mdev->tconn->data.rbuf.sizes; 2997b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 2998b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 2999b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3000e89b591cSPhilipp Reisner enum dds_flags ddsf; 3001b411b363SPhilipp Reisner 3002b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3003b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3004b411b363SPhilipp Reisner 3005b411b363SPhilipp Reisner if (p_size == 0 && mdev->state.disk == D_DISKLESS) { 3006b411b363SPhilipp Reisner dev_err(DEV, "some backing storage is needed\n"); 3007b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 300881e84650SAndreas Gruenbacher return false; 3009b411b363SPhilipp Reisner } 3010b411b363SPhilipp Reisner 3011b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3012b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3013b411b363SPhilipp Reisner mdev->p_size = p_size; 3014b411b363SPhilipp Reisner 3015b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3016b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3017b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3018b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3019b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 3020b411b363SPhilipp Reisner 3021b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3022b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3023b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3024b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 3025b411b363SPhilipp Reisner p_usize); 3026b411b363SPhilipp Reisner 3027b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 3028b411b363SPhilipp Reisner 3029b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 3030b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 3031b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3032b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 3033b411b363SPhilipp Reisner } 3034b411b363SPhilipp Reisner 3035b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3036b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3037a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 3038b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3039b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3040b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3041b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 3042b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3043b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 3044b411b363SPhilipp Reisner put_ldev(mdev); 304581e84650SAndreas Gruenbacher return false; 3046b411b363SPhilipp Reisner } 3047b411b363SPhilipp Reisner put_ldev(mdev); 3048b411b363SPhilipp Reisner } 3049b411b363SPhilipp Reisner 3050e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3051b411b363SPhilipp Reisner if (get_ldev(mdev)) { 305224c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3053b411b363SPhilipp Reisner put_ldev(mdev); 3054b411b363SPhilipp Reisner if (dd == dev_size_error) 305581e84650SAndreas Gruenbacher return false; 3056b411b363SPhilipp Reisner drbd_md_sync(mdev); 3057b411b363SPhilipp Reisner } else { 3058b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3059b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3060b411b363SPhilipp Reisner } 3061b411b363SPhilipp Reisner 306299432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 306399432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 306499432fccSPhilipp Reisner 3065b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3066b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3067b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3068b411b363SPhilipp Reisner ldsc = 1; 3069b411b363SPhilipp Reisner } 3070b411b363SPhilipp Reisner 3071b411b363SPhilipp Reisner put_ldev(mdev); 3072b411b363SPhilipp Reisner } 3073b411b363SPhilipp Reisner 3074b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3075b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3076b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3077b411b363SPhilipp Reisner /* we have different sizes, probably peer 3078b411b363SPhilipp Reisner * needs to know my new size... */ 3079e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3080b411b363SPhilipp Reisner } 3081b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3082b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3083b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3084e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3085e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3086e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3087b411b363SPhilipp Reisner else 3088e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3089e89b591cSPhilipp Reisner } else 3090b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3091b411b363SPhilipp Reisner } 3092b411b363SPhilipp Reisner } 3093b411b363SPhilipp Reisner 309481e84650SAndreas Gruenbacher return true; 3095b411b363SPhilipp Reisner } 3096b411b363SPhilipp Reisner 3097d8763023SAndreas Gruenbacher static int receive_uuids(struct drbd_conf *mdev, enum drbd_packet cmd, 3098d8763023SAndreas Gruenbacher unsigned int data_size) 3099b411b363SPhilipp Reisner { 3100e42325a5SPhilipp Reisner struct p_uuids *p = &mdev->tconn->data.rbuf.uuids; 3101b411b363SPhilipp Reisner u64 *p_uuid; 310262b0da3aSLars Ellenberg int i, updated_uuids = 0; 3103b411b363SPhilipp Reisner 3104b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3105b411b363SPhilipp Reisner 3106b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3107b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3108b411b363SPhilipp Reisner 3109b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3110b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3111b411b363SPhilipp Reisner 3112b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3113b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3114b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3115b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3116b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3117b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 3118b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 311981e84650SAndreas Gruenbacher return false; 3120b411b363SPhilipp Reisner } 3121b411b363SPhilipp Reisner 3122b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3123b411b363SPhilipp Reisner int skip_initial_sync = 3124b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 312531890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3126b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3127b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3128b411b363SPhilipp Reisner if (skip_initial_sync) { 3129b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3130b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 313120ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 313220ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3133b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3134b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3135b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3136b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3137b411b363SPhilipp Reisner drbd_md_sync(mdev); 313862b0da3aSLars Ellenberg updated_uuids = 1; 3139b411b363SPhilipp Reisner } 3140b411b363SPhilipp Reisner put_ldev(mdev); 314118a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 314218a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 314318a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 314418a50fa2SPhilipp Reisner for me. */ 314562b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3146b411b363SPhilipp Reisner } 3147b411b363SPhilipp Reisner 3148b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3149b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3150b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3151b411b363SPhilipp Reisner new disk state... */ 3152b411b363SPhilipp Reisner wait_event(mdev->misc_wait, !test_bit(CLUSTER_ST_CHANGE, &mdev->flags)); 3153b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 315462b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 315562b0da3aSLars Ellenberg 315662b0da3aSLars Ellenberg if (updated_uuids) 315762b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3158b411b363SPhilipp Reisner 315981e84650SAndreas Gruenbacher return true; 3160b411b363SPhilipp Reisner } 3161b411b363SPhilipp Reisner 3162b411b363SPhilipp Reisner /** 3163b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3164b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3165b411b363SPhilipp Reisner */ 3166b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3167b411b363SPhilipp Reisner { 3168b411b363SPhilipp Reisner union drbd_state ms; 3169b411b363SPhilipp Reisner 3170b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3171b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3172b411b363SPhilipp Reisner 3173b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3174b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3175b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3176b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3177b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3178b411b363SPhilipp Reisner }; 3179b411b363SPhilipp Reisner 3180b411b363SPhilipp Reisner ms.i = ps.i; 3181b411b363SPhilipp Reisner 3182b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3183b411b363SPhilipp Reisner ms.peer = ps.role; 3184b411b363SPhilipp Reisner ms.role = ps.peer; 3185b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3186b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3187b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3188b411b363SPhilipp Reisner 3189b411b363SPhilipp Reisner return ms; 3190b411b363SPhilipp Reisner } 3191b411b363SPhilipp Reisner 3192d8763023SAndreas Gruenbacher static int receive_req_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3193d8763023SAndreas Gruenbacher unsigned int data_size) 3194b411b363SPhilipp Reisner { 3195e42325a5SPhilipp Reisner struct p_req_state *p = &mdev->tconn->data.rbuf.req_state; 3196b411b363SPhilipp Reisner union drbd_state mask, val; 3197bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3198b411b363SPhilipp Reisner 3199b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3200b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3201b411b363SPhilipp Reisner 3202b411b363SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->flags) && 3203b411b363SPhilipp Reisner test_bit(CLUSTER_ST_CHANGE, &mdev->flags)) { 3204b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 320581e84650SAndreas Gruenbacher return true; 3206b411b363SPhilipp Reisner } 3207b411b363SPhilipp Reisner 3208b411b363SPhilipp Reisner mask = convert_state(mask); 3209b411b363SPhilipp Reisner val = convert_state(val); 3210b411b363SPhilipp Reisner 3211b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3212b411b363SPhilipp Reisner 3213b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3214b411b363SPhilipp Reisner drbd_md_sync(mdev); 3215b411b363SPhilipp Reisner 321681e84650SAndreas Gruenbacher return true; 3217b411b363SPhilipp Reisner } 3218b411b363SPhilipp Reisner 3219d8763023SAndreas Gruenbacher static int receive_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3220d8763023SAndreas Gruenbacher unsigned int data_size) 3221b411b363SPhilipp Reisner { 3222e42325a5SPhilipp Reisner struct p_state *p = &mdev->tconn->data.rbuf.state; 32234ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3224b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 322565d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3226b411b363SPhilipp Reisner int rv; 3227b411b363SPhilipp Reisner 3228b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3229b411b363SPhilipp Reisner 3230b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3231b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3232b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3233b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3234b411b363SPhilipp Reisner } 3235b411b363SPhilipp Reisner 323687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3237b411b363SPhilipp Reisner retry: 32384ac4aadaSLars Ellenberg os = ns = mdev->state; 323987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3240b411b363SPhilipp Reisner 3241e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3242e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3243e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3244e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3245e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3246e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3247e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3248e9ef7bb6SLars Ellenberg * syncing states. 3249e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3250e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3251e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3252e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3253e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3254e9ef7bb6SLars Ellenberg 3255e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3256e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3257e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3258e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3259e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3260e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3261e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 326281e84650SAndreas Gruenbacher return true; 3263e9ef7bb6SLars Ellenberg } 3264e9ef7bb6SLars Ellenberg } 3265e9ef7bb6SLars Ellenberg 3266e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3267e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3268e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3269e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3270e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3271e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3272e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3273e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3274e9ef7bb6SLars Ellenberg 32754ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 32764ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3277b411b363SPhilipp Reisner 327867531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 327967531718SPhilipp Reisner ns.conn = C_BEHIND; 328067531718SPhilipp Reisner 3281b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3282b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3283b411b363SPhilipp Reisner int cr; /* consider resync */ 3284b411b363SPhilipp Reisner 3285b411b363SPhilipp Reisner /* if we established a new connection */ 32864ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3287b411b363SPhilipp Reisner /* if we had an established connection 3288b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 32894ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3290b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 32914ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3292b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3293b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3294b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3295b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3296b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 32974ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3298b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3299b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3300b411b363SPhilipp Reisner 3301b411b363SPhilipp Reisner if (cr) 33024ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3303b411b363SPhilipp Reisner 3304b411b363SPhilipp Reisner put_ldev(mdev); 33054ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 33064ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3307b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 330882f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3309b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3310b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3311b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3312580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3313b411b363SPhilipp Reisner } else { 3314cf14c2e9SPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->flags)) 331581e84650SAndreas Gruenbacher return false; 33164ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 3317b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 331881e84650SAndreas Gruenbacher return false; 3319b411b363SPhilipp Reisner } 3320b411b363SPhilipp Reisner } 3321b411b363SPhilipp Reisner } 3322b411b363SPhilipp Reisner 332387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 33244ac4aadaSLars Ellenberg if (mdev->state.i != os.i) 3325b411b363SPhilipp Reisner goto retry; 3326b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3327b411b363SPhilipp Reisner ns.peer = peer_state.role; 3328b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3329b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 33304ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3331b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 33324ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 33334ac4aadaSLars Ellenberg if (ns.pdsk == D_CONSISTENT && is_susp(ns) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3334481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 33358554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3336481c6f50SPhilipp Reisner for temporal network outages! */ 333787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3338481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 3339481c6f50SPhilipp Reisner tl_clear(mdev); 3340481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3341481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 3342481c6f50SPhilipp Reisner drbd_force_state(mdev, NS2(conn, C_PROTOCOL_ERROR, susp, 0)); 334381e84650SAndreas Gruenbacher return false; 3344481c6f50SPhilipp Reisner } 334565d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 3346b411b363SPhilipp Reisner ns = mdev->state; 334787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3348b411b363SPhilipp Reisner 3349b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 3350b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 335181e84650SAndreas Gruenbacher return false; 3352b411b363SPhilipp Reisner } 3353b411b363SPhilipp Reisner 33544ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 33554ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3356b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3357b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3358b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3359b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3360b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3361b411b363SPhilipp Reisner drbd_send_state(mdev); 3362b411b363SPhilipp Reisner } 3363b411b363SPhilipp Reisner } 3364b411b363SPhilipp Reisner 336589e58e75SPhilipp Reisner mdev->tconn->net_conf->want_lose = 0; 3366b411b363SPhilipp Reisner 3367b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3368b411b363SPhilipp Reisner 336981e84650SAndreas Gruenbacher return true; 3370b411b363SPhilipp Reisner } 3371b411b363SPhilipp Reisner 3372d8763023SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_conf *mdev, enum drbd_packet cmd, 3373d8763023SAndreas Gruenbacher unsigned int data_size) 3374b411b363SPhilipp Reisner { 3375e42325a5SPhilipp Reisner struct p_rs_uuid *p = &mdev->tconn->data.rbuf.rs_uuid; 3376b411b363SPhilipp Reisner 3377b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3378b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3379c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3380b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3381b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3382b411b363SPhilipp Reisner 3383b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3384b411b363SPhilipp Reisner 3385b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3386b411b363SPhilipp Reisner _not_ be rotated into the history */ 3387b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3388b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3389b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3390b411b363SPhilipp Reisner 339162b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3392b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3393b411b363SPhilipp Reisner 3394b411b363SPhilipp Reisner put_ldev(mdev); 3395b411b363SPhilipp Reisner } else 3396b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3397b411b363SPhilipp Reisner 339881e84650SAndreas Gruenbacher return true; 3399b411b363SPhilipp Reisner } 3400b411b363SPhilipp Reisner 34012c46407dSAndreas Gruenbacher /** 34022c46407dSAndreas Gruenbacher * receive_bitmap_plain 34032c46407dSAndreas Gruenbacher * 34042c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 34052c46407dSAndreas Gruenbacher * code upon failure. 34062c46407dSAndreas Gruenbacher */ 34072c46407dSAndreas Gruenbacher static int 340802918be2SPhilipp Reisner receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size, 3409b411b363SPhilipp Reisner unsigned long *buffer, struct bm_xfer_ctx *c) 3410b411b363SPhilipp Reisner { 3411b411b363SPhilipp Reisner unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset); 3412b411b363SPhilipp Reisner unsigned want = num_words * sizeof(long); 34132c46407dSAndreas Gruenbacher int err; 3414b411b363SPhilipp Reisner 341502918be2SPhilipp Reisner if (want != data_size) { 341602918be2SPhilipp Reisner dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size); 34172c46407dSAndreas Gruenbacher return -EIO; 3418b411b363SPhilipp Reisner } 3419b411b363SPhilipp Reisner if (want == 0) 34202c46407dSAndreas Gruenbacher return 0; 34212c46407dSAndreas Gruenbacher err = drbd_recv(mdev, buffer, want); 34222c46407dSAndreas Gruenbacher if (err != want) { 34232c46407dSAndreas Gruenbacher if (err >= 0) 34242c46407dSAndreas Gruenbacher err = -EIO; 34252c46407dSAndreas Gruenbacher return err; 34262c46407dSAndreas Gruenbacher } 3427b411b363SPhilipp Reisner 3428b411b363SPhilipp Reisner drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer); 3429b411b363SPhilipp Reisner 3430b411b363SPhilipp Reisner c->word_offset += num_words; 3431b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3432b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3433b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3434b411b363SPhilipp Reisner 34352c46407dSAndreas Gruenbacher return 1; 3436b411b363SPhilipp Reisner } 3437b411b363SPhilipp Reisner 34382c46407dSAndreas Gruenbacher /** 34392c46407dSAndreas Gruenbacher * recv_bm_rle_bits 34402c46407dSAndreas Gruenbacher * 34412c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 34422c46407dSAndreas Gruenbacher * code upon failure. 34432c46407dSAndreas Gruenbacher */ 34442c46407dSAndreas Gruenbacher static int 3445b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3446b411b363SPhilipp Reisner struct p_compressed_bm *p, 3447c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3448c6d25cfeSPhilipp Reisner unsigned int len) 3449b411b363SPhilipp Reisner { 3450b411b363SPhilipp Reisner struct bitstream bs; 3451b411b363SPhilipp Reisner u64 look_ahead; 3452b411b363SPhilipp Reisner u64 rl; 3453b411b363SPhilipp Reisner u64 tmp; 3454b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3455b411b363SPhilipp Reisner unsigned long e; 3456b411b363SPhilipp Reisner int toggle = DCBP_get_start(p); 3457b411b363SPhilipp Reisner int have; 3458b411b363SPhilipp Reisner int bits; 3459b411b363SPhilipp Reisner 3460b411b363SPhilipp Reisner bitstream_init(&bs, p->code, len, DCBP_get_pad_bits(p)); 3461b411b363SPhilipp Reisner 3462b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3463b411b363SPhilipp Reisner if (bits < 0) 34642c46407dSAndreas Gruenbacher return -EIO; 3465b411b363SPhilipp Reisner 3466b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3467b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3468b411b363SPhilipp Reisner if (bits <= 0) 34692c46407dSAndreas Gruenbacher return -EIO; 3470b411b363SPhilipp Reisner 3471b411b363SPhilipp Reisner if (toggle) { 3472b411b363SPhilipp Reisner e = s + rl -1; 3473b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3474b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 34752c46407dSAndreas Gruenbacher return -EIO; 3476b411b363SPhilipp Reisner } 3477b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3478b411b363SPhilipp Reisner } 3479b411b363SPhilipp Reisner 3480b411b363SPhilipp Reisner if (have < bits) { 3481b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3482b411b363SPhilipp Reisner have, bits, look_ahead, 3483b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3484b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 34852c46407dSAndreas Gruenbacher return -EIO; 3486b411b363SPhilipp Reisner } 3487b411b363SPhilipp Reisner look_ahead >>= bits; 3488b411b363SPhilipp Reisner have -= bits; 3489b411b363SPhilipp Reisner 3490b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3491b411b363SPhilipp Reisner if (bits < 0) 34922c46407dSAndreas Gruenbacher return -EIO; 3493b411b363SPhilipp Reisner look_ahead |= tmp << have; 3494b411b363SPhilipp Reisner have += bits; 3495b411b363SPhilipp Reisner } 3496b411b363SPhilipp Reisner 3497b411b363SPhilipp Reisner c->bit_offset = s; 3498b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3499b411b363SPhilipp Reisner 35002c46407dSAndreas Gruenbacher return (s != c->bm_bits); 3501b411b363SPhilipp Reisner } 3502b411b363SPhilipp Reisner 35032c46407dSAndreas Gruenbacher /** 35042c46407dSAndreas Gruenbacher * decode_bitmap_c 35052c46407dSAndreas Gruenbacher * 35062c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 35072c46407dSAndreas Gruenbacher * code upon failure. 35082c46407dSAndreas Gruenbacher */ 35092c46407dSAndreas Gruenbacher static int 3510b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3511b411b363SPhilipp Reisner struct p_compressed_bm *p, 3512c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3513c6d25cfeSPhilipp Reisner unsigned int len) 3514b411b363SPhilipp Reisner { 3515b411b363SPhilipp Reisner if (DCBP_get_code(p) == RLE_VLI_Bits) 3516c6d25cfeSPhilipp Reisner return recv_bm_rle_bits(mdev, p, c, len); 3517b411b363SPhilipp Reisner 3518b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3519b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3520b411b363SPhilipp Reisner * during all our tests. */ 3521b411b363SPhilipp Reisner 3522b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 3523b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 35242c46407dSAndreas Gruenbacher return -EIO; 3525b411b363SPhilipp Reisner } 3526b411b363SPhilipp Reisner 3527b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3528b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3529b411b363SPhilipp Reisner { 3530b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 3531c012949aSPhilipp Reisner unsigned plain = sizeof(struct p_header) * 3532b411b363SPhilipp Reisner ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1) 3533b411b363SPhilipp Reisner + c->bm_words * sizeof(long); 3534b411b363SPhilipp Reisner unsigned total = c->bytes[0] + c->bytes[1]; 3535b411b363SPhilipp Reisner unsigned r; 3536b411b363SPhilipp Reisner 3537b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3538b411b363SPhilipp Reisner if (total == 0) 3539b411b363SPhilipp Reisner return; 3540b411b363SPhilipp Reisner 3541b411b363SPhilipp Reisner /* don't report if not compressed */ 3542b411b363SPhilipp Reisner if (total >= plain) 3543b411b363SPhilipp Reisner return; 3544b411b363SPhilipp Reisner 3545b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3546b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3547b411b363SPhilipp Reisner : (1000 * total / plain); 3548b411b363SPhilipp Reisner 3549b411b363SPhilipp Reisner if (r > 1000) 3550b411b363SPhilipp Reisner r = 1000; 3551b411b363SPhilipp Reisner 3552b411b363SPhilipp Reisner r = 1000 - r; 3553b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3554b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3555b411b363SPhilipp Reisner direction, 3556b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3557b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3558b411b363SPhilipp Reisner total, r/10, r % 10); 3559b411b363SPhilipp Reisner } 3560b411b363SPhilipp Reisner 3561b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3562b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3563b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3564b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3565b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3566b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3567b411b363SPhilipp Reisner 3568b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 3569d8763023SAndreas Gruenbacher static int receive_bitmap(struct drbd_conf *mdev, enum drbd_packet cmd, 3570d8763023SAndreas Gruenbacher unsigned int data_size) 3571b411b363SPhilipp Reisner { 3572b411b363SPhilipp Reisner struct bm_xfer_ctx c; 3573b411b363SPhilipp Reisner void *buffer; 35742c46407dSAndreas Gruenbacher int err; 357581e84650SAndreas Gruenbacher int ok = false; 3576257d0af6SPhilipp Reisner struct p_header *h = &mdev->tconn->data.rbuf.header; 3577b411b363SPhilipp Reisner 357820ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 357920ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 358020ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 3581b411b363SPhilipp Reisner 3582b411b363SPhilipp Reisner /* maybe we should use some per thread scratch page, 3583b411b363SPhilipp Reisner * and allocate that during initial device creation? */ 3584b411b363SPhilipp Reisner buffer = (unsigned long *) __get_free_page(GFP_NOIO); 3585b411b363SPhilipp Reisner if (!buffer) { 3586b411b363SPhilipp Reisner dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__); 3587b411b363SPhilipp Reisner goto out; 3588b411b363SPhilipp Reisner } 3589b411b363SPhilipp Reisner 3590b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3591b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3592b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3593b411b363SPhilipp Reisner }; 3594b411b363SPhilipp Reisner 35952c46407dSAndreas Gruenbacher for(;;) { 359602918be2SPhilipp Reisner if (cmd == P_BITMAP) { 35972c46407dSAndreas Gruenbacher err = receive_bitmap_plain(mdev, data_size, buffer, &c); 359802918be2SPhilipp Reisner } else if (cmd == P_COMPRESSED_BITMAP) { 3599b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3600b411b363SPhilipp Reisner * and the feature is enabled! */ 3601b411b363SPhilipp Reisner struct p_compressed_bm *p; 3602b411b363SPhilipp Reisner 360302918be2SPhilipp Reisner if (data_size > BM_PACKET_PAYLOAD_BYTES) { 3604b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 3605b411b363SPhilipp Reisner goto out; 3606b411b363SPhilipp Reisner } 3607b411b363SPhilipp Reisner /* use the page buff */ 3608b411b363SPhilipp Reisner p = buffer; 3609b411b363SPhilipp Reisner memcpy(p, h, sizeof(*h)); 361002918be2SPhilipp Reisner if (drbd_recv(mdev, p->head.payload, data_size) != data_size) 3611b411b363SPhilipp Reisner goto out; 3612004352faSLars Ellenberg if (data_size <= (sizeof(*p) - sizeof(p->head))) { 3613004352faSLars Ellenberg dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", data_size); 361478fcbdaeSAndreas Gruenbacher goto out; 3615b411b363SPhilipp Reisner } 3616c6d25cfeSPhilipp Reisner err = decode_bitmap_c(mdev, p, &c, data_size); 3617b411b363SPhilipp Reisner } else { 361802918be2SPhilipp Reisner dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", cmd); 3619b411b363SPhilipp Reisner goto out; 3620b411b363SPhilipp Reisner } 3621b411b363SPhilipp Reisner 362202918be2SPhilipp Reisner c.packets[cmd == P_BITMAP]++; 3623257d0af6SPhilipp Reisner c.bytes[cmd == P_BITMAP] += sizeof(struct p_header) + data_size; 3624b411b363SPhilipp Reisner 36252c46407dSAndreas Gruenbacher if (err <= 0) { 36262c46407dSAndreas Gruenbacher if (err < 0) 36272c46407dSAndreas Gruenbacher goto out; 3628b411b363SPhilipp Reisner break; 36292c46407dSAndreas Gruenbacher } 363002918be2SPhilipp Reisner if (!drbd_recv_header(mdev, &cmd, &data_size)) 3631b411b363SPhilipp Reisner goto out; 36322c46407dSAndreas Gruenbacher } 3633b411b363SPhilipp Reisner 3634b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3635b411b363SPhilipp Reisner 3636b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3637de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 3638de1f8e4aSAndreas Gruenbacher 3639b411b363SPhilipp Reisner ok = !drbd_send_bitmap(mdev); 3640b411b363SPhilipp Reisner if (!ok) 3641b411b363SPhilipp Reisner goto out; 3642b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3643de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3644de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 3645b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3646b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3647b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3648b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3649b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3650b411b363SPhilipp Reisner } 3651b411b363SPhilipp Reisner 365281e84650SAndreas Gruenbacher ok = true; 3653b411b363SPhilipp Reisner out: 365420ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 3655b411b363SPhilipp Reisner if (ok && mdev->state.conn == C_WF_BITMAP_S) 3656b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 3657b411b363SPhilipp Reisner free_page((unsigned long) buffer); 3658b411b363SPhilipp Reisner return ok; 3659b411b363SPhilipp Reisner } 3660b411b363SPhilipp Reisner 3661d8763023SAndreas Gruenbacher static int receive_skip(struct drbd_conf *mdev, enum drbd_packet cmd, 3662d8763023SAndreas Gruenbacher unsigned int data_size) 3663b411b363SPhilipp Reisner { 3664b411b363SPhilipp Reisner /* TODO zero copy sink :) */ 3665b411b363SPhilipp Reisner static char sink[128]; 3666b411b363SPhilipp Reisner int size, want, r; 3667b411b363SPhilipp Reisner 3668b411b363SPhilipp Reisner dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n", 366902918be2SPhilipp Reisner cmd, data_size); 3670b411b363SPhilipp Reisner 367102918be2SPhilipp Reisner size = data_size; 3672b411b363SPhilipp Reisner while (size > 0) { 3673b411b363SPhilipp Reisner want = min_t(int, size, sizeof(sink)); 3674b411b363SPhilipp Reisner r = drbd_recv(mdev, sink, want); 3675841ce241SAndreas Gruenbacher if (!expect(r > 0)) 3676841ce241SAndreas Gruenbacher break; 3677b411b363SPhilipp Reisner size -= r; 3678b411b363SPhilipp Reisner } 3679b411b363SPhilipp Reisner return size == 0; 3680b411b363SPhilipp Reisner } 3681b411b363SPhilipp Reisner 3682d8763023SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packet cmd, 3683d8763023SAndreas Gruenbacher unsigned int data_size) 3684b411b363SPhilipp Reisner { 3685b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3686b411b363SPhilipp Reisner * with the data requests being unplugged */ 3687e42325a5SPhilipp Reisner drbd_tcp_quickack(mdev->tconn->data.socket); 3688b411b363SPhilipp Reisner 368981e84650SAndreas Gruenbacher return true; 3690b411b363SPhilipp Reisner } 3691b411b363SPhilipp Reisner 3692d8763023SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_conf *mdev, enum drbd_packet cmd, 3693d8763023SAndreas Gruenbacher unsigned int data_size) 369473a01a18SPhilipp Reisner { 3695e42325a5SPhilipp Reisner struct p_block_desc *p = &mdev->tconn->data.rbuf.block_desc; 369673a01a18SPhilipp Reisner 3697f735e363SLars Ellenberg switch (mdev->state.conn) { 3698f735e363SLars Ellenberg case C_WF_SYNC_UUID: 3699f735e363SLars Ellenberg case C_WF_BITMAP_T: 3700f735e363SLars Ellenberg case C_BEHIND: 3701f735e363SLars Ellenberg break; 3702f735e363SLars Ellenberg default: 3703f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 3704f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 3705f735e363SLars Ellenberg } 3706f735e363SLars Ellenberg 370773a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 370873a01a18SPhilipp Reisner 370981e84650SAndreas Gruenbacher return true; 371073a01a18SPhilipp Reisner } 371173a01a18SPhilipp Reisner 3712d8763023SAndreas Gruenbacher typedef int (*drbd_cmd_handler_f)(struct drbd_conf *, enum drbd_packet cmd, 3713d8763023SAndreas Gruenbacher unsigned int to_receive); 3714b411b363SPhilipp Reisner 371502918be2SPhilipp Reisner struct data_cmd { 371602918be2SPhilipp Reisner int expect_payload; 371702918be2SPhilipp Reisner size_t pkt_size; 371802918be2SPhilipp Reisner drbd_cmd_handler_f function; 3719b411b363SPhilipp Reisner }; 3720b411b363SPhilipp Reisner 372102918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 372202918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 372302918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 372402918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 372502918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 3726257d0af6SPhilipp Reisner [P_BITMAP] = { 1, sizeof(struct p_header), receive_bitmap } , 3727257d0af6SPhilipp Reisner [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header), receive_bitmap } , 3728257d0af6SPhilipp Reisner [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header), receive_UnplugRemote }, 372902918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 373002918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 3731257d0af6SPhilipp Reisner [P_SYNC_PARAM] = { 1, sizeof(struct p_header), receive_SyncParam }, 3732257d0af6SPhilipp Reisner [P_SYNC_PARAM89] = { 1, sizeof(struct p_header), receive_SyncParam }, 373302918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 373402918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 373502918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 373602918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 373702918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 373802918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 373902918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 374002918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 374102918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 374202918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 374373a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 374402918be2SPhilipp Reisner /* anything missing from this table is in 374502918be2SPhilipp Reisner * the asender_tbl, see get_asender_cmd */ 374602918be2SPhilipp Reisner [P_MAX_CMD] = { 0, 0, NULL }, 374702918be2SPhilipp Reisner }; 374802918be2SPhilipp Reisner 374902918be2SPhilipp Reisner /* All handler functions that expect a sub-header get that sub-heder in 3750e42325a5SPhilipp Reisner mdev->tconn->data.rbuf.header.head.payload. 375102918be2SPhilipp Reisner 3752e42325a5SPhilipp Reisner Usually in mdev->tconn->data.rbuf.header.head the callback can find the usual 375302918be2SPhilipp Reisner p_header, but they may not rely on that. Since there is also p_header95 ! 375402918be2SPhilipp Reisner */ 3755b411b363SPhilipp Reisner 3756b411b363SPhilipp Reisner static void drbdd(struct drbd_conf *mdev) 3757b411b363SPhilipp Reisner { 3758c012949aSPhilipp Reisner struct p_header *header = &mdev->tconn->data.rbuf.header; 375902918be2SPhilipp Reisner unsigned int packet_size; 3760d8763023SAndreas Gruenbacher enum drbd_packet cmd; 376102918be2SPhilipp Reisner size_t shs; /* sub header size */ 376202918be2SPhilipp Reisner int rv; 3763b411b363SPhilipp Reisner 3764e6b3ea83SPhilipp Reisner while (get_t_state(&mdev->tconn->receiver) == RUNNING) { 3765b411b363SPhilipp Reisner drbd_thread_current_set_cpu(mdev); 376602918be2SPhilipp Reisner if (!drbd_recv_header(mdev, &cmd, &packet_size)) 376702918be2SPhilipp Reisner goto err_out; 376802918be2SPhilipp Reisner 376902918be2SPhilipp Reisner if (unlikely(cmd >= P_MAX_CMD || !drbd_cmd_handler[cmd].function)) { 377002918be2SPhilipp Reisner dev_err(DEV, "unknown packet type %d, l: %d!\n", cmd, packet_size); 377102918be2SPhilipp Reisner goto err_out; 37720b33a916SLars Ellenberg } 3773b411b363SPhilipp Reisner 3774c012949aSPhilipp Reisner shs = drbd_cmd_handler[cmd].pkt_size - sizeof(struct p_header); 3775c13f7e1aSLars Ellenberg if (packet_size - shs > 0 && !drbd_cmd_handler[cmd].expect_payload) { 3776c13f7e1aSLars Ellenberg dev_err(DEV, "No payload expected %s l:%d\n", cmdname(cmd), packet_size); 3777c13f7e1aSLars Ellenberg goto err_out; 3778c13f7e1aSLars Ellenberg } 3779c13f7e1aSLars Ellenberg 3780c13f7e1aSLars Ellenberg if (shs) { 3781c012949aSPhilipp Reisner rv = drbd_recv(mdev, &header->payload, shs); 378202918be2SPhilipp Reisner if (unlikely(rv != shs)) { 37830ddc5549SLars Ellenberg if (!signal_pending(current)) 37840ddc5549SLars Ellenberg dev_warn(DEV, "short read while reading sub header: rv=%d\n", rv); 378502918be2SPhilipp Reisner goto err_out; 3786b411b363SPhilipp Reisner } 378702918be2SPhilipp Reisner } 378802918be2SPhilipp Reisner 378902918be2SPhilipp Reisner rv = drbd_cmd_handler[cmd].function(mdev, cmd, packet_size - shs); 379002918be2SPhilipp Reisner 379102918be2SPhilipp Reisner if (unlikely(!rv)) { 3792b411b363SPhilipp Reisner dev_err(DEV, "error receiving %s, l: %d!\n", 379302918be2SPhilipp Reisner cmdname(cmd), packet_size); 379402918be2SPhilipp Reisner goto err_out; 3795b411b363SPhilipp Reisner } 3796b411b363SPhilipp Reisner } 379702918be2SPhilipp Reisner 379802918be2SPhilipp Reisner if (0) { 379902918be2SPhilipp Reisner err_out: 3800b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 3801b411b363SPhilipp Reisner } 3802856c50c7SLars Ellenberg /* If we leave here, we probably want to update at least the 3803856c50c7SLars Ellenberg * "Connected" indicator on stable storage. Do so explicitly here. */ 3804856c50c7SLars Ellenberg drbd_md_sync(mdev); 3805b411b363SPhilipp Reisner } 3806b411b363SPhilipp Reisner 3807191d3cc8SPhilipp Reisner void drbd_flush_workqueue(struct drbd_tconn *tconn) 3808b411b363SPhilipp Reisner { 3809b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 3810b411b363SPhilipp Reisner 3811b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 3812b411b363SPhilipp Reisner init_completion(&barr.done); 3813191d3cc8SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 3814b411b363SPhilipp Reisner wait_for_completion(&barr.done); 3815b411b363SPhilipp Reisner } 3816b411b363SPhilipp Reisner 3817b411b363SPhilipp Reisner static void drbd_disconnect(struct drbd_conf *mdev) 3818b411b363SPhilipp Reisner { 3819b411b363SPhilipp Reisner enum drbd_fencing_p fp; 3820b411b363SPhilipp Reisner union drbd_state os, ns; 3821b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 3822b411b363SPhilipp Reisner unsigned int i; 3823b411b363SPhilipp Reisner 3824b411b363SPhilipp Reisner if (mdev->state.conn == C_STANDALONE) 3825b411b363SPhilipp Reisner return; 3826b411b363SPhilipp Reisner 3827b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 3828e6b3ea83SPhilipp Reisner drbd_thread_stop(&mdev->tconn->asender); 3829b411b363SPhilipp Reisner drbd_free_sock(mdev); 3830b411b363SPhilipp Reisner 383185719573SPhilipp Reisner /* wait for current activity to cease. */ 383287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3833b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 3834b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 3835b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 383687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3837b411b363SPhilipp Reisner 3838b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 3839b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 3840b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 3841b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 3842b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 3843b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 3844b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 3845b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 3846b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 3847b411b363SPhilipp Reisner * on the fly. */ 3848b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 3849b411b363SPhilipp Reisner mdev->rs_total = 0; 3850b411b363SPhilipp Reisner mdev->rs_failed = 0; 3851b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 3852b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 3853b411b363SPhilipp Reisner 38547fde2be9SPhilipp Reisner del_timer(&mdev->request_timer); 38557fde2be9SPhilipp Reisner 3856b411b363SPhilipp Reisner /* make sure syncer is stopped and w_resume_next_sg queued */ 3857b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 3858b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 3859b411b363SPhilipp Reisner 3860b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 3861b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 3862b411b363SPhilipp Reisner * to be "canceled" */ 3863191d3cc8SPhilipp Reisner drbd_flush_workqueue(mdev->tconn); 3864b411b363SPhilipp Reisner 3865b411b363SPhilipp Reisner /* This also does reclaim_net_ee(). If we do this too early, we might 3866b411b363SPhilipp Reisner * miss some resync ee and pages.*/ 3867b411b363SPhilipp Reisner drbd_process_done_ee(mdev); 3868b411b363SPhilipp Reisner 3869b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3870b411b363SPhilipp Reisner mdev->p_uuid = NULL; 3871b411b363SPhilipp Reisner 3872fb22c402SPhilipp Reisner if (!is_susp(mdev->state)) 3873b411b363SPhilipp Reisner tl_clear(mdev); 3874b411b363SPhilipp Reisner 3875b411b363SPhilipp Reisner dev_info(DEV, "Connection closed\n"); 3876b411b363SPhilipp Reisner 3877b411b363SPhilipp Reisner drbd_md_sync(mdev); 3878b411b363SPhilipp Reisner 3879b411b363SPhilipp Reisner fp = FP_DONT_CARE; 3880b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3881b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 3882b411b363SPhilipp Reisner put_ldev(mdev); 3883b411b363SPhilipp Reisner } 3884b411b363SPhilipp Reisner 388587f7be4cSPhilipp Reisner if (mdev->state.role == R_PRIMARY && fp >= FP_RESOURCE && mdev->state.pdsk >= D_UNKNOWN) 388687f7be4cSPhilipp Reisner drbd_try_outdate_peer_async(mdev); 3887b411b363SPhilipp Reisner 388887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3889b411b363SPhilipp Reisner os = mdev->state; 3890b411b363SPhilipp Reisner if (os.conn >= C_UNCONNECTED) { 3891b411b363SPhilipp Reisner /* Do not restart in case we are C_DISCONNECTING */ 3892b411b363SPhilipp Reisner ns = os; 3893b411b363SPhilipp Reisner ns.conn = C_UNCONNECTED; 3894b411b363SPhilipp Reisner rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 3895b411b363SPhilipp Reisner } 389687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3897b411b363SPhilipp Reisner 3898b411b363SPhilipp Reisner if (os.conn == C_DISCONNECTING) { 3899b2fb6dbeSPhilipp Reisner wait_event(mdev->tconn->net_cnt_wait, atomic_read(&mdev->tconn->net_cnt) == 0); 3900b411b363SPhilipp Reisner 3901a0638456SPhilipp Reisner crypto_free_hash(mdev->tconn->cram_hmac_tfm); 3902a0638456SPhilipp Reisner mdev->tconn->cram_hmac_tfm = NULL; 3903b411b363SPhilipp Reisner 390489e58e75SPhilipp Reisner kfree(mdev->tconn->net_conf); 390589e58e75SPhilipp Reisner mdev->tconn->net_conf = NULL; 3906b411b363SPhilipp Reisner drbd_request_state(mdev, NS(conn, C_STANDALONE)); 3907b411b363SPhilipp Reisner } 3908b411b363SPhilipp Reisner 390920ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 391020ceb2b2SLars Ellenberg * if any. */ 391120ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 391220ceb2b2SLars Ellenberg 3913b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 3914b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 3915b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 3916b411b363SPhilipp Reisner * 3917b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 3918b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 3919b411b363SPhilipp Reisner */ 3920b411b363SPhilipp Reisner i = drbd_release_ee(mdev, &mdev->net_ee); 3921b411b363SPhilipp Reisner if (i) 3922b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 3923435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 3924435f0740SLars Ellenberg if (i) 3925435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 3926b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 3927b411b363SPhilipp Reisner if (i) 392845bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 3929b411b363SPhilipp Reisner 3930b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 3931b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 3932b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 3933b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 3934b411b363SPhilipp Reisner 3935b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 3936b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 3937b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 3938b411b363SPhilipp Reisner } 3939b411b363SPhilipp Reisner 3940b411b363SPhilipp Reisner /* 3941b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 3942b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 3943b411b363SPhilipp Reisner * 3944b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 3945b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 3946b411b363SPhilipp Reisner * 3947b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 3948b411b363SPhilipp Reisner */ 3949b411b363SPhilipp Reisner static int drbd_send_handshake(struct drbd_conf *mdev) 3950b411b363SPhilipp Reisner { 3951e6b3ea83SPhilipp Reisner /* ASSERT current == mdev->tconn->receiver ... */ 3952e42325a5SPhilipp Reisner struct p_handshake *p = &mdev->tconn->data.sbuf.handshake; 3953b411b363SPhilipp Reisner int ok; 3954b411b363SPhilipp Reisner 3955e42325a5SPhilipp Reisner if (mutex_lock_interruptible(&mdev->tconn->data.mutex)) { 3956b411b363SPhilipp Reisner dev_err(DEV, "interrupted during initial handshake\n"); 3957b411b363SPhilipp Reisner return 0; /* interrupted. not ok. */ 3958b411b363SPhilipp Reisner } 3959b411b363SPhilipp Reisner 3960e42325a5SPhilipp Reisner if (mdev->tconn->data.socket == NULL) { 3961e42325a5SPhilipp Reisner mutex_unlock(&mdev->tconn->data.mutex); 3962b411b363SPhilipp Reisner return 0; 3963b411b363SPhilipp Reisner } 3964b411b363SPhilipp Reisner 3965b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 3966b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 3967b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 3968e42325a5SPhilipp Reisner ok = _drbd_send_cmd(mdev, mdev->tconn->data.socket, P_HAND_SHAKE, 3969c012949aSPhilipp Reisner &p->head, sizeof(*p), 0 ); 3970e42325a5SPhilipp Reisner mutex_unlock(&mdev->tconn->data.mutex); 3971b411b363SPhilipp Reisner return ok; 3972b411b363SPhilipp Reisner } 3973b411b363SPhilipp Reisner 3974b411b363SPhilipp Reisner /* 3975b411b363SPhilipp Reisner * return values: 3976b411b363SPhilipp Reisner * 1 yes, we have a valid connection 3977b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 3978b411b363SPhilipp Reisner * -1 peer talks different language, 3979b411b363SPhilipp Reisner * no point in trying again, please go standalone. 3980b411b363SPhilipp Reisner */ 3981b411b363SPhilipp Reisner static int drbd_do_handshake(struct drbd_conf *mdev) 3982b411b363SPhilipp Reisner { 3983e6b3ea83SPhilipp Reisner /* ASSERT current == mdev->tconn->receiver ... */ 3984e42325a5SPhilipp Reisner struct p_handshake *p = &mdev->tconn->data.rbuf.handshake; 398502918be2SPhilipp Reisner const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80); 398602918be2SPhilipp Reisner unsigned int length; 3987d8763023SAndreas Gruenbacher enum drbd_packet cmd; 3988b411b363SPhilipp Reisner int rv; 3989b411b363SPhilipp Reisner 3990b411b363SPhilipp Reisner rv = drbd_send_handshake(mdev); 3991b411b363SPhilipp Reisner if (!rv) 3992b411b363SPhilipp Reisner return 0; 3993b411b363SPhilipp Reisner 399402918be2SPhilipp Reisner rv = drbd_recv_header(mdev, &cmd, &length); 3995b411b363SPhilipp Reisner if (!rv) 3996b411b363SPhilipp Reisner return 0; 3997b411b363SPhilipp Reisner 399802918be2SPhilipp Reisner if (cmd != P_HAND_SHAKE) { 3999b411b363SPhilipp Reisner dev_err(DEV, "expected HandShake packet, received: %s (0x%04x)\n", 400002918be2SPhilipp Reisner cmdname(cmd), cmd); 4001b411b363SPhilipp Reisner return -1; 4002b411b363SPhilipp Reisner } 4003b411b363SPhilipp Reisner 400402918be2SPhilipp Reisner if (length != expect) { 4005b411b363SPhilipp Reisner dev_err(DEV, "expected HandShake length: %u, received: %u\n", 400602918be2SPhilipp Reisner expect, length); 4007b411b363SPhilipp Reisner return -1; 4008b411b363SPhilipp Reisner } 4009b411b363SPhilipp Reisner 4010b411b363SPhilipp Reisner rv = drbd_recv(mdev, &p->head.payload, expect); 4011b411b363SPhilipp Reisner 4012b411b363SPhilipp Reisner if (rv != expect) { 40130ddc5549SLars Ellenberg if (!signal_pending(current)) 40140ddc5549SLars Ellenberg dev_warn(DEV, "short read receiving handshake packet: l=%u\n", rv); 4015b411b363SPhilipp Reisner return 0; 4016b411b363SPhilipp Reisner } 4017b411b363SPhilipp Reisner 4018b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4019b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4020b411b363SPhilipp Reisner if (p->protocol_max == 0) 4021b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4022b411b363SPhilipp Reisner 4023b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4024b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4025b411b363SPhilipp Reisner goto incompat; 4026b411b363SPhilipp Reisner 402731890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4028b411b363SPhilipp Reisner 4029b411b363SPhilipp Reisner dev_info(DEV, "Handshake successful: " 403031890f4aSPhilipp Reisner "Agreed network protocol version %d\n", mdev->tconn->agreed_pro_version); 4031b411b363SPhilipp Reisner 4032b411b363SPhilipp Reisner return 1; 4033b411b363SPhilipp Reisner 4034b411b363SPhilipp Reisner incompat: 4035b411b363SPhilipp Reisner dev_err(DEV, "incompatible DRBD dialects: " 4036b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4037b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4038b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4039b411b363SPhilipp Reisner return -1; 4040b411b363SPhilipp Reisner } 4041b411b363SPhilipp Reisner 4042b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 4043b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev) 4044b411b363SPhilipp Reisner { 4045b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4046b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4047b10d96cbSJohannes Thoma return -1; 4048b411b363SPhilipp Reisner } 4049b411b363SPhilipp Reisner #else 4050b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4051b10d96cbSJohannes Thoma 4052b10d96cbSJohannes Thoma /* Return value: 4053b10d96cbSJohannes Thoma 1 - auth succeeded, 4054b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4055b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4056b10d96cbSJohannes Thoma */ 4057b10d96cbSJohannes Thoma 4058b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev) 4059b411b363SPhilipp Reisner { 4060b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4061b411b363SPhilipp Reisner struct scatterlist sg; 4062b411b363SPhilipp Reisner char *response = NULL; 4063b411b363SPhilipp Reisner char *right_response = NULL; 4064b411b363SPhilipp Reisner char *peers_ch = NULL; 406589e58e75SPhilipp Reisner unsigned int key_len = strlen(mdev->tconn->net_conf->shared_secret); 4066b411b363SPhilipp Reisner unsigned int resp_size; 4067b411b363SPhilipp Reisner struct hash_desc desc; 4068d8763023SAndreas Gruenbacher enum drbd_packet cmd; 406902918be2SPhilipp Reisner unsigned int length; 4070b411b363SPhilipp Reisner int rv; 4071b411b363SPhilipp Reisner 4072a0638456SPhilipp Reisner desc.tfm = mdev->tconn->cram_hmac_tfm; 4073b411b363SPhilipp Reisner desc.flags = 0; 4074b411b363SPhilipp Reisner 4075a0638456SPhilipp Reisner rv = crypto_hash_setkey(mdev->tconn->cram_hmac_tfm, 407689e58e75SPhilipp Reisner (u8 *)mdev->tconn->net_conf->shared_secret, key_len); 4077b411b363SPhilipp Reisner if (rv) { 4078b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_setkey() failed with %d\n", rv); 4079b10d96cbSJohannes Thoma rv = -1; 4080b411b363SPhilipp Reisner goto fail; 4081b411b363SPhilipp Reisner } 4082b411b363SPhilipp Reisner 4083b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4084b411b363SPhilipp Reisner 4085b411b363SPhilipp Reisner rv = drbd_send_cmd2(mdev, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN); 4086b411b363SPhilipp Reisner if (!rv) 4087b411b363SPhilipp Reisner goto fail; 4088b411b363SPhilipp Reisner 408902918be2SPhilipp Reisner rv = drbd_recv_header(mdev, &cmd, &length); 4090b411b363SPhilipp Reisner if (!rv) 4091b411b363SPhilipp Reisner goto fail; 4092b411b363SPhilipp Reisner 409302918be2SPhilipp Reisner if (cmd != P_AUTH_CHALLENGE) { 4094b411b363SPhilipp Reisner dev_err(DEV, "expected AuthChallenge packet, received: %s (0x%04x)\n", 409502918be2SPhilipp Reisner cmdname(cmd), cmd); 4096b411b363SPhilipp Reisner rv = 0; 4097b411b363SPhilipp Reisner goto fail; 4098b411b363SPhilipp Reisner } 4099b411b363SPhilipp Reisner 410002918be2SPhilipp Reisner if (length > CHALLENGE_LEN * 2) { 4101b411b363SPhilipp Reisner dev_err(DEV, "expected AuthChallenge payload too big.\n"); 4102b10d96cbSJohannes Thoma rv = -1; 4103b411b363SPhilipp Reisner goto fail; 4104b411b363SPhilipp Reisner } 4105b411b363SPhilipp Reisner 410602918be2SPhilipp Reisner peers_ch = kmalloc(length, GFP_NOIO); 4107b411b363SPhilipp Reisner if (peers_ch == NULL) { 4108b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of peers_ch failed\n"); 4109b10d96cbSJohannes Thoma rv = -1; 4110b411b363SPhilipp Reisner goto fail; 4111b411b363SPhilipp Reisner } 4112b411b363SPhilipp Reisner 411302918be2SPhilipp Reisner rv = drbd_recv(mdev, peers_ch, length); 4114b411b363SPhilipp Reisner 411502918be2SPhilipp Reisner if (rv != length) { 41160ddc5549SLars Ellenberg if (!signal_pending(current)) 41170ddc5549SLars Ellenberg dev_warn(DEV, "short read AuthChallenge: l=%u\n", rv); 4118b411b363SPhilipp Reisner rv = 0; 4119b411b363SPhilipp Reisner goto fail; 4120b411b363SPhilipp Reisner } 4121b411b363SPhilipp Reisner 4122a0638456SPhilipp Reisner resp_size = crypto_hash_digestsize(mdev->tconn->cram_hmac_tfm); 4123b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4124b411b363SPhilipp Reisner if (response == NULL) { 4125b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of response failed\n"); 4126b10d96cbSJohannes Thoma rv = -1; 4127b411b363SPhilipp Reisner goto fail; 4128b411b363SPhilipp Reisner } 4129b411b363SPhilipp Reisner 4130b411b363SPhilipp Reisner sg_init_table(&sg, 1); 413102918be2SPhilipp Reisner sg_set_buf(&sg, peers_ch, length); 4132b411b363SPhilipp Reisner 4133b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4134b411b363SPhilipp Reisner if (rv) { 4135b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv); 4136b10d96cbSJohannes Thoma rv = -1; 4137b411b363SPhilipp Reisner goto fail; 4138b411b363SPhilipp Reisner } 4139b411b363SPhilipp Reisner 4140b411b363SPhilipp Reisner rv = drbd_send_cmd2(mdev, P_AUTH_RESPONSE, response, resp_size); 4141b411b363SPhilipp Reisner if (!rv) 4142b411b363SPhilipp Reisner goto fail; 4143b411b363SPhilipp Reisner 414402918be2SPhilipp Reisner rv = drbd_recv_header(mdev, &cmd, &length); 4145b411b363SPhilipp Reisner if (!rv) 4146b411b363SPhilipp Reisner goto fail; 4147b411b363SPhilipp Reisner 414802918be2SPhilipp Reisner if (cmd != P_AUTH_RESPONSE) { 4149b411b363SPhilipp Reisner dev_err(DEV, "expected AuthResponse packet, received: %s (0x%04x)\n", 415002918be2SPhilipp Reisner cmdname(cmd), cmd); 4151b411b363SPhilipp Reisner rv = 0; 4152b411b363SPhilipp Reisner goto fail; 4153b411b363SPhilipp Reisner } 4154b411b363SPhilipp Reisner 415502918be2SPhilipp Reisner if (length != resp_size) { 4156b411b363SPhilipp Reisner dev_err(DEV, "expected AuthResponse payload of wrong size\n"); 4157b411b363SPhilipp Reisner rv = 0; 4158b411b363SPhilipp Reisner goto fail; 4159b411b363SPhilipp Reisner } 4160b411b363SPhilipp Reisner 4161b411b363SPhilipp Reisner rv = drbd_recv(mdev, response , resp_size); 4162b411b363SPhilipp Reisner 4163b411b363SPhilipp Reisner if (rv != resp_size) { 41640ddc5549SLars Ellenberg if (!signal_pending(current)) 41650ddc5549SLars Ellenberg dev_warn(DEV, "short read receiving AuthResponse: l=%u\n", rv); 4166b411b363SPhilipp Reisner rv = 0; 4167b411b363SPhilipp Reisner goto fail; 4168b411b363SPhilipp Reisner } 4169b411b363SPhilipp Reisner 4170b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 41712d1ee87dSJulia Lawall if (right_response == NULL) { 4172b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of right_response failed\n"); 4173b10d96cbSJohannes Thoma rv = -1; 4174b411b363SPhilipp Reisner goto fail; 4175b411b363SPhilipp Reisner } 4176b411b363SPhilipp Reisner 4177b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4178b411b363SPhilipp Reisner 4179b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4180b411b363SPhilipp Reisner if (rv) { 4181b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv); 4182b10d96cbSJohannes Thoma rv = -1; 4183b411b363SPhilipp Reisner goto fail; 4184b411b363SPhilipp Reisner } 4185b411b363SPhilipp Reisner 4186b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4187b411b363SPhilipp Reisner 4188b411b363SPhilipp Reisner if (rv) 4189b411b363SPhilipp Reisner dev_info(DEV, "Peer authenticated using %d bytes of '%s' HMAC\n", 419089e58e75SPhilipp Reisner resp_size, mdev->tconn->net_conf->cram_hmac_alg); 4191b10d96cbSJohannes Thoma else 4192b10d96cbSJohannes Thoma rv = -1; 4193b411b363SPhilipp Reisner 4194b411b363SPhilipp Reisner fail: 4195b411b363SPhilipp Reisner kfree(peers_ch); 4196b411b363SPhilipp Reisner kfree(response); 4197b411b363SPhilipp Reisner kfree(right_response); 4198b411b363SPhilipp Reisner 4199b411b363SPhilipp Reisner return rv; 4200b411b363SPhilipp Reisner } 4201b411b363SPhilipp Reisner #endif 4202b411b363SPhilipp Reisner 4203b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4204b411b363SPhilipp Reisner { 4205b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 4206b411b363SPhilipp Reisner unsigned int minor = mdev_to_minor(mdev); 4207b411b363SPhilipp Reisner int h; 4208b411b363SPhilipp Reisner 4209b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_receiver", minor); 4210b411b363SPhilipp Reisner 4211b411b363SPhilipp Reisner dev_info(DEV, "receiver (re)started\n"); 4212b411b363SPhilipp Reisner 4213b411b363SPhilipp Reisner do { 4214b411b363SPhilipp Reisner h = drbd_connect(mdev); 4215b411b363SPhilipp Reisner if (h == 0) { 4216b411b363SPhilipp Reisner drbd_disconnect(mdev); 421720ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4218b411b363SPhilipp Reisner } 4219b411b363SPhilipp Reisner if (h == -1) { 4220b411b363SPhilipp Reisner dev_warn(DEV, "Discarding network configuration.\n"); 4221b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 4222b411b363SPhilipp Reisner } 4223b411b363SPhilipp Reisner } while (h == 0); 4224b411b363SPhilipp Reisner 4225b411b363SPhilipp Reisner if (h > 0) { 4226b2fb6dbeSPhilipp Reisner if (get_net_conf(mdev->tconn)) { 4227b411b363SPhilipp Reisner drbdd(mdev); 4228b2fb6dbeSPhilipp Reisner put_net_conf(mdev->tconn); 4229b411b363SPhilipp Reisner } 4230b411b363SPhilipp Reisner } 4231b411b363SPhilipp Reisner 4232b411b363SPhilipp Reisner drbd_disconnect(mdev); 4233b411b363SPhilipp Reisner 4234b411b363SPhilipp Reisner dev_info(DEV, "receiver terminated\n"); 4235b411b363SPhilipp Reisner return 0; 4236b411b363SPhilipp Reisner } 4237b411b363SPhilipp Reisner 4238b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4239b411b363SPhilipp Reisner 4240d8763023SAndreas Gruenbacher static int got_RqSReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4241b411b363SPhilipp Reisner { 4242257d0af6SPhilipp Reisner struct p_req_state_reply *p = &mdev->tconn->meta.rbuf.req_state_reply; 4243b411b363SPhilipp Reisner 4244b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4245b411b363SPhilipp Reisner 4246b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4247b411b363SPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4248b411b363SPhilipp Reisner } else { 4249b411b363SPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4250b411b363SPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4251b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4252b411b363SPhilipp Reisner } 4253b411b363SPhilipp Reisner wake_up(&mdev->state_wait); 4254b411b363SPhilipp Reisner 425581e84650SAndreas Gruenbacher return true; 4256b411b363SPhilipp Reisner } 4257b411b363SPhilipp Reisner 4258d8763023SAndreas Gruenbacher static int got_Ping(struct drbd_conf *mdev, enum drbd_packet cmd) 4259b411b363SPhilipp Reisner { 4260b411b363SPhilipp Reisner return drbd_send_ping_ack(mdev); 4261b411b363SPhilipp Reisner 4262b411b363SPhilipp Reisner } 4263b411b363SPhilipp Reisner 4264d8763023SAndreas Gruenbacher static int got_PingAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4265b411b363SPhilipp Reisner { 4266b411b363SPhilipp Reisner /* restore idle timeout */ 4267e42325a5SPhilipp Reisner mdev->tconn->meta.socket->sk->sk_rcvtimeo = mdev->tconn->net_conf->ping_int*HZ; 4268309d1608SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &mdev->flags)) 4269309d1608SPhilipp Reisner wake_up(&mdev->misc_wait); 4270b411b363SPhilipp Reisner 427181e84650SAndreas Gruenbacher return true; 4272b411b363SPhilipp Reisner } 4273b411b363SPhilipp Reisner 4274d8763023SAndreas Gruenbacher static int got_IsInSync(struct drbd_conf *mdev, enum drbd_packet cmd) 4275b411b363SPhilipp Reisner { 4276257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4277b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4278b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4279b411b363SPhilipp Reisner 428031890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4281b411b363SPhilipp Reisner 4282b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4283b411b363SPhilipp Reisner 42841d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4285b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4286b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4287b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4288b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 42891d53f09eSLars Ellenberg put_ldev(mdev); 42901d53f09eSLars Ellenberg } 4291b411b363SPhilipp Reisner dec_rs_pending(mdev); 4292778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4293b411b363SPhilipp Reisner 429481e84650SAndreas Gruenbacher return true; 4295b411b363SPhilipp Reisner } 4296b411b363SPhilipp Reisner 4297bc9c5c41SAndreas Gruenbacher static int 4298bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4299bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4300bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4301b411b363SPhilipp Reisner { 4302b411b363SPhilipp Reisner struct drbd_request *req; 4303b411b363SPhilipp Reisner struct bio_and_error m; 4304b411b363SPhilipp Reisner 430587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4306bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4307b411b363SPhilipp Reisner if (unlikely(!req)) { 430887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 430981e84650SAndreas Gruenbacher return false; 4310b411b363SPhilipp Reisner } 4311b411b363SPhilipp Reisner __req_mod(req, what, &m); 431287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4313b411b363SPhilipp Reisner 4314b411b363SPhilipp Reisner if (m.bio) 4315b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 431681e84650SAndreas Gruenbacher return true; 4317b411b363SPhilipp Reisner } 4318b411b363SPhilipp Reisner 4319d8763023SAndreas Gruenbacher static int got_BlockAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4320b411b363SPhilipp Reisner { 4321257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4322b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4323b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4324b411b363SPhilipp Reisner enum drbd_req_event what; 4325b411b363SPhilipp Reisner 4326b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4327b411b363SPhilipp Reisner 4328579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4329b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4330b411b363SPhilipp Reisner dec_rs_pending(mdev); 433181e84650SAndreas Gruenbacher return true; 4332b411b363SPhilipp Reisner } 4333257d0af6SPhilipp Reisner switch (cmd) { 4334b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 433589e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 43368554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4337b411b363SPhilipp Reisner break; 4338b411b363SPhilipp Reisner case P_WRITE_ACK: 433989e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 43408554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4341b411b363SPhilipp Reisner break; 4342b411b363SPhilipp Reisner case P_RECV_ACK: 434389e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B); 43448554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4345b411b363SPhilipp Reisner break; 4346b411b363SPhilipp Reisner case P_DISCARD_ACK: 434789e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 43488554df1cSAndreas Gruenbacher what = CONFLICT_DISCARDED_BY_PEER; 4349b411b363SPhilipp Reisner break; 4350b411b363SPhilipp Reisner default: 4351b411b363SPhilipp Reisner D_ASSERT(0); 435281e84650SAndreas Gruenbacher return false; 4353b411b363SPhilipp Reisner } 4354b411b363SPhilipp Reisner 4355b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4356bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4357bc9c5c41SAndreas Gruenbacher what, false); 4358b411b363SPhilipp Reisner } 4359b411b363SPhilipp Reisner 4360d8763023SAndreas Gruenbacher static int got_NegAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4361b411b363SPhilipp Reisner { 4362257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4363b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 43642deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 436589e58e75SPhilipp Reisner bool missing_ok = mdev->tconn->net_conf->wire_protocol == DRBD_PROT_A || 436689e58e75SPhilipp Reisner mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B; 4367c3afd8f5SAndreas Gruenbacher bool found; 4368b411b363SPhilipp Reisner 4369b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4370b411b363SPhilipp Reisner 4371579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4372b411b363SPhilipp Reisner dec_rs_pending(mdev); 4373b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 437481e84650SAndreas Gruenbacher return true; 4375b411b363SPhilipp Reisner } 43762deb8336SPhilipp Reisner 4377c3afd8f5SAndreas Gruenbacher found = validate_req_change_req_state(mdev, p->block_id, sector, 4378bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 43798554df1cSAndreas Gruenbacher NEG_ACKED, missing_ok); 4380c3afd8f5SAndreas Gruenbacher if (!found) { 43812deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 43822deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4383c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 43842deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 43852deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4386c3afd8f5SAndreas Gruenbacher if (!missing_ok) 43872deb8336SPhilipp Reisner return false; 4388c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 43892deb8336SPhilipp Reisner } 43902deb8336SPhilipp Reisner return true; 4391b411b363SPhilipp Reisner } 4392b411b363SPhilipp Reisner 4393d8763023SAndreas Gruenbacher static int got_NegDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4394b411b363SPhilipp Reisner { 4395257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4396b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4397b411b363SPhilipp Reisner 4398b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4399b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4400b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4401b411b363SPhilipp Reisner 4402b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4403bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 44048554df1cSAndreas Gruenbacher NEG_ACKED, false); 4405b411b363SPhilipp Reisner } 4406b411b363SPhilipp Reisner 4407d8763023SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4408b411b363SPhilipp Reisner { 4409b411b363SPhilipp Reisner sector_t sector; 4410b411b363SPhilipp Reisner int size; 4411257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4412b411b363SPhilipp Reisner 4413b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4414b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4415b411b363SPhilipp Reisner 4416b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4417b411b363SPhilipp Reisner 4418b411b363SPhilipp Reisner dec_rs_pending(mdev); 4419b411b363SPhilipp Reisner 4420b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4421b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4422257d0af6SPhilipp Reisner switch (cmd) { 4423d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4424b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4425d612d309SPhilipp Reisner case P_RS_CANCEL: 4426d612d309SPhilipp Reisner break; 4427d612d309SPhilipp Reisner default: 4428d612d309SPhilipp Reisner D_ASSERT(0); 4429d612d309SPhilipp Reisner put_ldev(mdev); 4430d612d309SPhilipp Reisner return false; 4431d612d309SPhilipp Reisner } 4432b411b363SPhilipp Reisner put_ldev(mdev); 4433b411b363SPhilipp Reisner } 4434b411b363SPhilipp Reisner 443581e84650SAndreas Gruenbacher return true; 4436b411b363SPhilipp Reisner } 4437b411b363SPhilipp Reisner 4438d8763023SAndreas Gruenbacher static int got_BarrierAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4439b411b363SPhilipp Reisner { 4440257d0af6SPhilipp Reisner struct p_barrier_ack *p = &mdev->tconn->meta.rbuf.barrier_ack; 4441b411b363SPhilipp Reisner 4442b411b363SPhilipp Reisner tl_release(mdev, p->barrier, be32_to_cpu(p->set_size)); 4443b411b363SPhilipp Reisner 4444c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 4445c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 4446370a43e7SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) { 4447370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 4448370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 4449c4752ef1SPhilipp Reisner } 4450c4752ef1SPhilipp Reisner 445181e84650SAndreas Gruenbacher return true; 4452b411b363SPhilipp Reisner } 4453b411b363SPhilipp Reisner 4454d8763023SAndreas Gruenbacher static int got_OVResult(struct drbd_conf *mdev, enum drbd_packet cmd) 4455b411b363SPhilipp Reisner { 4456257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4457b411b363SPhilipp Reisner struct drbd_work *w; 4458b411b363SPhilipp Reisner sector_t sector; 4459b411b363SPhilipp Reisner int size; 4460b411b363SPhilipp Reisner 4461b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4462b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4463b411b363SPhilipp Reisner 4464b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4465b411b363SPhilipp Reisner 4466b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 4467b411b363SPhilipp Reisner drbd_ov_oos_found(mdev, sector, size); 4468b411b363SPhilipp Reisner else 4469b411b363SPhilipp Reisner ov_oos_print(mdev); 4470b411b363SPhilipp Reisner 44711d53f09eSLars Ellenberg if (!get_ldev(mdev)) 447281e84650SAndreas Gruenbacher return true; 44731d53f09eSLars Ellenberg 4474b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4475b411b363SPhilipp Reisner dec_rs_pending(mdev); 4476b411b363SPhilipp Reisner 4477ea5442afSLars Ellenberg --mdev->ov_left; 4478ea5442afSLars Ellenberg 4479ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 4480ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 4481ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 4482ea5442afSLars Ellenberg 4483ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 4484b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4485b411b363SPhilipp Reisner if (w) { 4486b411b363SPhilipp Reisner w->cb = w_ov_finished; 4487e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 4488b411b363SPhilipp Reisner } else { 4489b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 4490b411b363SPhilipp Reisner ov_oos_print(mdev); 4491b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4492b411b363SPhilipp Reisner } 4493b411b363SPhilipp Reisner } 44941d53f09eSLars Ellenberg put_ldev(mdev); 449581e84650SAndreas Gruenbacher return true; 4496b411b363SPhilipp Reisner } 4497b411b363SPhilipp Reisner 4498d8763023SAndreas Gruenbacher static int got_skip(struct drbd_conf *mdev, enum drbd_packet cmd) 44990ced55a3SPhilipp Reisner { 450081e84650SAndreas Gruenbacher return true; 45010ced55a3SPhilipp Reisner } 45020ced55a3SPhilipp Reisner 4503b411b363SPhilipp Reisner struct asender_cmd { 4504b411b363SPhilipp Reisner size_t pkt_size; 4505d8763023SAndreas Gruenbacher int (*process)(struct drbd_conf *mdev, enum drbd_packet cmd); 4506b411b363SPhilipp Reisner }; 4507b411b363SPhilipp Reisner 4508b411b363SPhilipp Reisner static struct asender_cmd *get_asender_cmd(int cmd) 4509b411b363SPhilipp Reisner { 4510b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 4511b411b363SPhilipp Reisner /* anything missing from this table is in 4512b411b363SPhilipp Reisner * the drbd_cmd_handler (drbd_default_handler) table, 4513b411b363SPhilipp Reisner * see the beginning of drbdd() */ 4514257d0af6SPhilipp Reisner [P_PING] = { sizeof(struct p_header), got_Ping }, 4515257d0af6SPhilipp Reisner [P_PING_ACK] = { sizeof(struct p_header), got_PingAck }, 4516b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4517b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4518b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4519b411b363SPhilipp Reisner [P_DISCARD_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4520b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 4521b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 4522b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply}, 4523b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 4524b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 4525b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 4526b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 452702918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 4528d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply}, 4529b411b363SPhilipp Reisner [P_MAX_CMD] = { 0, NULL }, 4530b411b363SPhilipp Reisner }; 4531b411b363SPhilipp Reisner if (cmd > P_MAX_CMD || asender_tbl[cmd].process == NULL) 4532b411b363SPhilipp Reisner return NULL; 4533b411b363SPhilipp Reisner return &asender_tbl[cmd]; 4534b411b363SPhilipp Reisner } 4535b411b363SPhilipp Reisner 4536b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4537b411b363SPhilipp Reisner { 4538b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 4539257d0af6SPhilipp Reisner struct p_header *h = &mdev->tconn->meta.rbuf.header; 4540b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 4541b411b363SPhilipp Reisner 4542257d0af6SPhilipp Reisner int rv; 4543b411b363SPhilipp Reisner void *buf = h; 4544b411b363SPhilipp Reisner int received = 0; 4545257d0af6SPhilipp Reisner int expect = sizeof(struct p_header); 4546f36af18cSLars Ellenberg int ping_timeout_active = 0; 4547257d0af6SPhilipp Reisner int empty, pkt_size; 4548d8763023SAndreas Gruenbacher enum drbd_packet cmd_nr; 4549b411b363SPhilipp Reisner 4550b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_asender", mdev_to_minor(mdev)); 4551b411b363SPhilipp Reisner 4552b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4553b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4554b411b363SPhilipp Reisner 4555e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 4556b411b363SPhilipp Reisner drbd_thread_current_set_cpu(mdev); 4557b411b363SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &mdev->flags)) { 4558841ce241SAndreas Gruenbacher if (!drbd_send_ping(mdev)) { 4559841ce241SAndreas Gruenbacher dev_err(DEV, "drbd_send_ping has failed\n"); 4560841ce241SAndreas Gruenbacher goto reconnect; 4561841ce241SAndreas Gruenbacher } 4562e42325a5SPhilipp Reisner mdev->tconn->meta.socket->sk->sk_rcvtimeo = 456389e58e75SPhilipp Reisner mdev->tconn->net_conf->ping_timeo*HZ/10; 4564f36af18cSLars Ellenberg ping_timeout_active = 1; 4565b411b363SPhilipp Reisner } 4566b411b363SPhilipp Reisner 4567b411b363SPhilipp Reisner /* conditionally cork; 4568b411b363SPhilipp Reisner * it may hurt latency if we cork without much to send */ 456989e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->no_cork && 4570b411b363SPhilipp Reisner 3 < atomic_read(&mdev->unacked_cnt)) 4571e42325a5SPhilipp Reisner drbd_tcp_cork(mdev->tconn->meta.socket); 4572b411b363SPhilipp Reisner while (1) { 4573b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4574b411b363SPhilipp Reisner flush_signals(current); 45750f8488e1SLars Ellenberg if (!drbd_process_done_ee(mdev)) 4576b411b363SPhilipp Reisner goto reconnect; 4577b411b363SPhilipp Reisner /* to avoid race with newly queued ACKs */ 4578b411b363SPhilipp Reisner set_bit(SIGNAL_ASENDER, &mdev->flags); 457987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4580b411b363SPhilipp Reisner empty = list_empty(&mdev->done_ee); 458187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4582b411b363SPhilipp Reisner /* new ack may have been queued right here, 4583b411b363SPhilipp Reisner * but then there is also a signal pending, 4584b411b363SPhilipp Reisner * and we start over... */ 4585b411b363SPhilipp Reisner if (empty) 4586b411b363SPhilipp Reisner break; 4587b411b363SPhilipp Reisner } 4588b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 458989e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->no_cork) 4590e42325a5SPhilipp Reisner drbd_tcp_uncork(mdev->tconn->meta.socket); 4591b411b363SPhilipp Reisner 4592b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4593b411b363SPhilipp Reisner if (signal_pending(current)) 4594b411b363SPhilipp Reisner continue; 4595b411b363SPhilipp Reisner 4596e42325a5SPhilipp Reisner rv = drbd_recv_short(mdev, mdev->tconn->meta.socket, 4597b411b363SPhilipp Reisner buf, expect-received, 0); 4598b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4599b411b363SPhilipp Reisner 4600b411b363SPhilipp Reisner flush_signals(current); 4601b411b363SPhilipp Reisner 4602b411b363SPhilipp Reisner /* Note: 4603b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4604b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4605b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4606b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4607b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4608b411b363SPhilipp Reisner * rv == expected: full header or command 4609b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4610b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4611b411b363SPhilipp Reisner */ 4612b411b363SPhilipp Reisner if (likely(rv > 0)) { 4613b411b363SPhilipp Reisner received += rv; 4614b411b363SPhilipp Reisner buf += rv; 4615b411b363SPhilipp Reisner } else if (rv == 0) { 4616b411b363SPhilipp Reisner dev_err(DEV, "meta connection shut down by peer.\n"); 4617b411b363SPhilipp Reisner goto reconnect; 4618b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4619cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 4620cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 462131890f4aSPhilipp Reisner if (time_after(mdev->tconn->last_received, 4622e42325a5SPhilipp Reisner jiffies - mdev->tconn->meta.socket->sk->sk_rcvtimeo)) 4623cb6518cbSLars Ellenberg continue; 4624f36af18cSLars Ellenberg if (ping_timeout_active) { 4625b411b363SPhilipp Reisner dev_err(DEV, "PingAck did not arrive in time.\n"); 4626b411b363SPhilipp Reisner goto reconnect; 4627b411b363SPhilipp Reisner } 4628b411b363SPhilipp Reisner set_bit(SEND_PING, &mdev->flags); 4629b411b363SPhilipp Reisner continue; 4630b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4631b411b363SPhilipp Reisner continue; 4632b411b363SPhilipp Reisner } else { 4633b411b363SPhilipp Reisner dev_err(DEV, "sock_recvmsg returned %d\n", rv); 4634b411b363SPhilipp Reisner goto reconnect; 4635b411b363SPhilipp Reisner } 4636b411b363SPhilipp Reisner 4637b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 4638257d0af6SPhilipp Reisner if (!decode_header(mdev, h, &cmd_nr, &pkt_size)) 4639b411b363SPhilipp Reisner goto reconnect; 4640257d0af6SPhilipp Reisner cmd = get_asender_cmd(cmd_nr); 4641b411b363SPhilipp Reisner if (unlikely(cmd == NULL)) { 4642257d0af6SPhilipp Reisner dev_err(DEV, "unknown command %d on meta (l: %d)\n", 4643257d0af6SPhilipp Reisner cmd_nr, pkt_size); 4644b411b363SPhilipp Reisner goto disconnect; 4645b411b363SPhilipp Reisner } 4646b411b363SPhilipp Reisner expect = cmd->pkt_size; 4647257d0af6SPhilipp Reisner if (pkt_size != expect - sizeof(struct p_header)) { 4648257d0af6SPhilipp Reisner dev_err(DEV, "Wrong packet size on meta (c: %d, l: %d)\n", 4649257d0af6SPhilipp Reisner cmd_nr, pkt_size); 4650b411b363SPhilipp Reisner goto reconnect; 4651b411b363SPhilipp Reisner } 4652257d0af6SPhilipp Reisner } 4653b411b363SPhilipp Reisner if (received == expect) { 465431890f4aSPhilipp Reisner mdev->tconn->last_received = jiffies; 4655b411b363SPhilipp Reisner D_ASSERT(cmd != NULL); 4656257d0af6SPhilipp Reisner if (!cmd->process(mdev, cmd_nr)) 4657b411b363SPhilipp Reisner goto reconnect; 4658b411b363SPhilipp Reisner 4659f36af18cSLars Ellenberg /* the idle_timeout (ping-int) 4660f36af18cSLars Ellenberg * has been restored in got_PingAck() */ 4661f36af18cSLars Ellenberg if (cmd == get_asender_cmd(P_PING_ACK)) 4662f36af18cSLars Ellenberg ping_timeout_active = 0; 4663f36af18cSLars Ellenberg 4664b411b363SPhilipp Reisner buf = h; 4665b411b363SPhilipp Reisner received = 0; 4666257d0af6SPhilipp Reisner expect = sizeof(struct p_header); 4667b411b363SPhilipp Reisner cmd = NULL; 4668b411b363SPhilipp Reisner } 4669b411b363SPhilipp Reisner } 4670b411b363SPhilipp Reisner 4671b411b363SPhilipp Reisner if (0) { 4672b411b363SPhilipp Reisner reconnect: 4673b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_NETWORK_FAILURE)); 4674856c50c7SLars Ellenberg drbd_md_sync(mdev); 4675b411b363SPhilipp Reisner } 4676b411b363SPhilipp Reisner if (0) { 4677b411b363SPhilipp Reisner disconnect: 4678b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 4679856c50c7SLars Ellenberg drbd_md_sync(mdev); 4680b411b363SPhilipp Reisner } 4681b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4682b411b363SPhilipp Reisner 4683b411b363SPhilipp Reisner D_ASSERT(mdev->state.conn < C_CONNECTED); 4684b411b363SPhilipp Reisner dev_info(DEV, "asender terminated\n"); 4685b411b363SPhilipp Reisner 4686b411b363SPhilipp Reisner return 0; 4687b411b363SPhilipp Reisner } 4688