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 213b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 214b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 215b411b363SPhilipp Reisner spin_unlock_irq(&mdev->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. */ 24045bb912bSLars Ellenberg if (atomic_read(&mdev->pp_in_use) < mdev->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 248b411b363SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->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. 27245bb912bSLars Ellenberg * Is also used from inside an other spin_lock_irq(&mdev->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 28045bb912bSLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_SEGMENT_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 322b411b363SPhilipp Reisner if (FAULT_ACTIVE(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 336b411b363SPhilipp Reisner INIT_HLIST_NODE(&e->colision); 337b411b363SPhilipp Reisner e->epoch = NULL; 33845bb912bSLars Ellenberg e->mdev = mdev; 33945bb912bSLars Ellenberg e->pages = page; 34045bb912bSLars Ellenberg atomic_set(&e->pending_bios, 0); 34145bb912bSLars Ellenberg e->size = data_size; 342b411b363SPhilipp Reisner e->flags = 0; 34345bb912bSLars Ellenberg e->sector = sector; 34445bb912bSLars Ellenberg e->block_id = id; 345b411b363SPhilipp Reisner 346b411b363SPhilipp Reisner return e; 347b411b363SPhilipp Reisner 34845bb912bSLars Ellenberg fail: 349b411b363SPhilipp Reisner mempool_free(e, drbd_ee_mempool); 350b411b363SPhilipp Reisner return NULL; 351b411b363SPhilipp Reisner } 352b411b363SPhilipp Reisner 353435f0740SLars Ellenberg void drbd_free_some_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e, int is_net) 354b411b363SPhilipp Reisner { 355c36c3cedSLars Ellenberg if (e->flags & EE_HAS_DIGEST) 356c36c3cedSLars Ellenberg kfree(e->digest); 357435f0740SLars Ellenberg drbd_pp_free(mdev, e->pages, is_net); 35845bb912bSLars Ellenberg D_ASSERT(atomic_read(&e->pending_bios) == 0); 359b411b363SPhilipp Reisner D_ASSERT(hlist_unhashed(&e->colision)); 360b411b363SPhilipp Reisner mempool_free(e, drbd_ee_mempool); 361b411b363SPhilipp Reisner } 362b411b363SPhilipp Reisner 363b411b363SPhilipp Reisner int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list) 364b411b363SPhilipp Reisner { 365b411b363SPhilipp Reisner LIST_HEAD(work_list); 366b411b363SPhilipp Reisner struct drbd_epoch_entry *e, *t; 367b411b363SPhilipp Reisner int count = 0; 368435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 369b411b363SPhilipp Reisner 370b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 371b411b363SPhilipp Reisner list_splice_init(list, &work_list); 372b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 373b411b363SPhilipp Reisner 374b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &work_list, w.list) { 375435f0740SLars Ellenberg drbd_free_some_ee(mdev, e, is_net); 376b411b363SPhilipp Reisner count++; 377b411b363SPhilipp Reisner } 378b411b363SPhilipp Reisner return count; 379b411b363SPhilipp Reisner } 380b411b363SPhilipp Reisner 381b411b363SPhilipp Reisner 382b411b363SPhilipp Reisner /* 383b411b363SPhilipp Reisner * This function is called from _asender only_ 384b411b363SPhilipp Reisner * but see also comments in _req_mod(,barrier_acked) 385b411b363SPhilipp Reisner * and receive_Barrier. 386b411b363SPhilipp Reisner * 387b411b363SPhilipp Reisner * Move entries from net_ee to done_ee, if ready. 388b411b363SPhilipp Reisner * Grab done_ee, call all callbacks, free the entries. 389b411b363SPhilipp Reisner * The callbacks typically send out ACKs. 390b411b363SPhilipp Reisner */ 391b411b363SPhilipp Reisner static int drbd_process_done_ee(struct drbd_conf *mdev) 392b411b363SPhilipp Reisner { 393b411b363SPhilipp Reisner LIST_HEAD(work_list); 394b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 395b411b363SPhilipp Reisner struct drbd_epoch_entry *e, *t; 396b411b363SPhilipp Reisner int ok = (mdev->state.conn >= C_WF_REPORT_PARAMS); 397b411b363SPhilipp Reisner 398b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 399b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 400b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 401b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 402b411b363SPhilipp Reisner 403b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &reclaimed, w.list) 404435f0740SLars Ellenberg drbd_free_net_ee(mdev, e); 405b411b363SPhilipp Reisner 406b411b363SPhilipp Reisner /* possible callbacks here: 407b411b363SPhilipp Reisner * e_end_block, and e_end_resync_block, e_send_discard_ack. 408b411b363SPhilipp Reisner * all ignore the last argument. 409b411b363SPhilipp Reisner */ 410b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &work_list, w.list) { 411b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 412b411b363SPhilipp Reisner ok = e->w.cb(mdev, &e->w, !ok) && ok; 413b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 414b411b363SPhilipp Reisner } 415b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 416b411b363SPhilipp Reisner 417b411b363SPhilipp Reisner return ok; 418b411b363SPhilipp Reisner } 419b411b363SPhilipp Reisner 420b411b363SPhilipp Reisner void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 421b411b363SPhilipp Reisner { 422b411b363SPhilipp Reisner DEFINE_WAIT(wait); 423b411b363SPhilipp Reisner 424b411b363SPhilipp Reisner /* avoids spin_lock/unlock 425b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 426b411b363SPhilipp Reisner while (!list_empty(head)) { 427b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 428b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 4297eaceaccSJens Axboe io_schedule(); 430b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 431b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 432b411b363SPhilipp Reisner } 433b411b363SPhilipp Reisner } 434b411b363SPhilipp Reisner 435b411b363SPhilipp Reisner void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 436b411b363SPhilipp Reisner { 437b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 438b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 439b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 440b411b363SPhilipp Reisner } 441b411b363SPhilipp Reisner 442b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 443b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 444b411b363SPhilipp Reisner static int drbd_accept(struct drbd_conf *mdev, const char **what, 445b411b363SPhilipp Reisner struct socket *sock, struct socket **newsock) 446b411b363SPhilipp Reisner { 447b411b363SPhilipp Reisner struct sock *sk = sock->sk; 448b411b363SPhilipp Reisner int err = 0; 449b411b363SPhilipp Reisner 450b411b363SPhilipp Reisner *what = "listen"; 451b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 452b411b363SPhilipp Reisner if (err < 0) 453b411b363SPhilipp Reisner goto out; 454b411b363SPhilipp Reisner 455b411b363SPhilipp Reisner *what = "sock_create_lite"; 456b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 457b411b363SPhilipp Reisner newsock); 458b411b363SPhilipp Reisner if (err < 0) 459b411b363SPhilipp Reisner goto out; 460b411b363SPhilipp Reisner 461b411b363SPhilipp Reisner *what = "accept"; 462b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 463b411b363SPhilipp Reisner if (err < 0) { 464b411b363SPhilipp Reisner sock_release(*newsock); 465b411b363SPhilipp Reisner *newsock = NULL; 466b411b363SPhilipp Reisner goto out; 467b411b363SPhilipp Reisner } 468b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 469b411b363SPhilipp Reisner 470b411b363SPhilipp Reisner out: 471b411b363SPhilipp Reisner return err; 472b411b363SPhilipp Reisner } 473b411b363SPhilipp Reisner 474b411b363SPhilipp Reisner static int drbd_recv_short(struct drbd_conf *mdev, struct socket *sock, 475b411b363SPhilipp Reisner void *buf, size_t size, int flags) 476b411b363SPhilipp Reisner { 477b411b363SPhilipp Reisner mm_segment_t oldfs; 478b411b363SPhilipp Reisner struct kvec iov = { 479b411b363SPhilipp Reisner .iov_base = buf, 480b411b363SPhilipp Reisner .iov_len = size, 481b411b363SPhilipp Reisner }; 482b411b363SPhilipp Reisner struct msghdr msg = { 483b411b363SPhilipp Reisner .msg_iovlen = 1, 484b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 485b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 486b411b363SPhilipp Reisner }; 487b411b363SPhilipp Reisner int rv; 488b411b363SPhilipp Reisner 489b411b363SPhilipp Reisner oldfs = get_fs(); 490b411b363SPhilipp Reisner set_fs(KERNEL_DS); 491b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 492b411b363SPhilipp Reisner set_fs(oldfs); 493b411b363SPhilipp Reisner 494b411b363SPhilipp Reisner return rv; 495b411b363SPhilipp Reisner } 496b411b363SPhilipp Reisner 497b411b363SPhilipp Reisner static int drbd_recv(struct drbd_conf *mdev, void *buf, size_t size) 498b411b363SPhilipp Reisner { 499b411b363SPhilipp Reisner mm_segment_t oldfs; 500b411b363SPhilipp Reisner struct kvec iov = { 501b411b363SPhilipp Reisner .iov_base = buf, 502b411b363SPhilipp Reisner .iov_len = size, 503b411b363SPhilipp Reisner }; 504b411b363SPhilipp Reisner struct msghdr msg = { 505b411b363SPhilipp Reisner .msg_iovlen = 1, 506b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 507b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 508b411b363SPhilipp Reisner }; 509b411b363SPhilipp Reisner int rv; 510b411b363SPhilipp Reisner 511b411b363SPhilipp Reisner oldfs = get_fs(); 512b411b363SPhilipp Reisner set_fs(KERNEL_DS); 513b411b363SPhilipp Reisner 514b411b363SPhilipp Reisner for (;;) { 515b411b363SPhilipp Reisner rv = sock_recvmsg(mdev->data.socket, &msg, size, msg.msg_flags); 516b411b363SPhilipp Reisner if (rv == size) 517b411b363SPhilipp Reisner break; 518b411b363SPhilipp Reisner 519b411b363SPhilipp Reisner /* Note: 520b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 521b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 522b411b363SPhilipp Reisner */ 523b411b363SPhilipp Reisner 524b411b363SPhilipp Reisner if (rv < 0) { 525b411b363SPhilipp Reisner if (rv == -ECONNRESET) 526b411b363SPhilipp Reisner dev_info(DEV, "sock was reset by peer\n"); 527b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 528b411b363SPhilipp Reisner dev_err(DEV, "sock_recvmsg returned %d\n", rv); 529b411b363SPhilipp Reisner break; 530b411b363SPhilipp Reisner } else if (rv == 0) { 531b411b363SPhilipp Reisner dev_info(DEV, "sock was shut down by peer\n"); 532b411b363SPhilipp Reisner break; 533b411b363SPhilipp Reisner } else { 534b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 535b411b363SPhilipp Reisner * after we read a partial message 536b411b363SPhilipp Reisner */ 537b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 538b411b363SPhilipp Reisner break; 539b411b363SPhilipp Reisner } 540b411b363SPhilipp Reisner }; 541b411b363SPhilipp Reisner 542b411b363SPhilipp Reisner set_fs(oldfs); 543b411b363SPhilipp Reisner 544b411b363SPhilipp Reisner if (rv != size) 545b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_BROKEN_PIPE)); 546b411b363SPhilipp Reisner 547b411b363SPhilipp Reisner return rv; 548b411b363SPhilipp Reisner } 549b411b363SPhilipp Reisner 5505dbf1673SLars Ellenberg /* quoting tcp(7): 5515dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5525dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5535dbf1673SLars Ellenberg * This is our wrapper to do so. 5545dbf1673SLars Ellenberg */ 5555dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5565dbf1673SLars Ellenberg unsigned int rcv) 5575dbf1673SLars Ellenberg { 5585dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5595dbf1673SLars Ellenberg if (snd) { 5605dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5615dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5625dbf1673SLars Ellenberg } 5635dbf1673SLars Ellenberg if (rcv) { 5645dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5655dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5665dbf1673SLars Ellenberg } 5675dbf1673SLars Ellenberg } 5685dbf1673SLars Ellenberg 569b411b363SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_conf *mdev) 570b411b363SPhilipp Reisner { 571b411b363SPhilipp Reisner const char *what; 572b411b363SPhilipp Reisner struct socket *sock; 573b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 574b411b363SPhilipp Reisner int err; 575b411b363SPhilipp Reisner int disconnect_on_error = 1; 576b411b363SPhilipp Reisner 577b411b363SPhilipp Reisner if (!get_net_conf(mdev)) 578b411b363SPhilipp Reisner return NULL; 579b411b363SPhilipp Reisner 580b411b363SPhilipp Reisner what = "sock_create_kern"; 581b411b363SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)mdev->net_conf->my_addr)->sa_family, 582b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 583b411b363SPhilipp Reisner if (err < 0) { 584b411b363SPhilipp Reisner sock = NULL; 585b411b363SPhilipp Reisner goto out; 586b411b363SPhilipp Reisner } 587b411b363SPhilipp Reisner 588b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 589b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = mdev->net_conf->try_connect_int*HZ; 5905dbf1673SLars Ellenberg drbd_setbufsize(sock, mdev->net_conf->sndbuf_size, 5915dbf1673SLars Ellenberg mdev->net_conf->rcvbuf_size); 592b411b363SPhilipp Reisner 593b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 594b411b363SPhilipp Reisner * for the outgoing connections. 595b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 596b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 597b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 598b411b363SPhilipp Reisner * a free one dynamically. 599b411b363SPhilipp Reisner */ 600b411b363SPhilipp Reisner memcpy(&src_in6, mdev->net_conf->my_addr, 601b411b363SPhilipp Reisner min_t(int, mdev->net_conf->my_addr_len, sizeof(src_in6))); 602b411b363SPhilipp Reisner if (((struct sockaddr *)mdev->net_conf->my_addr)->sa_family == AF_INET6) 603b411b363SPhilipp Reisner src_in6.sin6_port = 0; 604b411b363SPhilipp Reisner else 605b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 606b411b363SPhilipp Reisner 607b411b363SPhilipp Reisner what = "bind before connect"; 608b411b363SPhilipp Reisner err = sock->ops->bind(sock, 609b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 610b411b363SPhilipp Reisner mdev->net_conf->my_addr_len); 611b411b363SPhilipp Reisner if (err < 0) 612b411b363SPhilipp Reisner goto out; 613b411b363SPhilipp Reisner 614b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 615b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 616b411b363SPhilipp Reisner disconnect_on_error = 0; 617b411b363SPhilipp Reisner what = "connect"; 618b411b363SPhilipp Reisner err = sock->ops->connect(sock, 619b411b363SPhilipp Reisner (struct sockaddr *)mdev->net_conf->peer_addr, 620b411b363SPhilipp Reisner mdev->net_conf->peer_addr_len, 0); 621b411b363SPhilipp Reisner 622b411b363SPhilipp Reisner out: 623b411b363SPhilipp Reisner if (err < 0) { 624b411b363SPhilipp Reisner if (sock) { 625b411b363SPhilipp Reisner sock_release(sock); 626b411b363SPhilipp Reisner sock = NULL; 627b411b363SPhilipp Reisner } 628b411b363SPhilipp Reisner switch (-err) { 629b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 630b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 631b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 632b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 633b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 634b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 635b411b363SPhilipp Reisner disconnect_on_error = 0; 636b411b363SPhilipp Reisner break; 637b411b363SPhilipp Reisner default: 638b411b363SPhilipp Reisner dev_err(DEV, "%s failed, err = %d\n", what, err); 639b411b363SPhilipp Reisner } 640b411b363SPhilipp Reisner if (disconnect_on_error) 641b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 642b411b363SPhilipp Reisner } 643b411b363SPhilipp Reisner put_net_conf(mdev); 644b411b363SPhilipp Reisner return sock; 645b411b363SPhilipp Reisner } 646b411b363SPhilipp Reisner 647b411b363SPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_conf *mdev) 648b411b363SPhilipp Reisner { 649b411b363SPhilipp Reisner int timeo, err; 650b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 651b411b363SPhilipp Reisner const char *what; 652b411b363SPhilipp Reisner 653b411b363SPhilipp Reisner if (!get_net_conf(mdev)) 654b411b363SPhilipp Reisner return NULL; 655b411b363SPhilipp Reisner 656b411b363SPhilipp Reisner what = "sock_create_kern"; 657b411b363SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)mdev->net_conf->my_addr)->sa_family, 658b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 659b411b363SPhilipp Reisner if (err) { 660b411b363SPhilipp Reisner s_listen = NULL; 661b411b363SPhilipp Reisner goto out; 662b411b363SPhilipp Reisner } 663b411b363SPhilipp Reisner 664b411b363SPhilipp Reisner timeo = mdev->net_conf->try_connect_int * HZ; 665b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 666b411b363SPhilipp Reisner 667b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 668b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 669b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 6705dbf1673SLars Ellenberg drbd_setbufsize(s_listen, mdev->net_conf->sndbuf_size, 6715dbf1673SLars Ellenberg mdev->net_conf->rcvbuf_size); 672b411b363SPhilipp Reisner 673b411b363SPhilipp Reisner what = "bind before listen"; 674b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 675b411b363SPhilipp Reisner (struct sockaddr *) mdev->net_conf->my_addr, 676b411b363SPhilipp Reisner mdev->net_conf->my_addr_len); 677b411b363SPhilipp Reisner if (err < 0) 678b411b363SPhilipp Reisner goto out; 679b411b363SPhilipp Reisner 680b411b363SPhilipp Reisner err = drbd_accept(mdev, &what, s_listen, &s_estab); 681b411b363SPhilipp Reisner 682b411b363SPhilipp Reisner out: 683b411b363SPhilipp Reisner if (s_listen) 684b411b363SPhilipp Reisner sock_release(s_listen); 685b411b363SPhilipp Reisner if (err < 0) { 686b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 687b411b363SPhilipp Reisner dev_err(DEV, "%s failed, err = %d\n", what, err); 688b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 689b411b363SPhilipp Reisner } 690b411b363SPhilipp Reisner } 691b411b363SPhilipp Reisner put_net_conf(mdev); 692b411b363SPhilipp Reisner 693b411b363SPhilipp Reisner return s_estab; 694b411b363SPhilipp Reisner } 695b411b363SPhilipp Reisner 696b411b363SPhilipp Reisner static int drbd_send_fp(struct drbd_conf *mdev, 697b411b363SPhilipp Reisner struct socket *sock, enum drbd_packets cmd) 698b411b363SPhilipp Reisner { 69902918be2SPhilipp Reisner struct p_header80 *h = &mdev->data.sbuf.header.h80; 700b411b363SPhilipp Reisner 701b411b363SPhilipp Reisner return _drbd_send_cmd(mdev, sock, cmd, h, sizeof(*h), 0); 702b411b363SPhilipp Reisner } 703b411b363SPhilipp Reisner 704b411b363SPhilipp Reisner static enum drbd_packets drbd_recv_fp(struct drbd_conf *mdev, struct socket *sock) 705b411b363SPhilipp Reisner { 70602918be2SPhilipp Reisner struct p_header80 *h = &mdev->data.rbuf.header.h80; 707b411b363SPhilipp Reisner int rr; 708b411b363SPhilipp Reisner 709b411b363SPhilipp Reisner rr = drbd_recv_short(mdev, sock, h, sizeof(*h), 0); 710b411b363SPhilipp Reisner 711b411b363SPhilipp Reisner if (rr == sizeof(*h) && h->magic == BE_DRBD_MAGIC) 712b411b363SPhilipp Reisner return be16_to_cpu(h->command); 713b411b363SPhilipp Reisner 714b411b363SPhilipp Reisner return 0xffff; 715b411b363SPhilipp Reisner } 716b411b363SPhilipp Reisner 717b411b363SPhilipp Reisner /** 718b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 719b411b363SPhilipp Reisner * @mdev: DRBD device. 720b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 721b411b363SPhilipp Reisner */ 722b411b363SPhilipp Reisner static int drbd_socket_okay(struct drbd_conf *mdev, struct socket **sock) 723b411b363SPhilipp Reisner { 724b411b363SPhilipp Reisner int rr; 725b411b363SPhilipp Reisner char tb[4]; 726b411b363SPhilipp Reisner 727b411b363SPhilipp Reisner if (!*sock) 728b411b363SPhilipp Reisner return FALSE; 729b411b363SPhilipp Reisner 730b411b363SPhilipp Reisner rr = drbd_recv_short(mdev, *sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 731b411b363SPhilipp Reisner 732b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 733b411b363SPhilipp Reisner return TRUE; 734b411b363SPhilipp Reisner } else { 735b411b363SPhilipp Reisner sock_release(*sock); 736b411b363SPhilipp Reisner *sock = NULL; 737b411b363SPhilipp Reisner return FALSE; 738b411b363SPhilipp Reisner } 739b411b363SPhilipp Reisner } 740b411b363SPhilipp Reisner 741b411b363SPhilipp Reisner /* 742b411b363SPhilipp Reisner * return values: 743b411b363SPhilipp Reisner * 1 yes, we have a valid connection 744b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 745b411b363SPhilipp Reisner * -1 peer talks different language, 746b411b363SPhilipp Reisner * no point in trying again, please go standalone. 747b411b363SPhilipp Reisner * -2 We do not have a network config... 748b411b363SPhilipp Reisner */ 749b411b363SPhilipp Reisner static int drbd_connect(struct drbd_conf *mdev) 750b411b363SPhilipp Reisner { 751b411b363SPhilipp Reisner struct socket *s, *sock, *msock; 752b411b363SPhilipp Reisner int try, h, ok; 753b411b363SPhilipp Reisner 754b411b363SPhilipp Reisner D_ASSERT(!mdev->data.socket); 755b411b363SPhilipp Reisner 756b411b363SPhilipp Reisner if (drbd_request_state(mdev, NS(conn, C_WF_CONNECTION)) < SS_SUCCESS) 757b411b363SPhilipp Reisner return -2; 758b411b363SPhilipp Reisner 759b411b363SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &mdev->flags); 760b411b363SPhilipp Reisner 761b411b363SPhilipp Reisner sock = NULL; 762b411b363SPhilipp Reisner msock = NULL; 763b411b363SPhilipp Reisner 764b411b363SPhilipp Reisner do { 765b411b363SPhilipp Reisner for (try = 0;;) { 766b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 767b411b363SPhilipp Reisner s = drbd_try_connect(mdev); 768b411b363SPhilipp Reisner if (s || ++try >= 3) 769b411b363SPhilipp Reisner break; 770b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 771b411b363SPhilipp Reisner __set_current_state(TASK_INTERRUPTIBLE); 772b411b363SPhilipp Reisner schedule_timeout(HZ / 10); 773b411b363SPhilipp Reisner } 774b411b363SPhilipp Reisner 775b411b363SPhilipp Reisner if (s) { 776b411b363SPhilipp Reisner if (!sock) { 777b411b363SPhilipp Reisner drbd_send_fp(mdev, s, P_HAND_SHAKE_S); 778b411b363SPhilipp Reisner sock = s; 779b411b363SPhilipp Reisner s = NULL; 780b411b363SPhilipp Reisner } else if (!msock) { 781b411b363SPhilipp Reisner drbd_send_fp(mdev, s, P_HAND_SHAKE_M); 782b411b363SPhilipp Reisner msock = s; 783b411b363SPhilipp Reisner s = NULL; 784b411b363SPhilipp Reisner } else { 785b411b363SPhilipp Reisner dev_err(DEV, "Logic error in drbd_connect()\n"); 786b411b363SPhilipp Reisner goto out_release_sockets; 787b411b363SPhilipp Reisner } 788b411b363SPhilipp Reisner } 789b411b363SPhilipp Reisner 790b411b363SPhilipp Reisner if (sock && msock) { 791b411b363SPhilipp Reisner __set_current_state(TASK_INTERRUPTIBLE); 792b411b363SPhilipp Reisner schedule_timeout(HZ / 10); 793b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &sock); 794b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &msock) && ok; 795b411b363SPhilipp Reisner if (ok) 796b411b363SPhilipp Reisner break; 797b411b363SPhilipp Reisner } 798b411b363SPhilipp Reisner 799b411b363SPhilipp Reisner retry: 800b411b363SPhilipp Reisner s = drbd_wait_for_connect(mdev); 801b411b363SPhilipp Reisner if (s) { 802b411b363SPhilipp Reisner try = drbd_recv_fp(mdev, s); 803b411b363SPhilipp Reisner drbd_socket_okay(mdev, &sock); 804b411b363SPhilipp Reisner drbd_socket_okay(mdev, &msock); 805b411b363SPhilipp Reisner switch (try) { 806b411b363SPhilipp Reisner case P_HAND_SHAKE_S: 807b411b363SPhilipp Reisner if (sock) { 808b411b363SPhilipp Reisner dev_warn(DEV, "initial packet S crossed\n"); 809b411b363SPhilipp Reisner sock_release(sock); 810b411b363SPhilipp Reisner } 811b411b363SPhilipp Reisner sock = s; 812b411b363SPhilipp Reisner break; 813b411b363SPhilipp Reisner case P_HAND_SHAKE_M: 814b411b363SPhilipp Reisner if (msock) { 815b411b363SPhilipp Reisner dev_warn(DEV, "initial packet M crossed\n"); 816b411b363SPhilipp Reisner sock_release(msock); 817b411b363SPhilipp Reisner } 818b411b363SPhilipp Reisner msock = s; 819b411b363SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &mdev->flags); 820b411b363SPhilipp Reisner break; 821b411b363SPhilipp Reisner default: 822b411b363SPhilipp Reisner dev_warn(DEV, "Error receiving initial packet\n"); 823b411b363SPhilipp Reisner sock_release(s); 824b411b363SPhilipp Reisner if (random32() & 1) 825b411b363SPhilipp Reisner goto retry; 826b411b363SPhilipp Reisner } 827b411b363SPhilipp Reisner } 828b411b363SPhilipp Reisner 829b411b363SPhilipp Reisner if (mdev->state.conn <= C_DISCONNECTING) 830b411b363SPhilipp Reisner goto out_release_sockets; 831b411b363SPhilipp Reisner if (signal_pending(current)) { 832b411b363SPhilipp Reisner flush_signals(current); 833b411b363SPhilipp Reisner smp_rmb(); 834b411b363SPhilipp Reisner if (get_t_state(&mdev->receiver) == Exiting) 835b411b363SPhilipp Reisner goto out_release_sockets; 836b411b363SPhilipp Reisner } 837b411b363SPhilipp Reisner 838b411b363SPhilipp Reisner if (sock && msock) { 839b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &sock); 840b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &msock) && ok; 841b411b363SPhilipp Reisner if (ok) 842b411b363SPhilipp Reisner break; 843b411b363SPhilipp Reisner } 844b411b363SPhilipp Reisner } while (1); 845b411b363SPhilipp Reisner 846b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 847b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 848b411b363SPhilipp Reisner 849b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 850b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 851b411b363SPhilipp Reisner 852b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 853b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 854b411b363SPhilipp Reisner 855b411b363SPhilipp Reisner /* NOT YET ... 856b411b363SPhilipp Reisner * sock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10; 857b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 858b411b363SPhilipp Reisner * first set it to the P_HAND_SHAKE timeout, 859b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 860b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 861b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = mdev->net_conf->ping_timeo*4*HZ/10; 862b411b363SPhilipp Reisner 863b411b363SPhilipp Reisner msock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10; 864b411b363SPhilipp Reisner msock->sk->sk_rcvtimeo = mdev->net_conf->ping_int*HZ; 865b411b363SPhilipp Reisner 866b411b363SPhilipp Reisner /* we don't want delays. 867b411b363SPhilipp Reisner * we use TCP_CORK where apropriate, though */ 868b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 869b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 870b411b363SPhilipp Reisner 871b411b363SPhilipp Reisner mdev->data.socket = sock; 872b411b363SPhilipp Reisner mdev->meta.socket = msock; 873b411b363SPhilipp Reisner mdev->last_received = jiffies; 874b411b363SPhilipp Reisner 875b411b363SPhilipp Reisner D_ASSERT(mdev->asender.task == NULL); 876b411b363SPhilipp Reisner 877b411b363SPhilipp Reisner h = drbd_do_handshake(mdev); 878b411b363SPhilipp Reisner if (h <= 0) 879b411b363SPhilipp Reisner return h; 880b411b363SPhilipp Reisner 881b411b363SPhilipp Reisner if (mdev->cram_hmac_tfm) { 882b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 883b10d96cbSJohannes Thoma switch (drbd_do_auth(mdev)) { 884b10d96cbSJohannes Thoma case -1: 885b411b363SPhilipp Reisner dev_err(DEV, "Authentication of peer failed\n"); 886b411b363SPhilipp Reisner return -1; 887b10d96cbSJohannes Thoma case 0: 888b10d96cbSJohannes Thoma dev_err(DEV, "Authentication of peer failed, trying again.\n"); 889b10d96cbSJohannes Thoma return 0; 890b411b363SPhilipp Reisner } 891b411b363SPhilipp Reisner } 892b411b363SPhilipp Reisner 893b411b363SPhilipp Reisner if (drbd_request_state(mdev, NS(conn, C_WF_REPORT_PARAMS)) < SS_SUCCESS) 894b411b363SPhilipp Reisner return 0; 895b411b363SPhilipp Reisner 896b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10; 897b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 898b411b363SPhilipp Reisner 899b411b363SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 900b411b363SPhilipp Reisner mdev->peer_seq = 0; 901b411b363SPhilipp Reisner 902b411b363SPhilipp Reisner drbd_thread_start(&mdev->asender); 903b411b363SPhilipp Reisner 904d5373389SPhilipp Reisner if (mdev->agreed_pro_version < 95 && get_ldev(mdev)) { 905d5373389SPhilipp Reisner drbd_setup_queue_param(mdev, DRBD_MAX_SIZE_H80_PACKET); 906d5373389SPhilipp Reisner put_ldev(mdev); 907d5373389SPhilipp Reisner } 908d5373389SPhilipp Reisner 9097e2455c1SPhilipp Reisner if (!drbd_send_protocol(mdev)) 9107e2455c1SPhilipp Reisner return -1; 911b411b363SPhilipp Reisner drbd_send_sync_param(mdev, &mdev->sync_conf); 912e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, 0); 913b411b363SPhilipp Reisner drbd_send_uuids(mdev); 914b411b363SPhilipp Reisner drbd_send_state(mdev); 915b411b363SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 916b411b363SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 917b411b363SPhilipp Reisner 918b411b363SPhilipp Reisner return 1; 919b411b363SPhilipp Reisner 920b411b363SPhilipp Reisner out_release_sockets: 921b411b363SPhilipp Reisner if (sock) 922b411b363SPhilipp Reisner sock_release(sock); 923b411b363SPhilipp Reisner if (msock) 924b411b363SPhilipp Reisner sock_release(msock); 925b411b363SPhilipp Reisner return -1; 926b411b363SPhilipp Reisner } 927b411b363SPhilipp Reisner 92802918be2SPhilipp Reisner static int drbd_recv_header(struct drbd_conf *mdev, enum drbd_packets *cmd, unsigned int *packet_size) 929b411b363SPhilipp Reisner { 93002918be2SPhilipp Reisner union p_header *h = &mdev->data.rbuf.header; 931b411b363SPhilipp Reisner int r; 932b411b363SPhilipp Reisner 933b411b363SPhilipp Reisner r = drbd_recv(mdev, h, sizeof(*h)); 934b411b363SPhilipp Reisner if (unlikely(r != sizeof(*h))) { 935b411b363SPhilipp Reisner dev_err(DEV, "short read expecting header on sock: r=%d\n", r); 936b411b363SPhilipp Reisner return FALSE; 93702918be2SPhilipp Reisner } 93802918be2SPhilipp Reisner 93902918be2SPhilipp Reisner if (likely(h->h80.magic == BE_DRBD_MAGIC)) { 94002918be2SPhilipp Reisner *cmd = be16_to_cpu(h->h80.command); 94102918be2SPhilipp Reisner *packet_size = be16_to_cpu(h->h80.length); 94202918be2SPhilipp Reisner } else if (h->h95.magic == BE_DRBD_MAGIC_BIG) { 94302918be2SPhilipp Reisner *cmd = be16_to_cpu(h->h95.command); 94402918be2SPhilipp Reisner *packet_size = be32_to_cpu(h->h95.length); 94502918be2SPhilipp Reisner } else { 946004352faSLars Ellenberg dev_err(DEV, "magic?? on data m: 0x%08x c: %d l: %d\n", 947004352faSLars Ellenberg be32_to_cpu(h->h80.magic), 948004352faSLars Ellenberg be16_to_cpu(h->h80.command), 949004352faSLars Ellenberg be16_to_cpu(h->h80.length)); 950b411b363SPhilipp Reisner return FALSE; 951b411b363SPhilipp Reisner } 952b411b363SPhilipp Reisner mdev->last_received = jiffies; 953b411b363SPhilipp Reisner 954b411b363SPhilipp Reisner return TRUE; 955b411b363SPhilipp Reisner } 956b411b363SPhilipp Reisner 9572451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 958b411b363SPhilipp Reisner { 959b411b363SPhilipp Reisner int rv; 960b411b363SPhilipp Reisner 961b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 962fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 963dd3932edSChristoph Hellwig NULL); 964b411b363SPhilipp Reisner if (rv) { 965b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 966b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 967b411b363SPhilipp Reisner * don't try again for ANY return value != 0 968b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 969b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 970b411b363SPhilipp Reisner } 971b411b363SPhilipp Reisner put_ldev(mdev); 972b411b363SPhilipp Reisner } 973b411b363SPhilipp Reisner } 974b411b363SPhilipp Reisner 975b411b363SPhilipp Reisner /** 976b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 977b411b363SPhilipp Reisner * @mdev: DRBD device. 978b411b363SPhilipp Reisner * @epoch: Epoch object. 979b411b363SPhilipp Reisner * @ev: Epoch event. 980b411b363SPhilipp Reisner */ 981b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 982b411b363SPhilipp Reisner struct drbd_epoch *epoch, 983b411b363SPhilipp Reisner enum epoch_event ev) 984b411b363SPhilipp Reisner { 9852451fc3bSPhilipp Reisner int epoch_size; 986b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 987b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 988b411b363SPhilipp Reisner 989b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 990b411b363SPhilipp Reisner do { 991b411b363SPhilipp Reisner next_epoch = NULL; 992b411b363SPhilipp Reisner 993b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 994b411b363SPhilipp Reisner 995b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 996b411b363SPhilipp Reisner case EV_PUT: 997b411b363SPhilipp Reisner atomic_dec(&epoch->active); 998b411b363SPhilipp Reisner break; 999b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1000b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1001b411b363SPhilipp Reisner break; 1002b411b363SPhilipp Reisner case EV_BECAME_LAST: 1003b411b363SPhilipp Reisner /* nothing to do*/ 1004b411b363SPhilipp Reisner break; 1005b411b363SPhilipp Reisner } 1006b411b363SPhilipp Reisner 1007b411b363SPhilipp Reisner if (epoch_size != 0 && 1008b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 10092451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1010b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1011b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1012b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1013b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1014b411b363SPhilipp Reisner } 1015b411b363SPhilipp Reisner dec_unacked(mdev); 1016b411b363SPhilipp Reisner 1017b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1018b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1019b411b363SPhilipp Reisner list_del(&epoch->list); 1020b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1021b411b363SPhilipp Reisner mdev->epochs--; 1022b411b363SPhilipp Reisner kfree(epoch); 1023b411b363SPhilipp Reisner 1024b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1025b411b363SPhilipp Reisner rv = FE_DESTROYED; 1026b411b363SPhilipp Reisner } else { 1027b411b363SPhilipp Reisner epoch->flags = 0; 1028b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1029698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1030b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1031b411b363SPhilipp Reisner rv = FE_RECYCLED; 10322451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1033b411b363SPhilipp Reisner } 1034b411b363SPhilipp Reisner } 1035b411b363SPhilipp Reisner 1036b411b363SPhilipp Reisner if (!next_epoch) 1037b411b363SPhilipp Reisner break; 1038b411b363SPhilipp Reisner 1039b411b363SPhilipp Reisner epoch = next_epoch; 1040b411b363SPhilipp Reisner } while (1); 1041b411b363SPhilipp Reisner 1042b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1043b411b363SPhilipp Reisner 1044b411b363SPhilipp Reisner return rv; 1045b411b363SPhilipp Reisner } 1046b411b363SPhilipp Reisner 1047b411b363SPhilipp Reisner /** 1048b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1049b411b363SPhilipp Reisner * @mdev: DRBD device. 1050b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1051b411b363SPhilipp Reisner */ 1052b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1053b411b363SPhilipp Reisner { 1054b411b363SPhilipp Reisner enum write_ordering_e pwo; 1055b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1056b411b363SPhilipp Reisner [WO_none] = "none", 1057b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1058b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1059b411b363SPhilipp Reisner }; 1060b411b363SPhilipp Reisner 1061b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1062b411b363SPhilipp Reisner wo = min(pwo, wo); 1063b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1064b411b363SPhilipp Reisner wo = WO_drain_io; 1065b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1066b411b363SPhilipp Reisner wo = WO_none; 1067b411b363SPhilipp Reisner mdev->write_ordering = wo; 10682451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1069b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1070b411b363SPhilipp Reisner } 1071b411b363SPhilipp Reisner 1072b411b363SPhilipp Reisner /** 107345bb912bSLars Ellenberg * drbd_submit_ee() 107445bb912bSLars Ellenberg * @mdev: DRBD device. 107545bb912bSLars Ellenberg * @e: epoch entry 107645bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 107745bb912bSLars Ellenberg */ 107845bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 107945bb912bSLars Ellenberg int drbd_submit_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e, 108045bb912bSLars Ellenberg const unsigned rw, const int fault_type) 108145bb912bSLars Ellenberg { 108245bb912bSLars Ellenberg struct bio *bios = NULL; 108345bb912bSLars Ellenberg struct bio *bio; 108445bb912bSLars Ellenberg struct page *page = e->pages; 108545bb912bSLars Ellenberg sector_t sector = e->sector; 108645bb912bSLars Ellenberg unsigned ds = e->size; 108745bb912bSLars Ellenberg unsigned n_bios = 0; 108845bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 108945bb912bSLars Ellenberg 109045bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 109145bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 109245bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 109345bb912bSLars Ellenberg * request in more than one bio. */ 109445bb912bSLars Ellenberg next_bio: 109545bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 109645bb912bSLars Ellenberg if (!bio) { 109745bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 109845bb912bSLars Ellenberg goto fail; 109945bb912bSLars Ellenberg } 110045bb912bSLars Ellenberg /* > e->sector, unless this is the first bio */ 110145bb912bSLars Ellenberg bio->bi_sector = sector; 110245bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 110345bb912bSLars Ellenberg bio->bi_rw = rw; 110445bb912bSLars Ellenberg bio->bi_private = e; 110545bb912bSLars Ellenberg bio->bi_end_io = drbd_endio_sec; 110645bb912bSLars Ellenberg 110745bb912bSLars Ellenberg bio->bi_next = bios; 110845bb912bSLars Ellenberg bios = bio; 110945bb912bSLars Ellenberg ++n_bios; 111045bb912bSLars Ellenberg 111145bb912bSLars Ellenberg page_chain_for_each(page) { 111245bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 111345bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 111445bb912bSLars Ellenberg /* a single page must always be possible! */ 111545bb912bSLars Ellenberg BUG_ON(bio->bi_vcnt == 0); 111645bb912bSLars Ellenberg goto next_bio; 111745bb912bSLars Ellenberg } 111845bb912bSLars Ellenberg ds -= len; 111945bb912bSLars Ellenberg sector += len >> 9; 112045bb912bSLars Ellenberg --nr_pages; 112145bb912bSLars Ellenberg } 112245bb912bSLars Ellenberg D_ASSERT(page == NULL); 112345bb912bSLars Ellenberg D_ASSERT(ds == 0); 112445bb912bSLars Ellenberg 112545bb912bSLars Ellenberg atomic_set(&e->pending_bios, n_bios); 112645bb912bSLars Ellenberg do { 112745bb912bSLars Ellenberg bio = bios; 112845bb912bSLars Ellenberg bios = bios->bi_next; 112945bb912bSLars Ellenberg bio->bi_next = NULL; 113045bb912bSLars Ellenberg 113145bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 113245bb912bSLars Ellenberg } while (bios); 113345bb912bSLars Ellenberg return 0; 113445bb912bSLars Ellenberg 113545bb912bSLars Ellenberg fail: 113645bb912bSLars Ellenberg while (bios) { 113745bb912bSLars Ellenberg bio = bios; 113845bb912bSLars Ellenberg bios = bios->bi_next; 113945bb912bSLars Ellenberg bio_put(bio); 114045bb912bSLars Ellenberg } 114145bb912bSLars Ellenberg return -ENOMEM; 114245bb912bSLars Ellenberg } 114345bb912bSLars Ellenberg 114402918be2SPhilipp Reisner static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 1145b411b363SPhilipp Reisner { 11462451fc3bSPhilipp Reisner int rv; 114702918be2SPhilipp Reisner struct p_barrier *p = &mdev->data.rbuf.barrier; 1148b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1149b411b363SPhilipp Reisner 1150b411b363SPhilipp Reisner inc_unacked(mdev); 1151b411b363SPhilipp Reisner 1152b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1153b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1154b411b363SPhilipp Reisner 1155b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1156b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1157b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1158b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1159b411b363SPhilipp Reisner * completed. */ 1160b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1161b411b363SPhilipp Reisner case WO_none: 1162b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 1163b411b363SPhilipp Reisner return TRUE; 1164b411b363SPhilipp Reisner 1165b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1166b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1167b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 11682451fc3bSPhilipp Reisner if (epoch) 11692451fc3bSPhilipp Reisner break; 11702451fc3bSPhilipp Reisner else 1171b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 11722451fc3bSPhilipp Reisner /* Fall through */ 11732451fc3bSPhilipp Reisner 11742451fc3bSPhilipp Reisner case WO_bdev_flush: 11752451fc3bSPhilipp Reisner case WO_drain_io: 1176b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 11772451fc3bSPhilipp Reisner drbd_flush(mdev); 11782451fc3bSPhilipp Reisner 11792451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 11802451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 11812451fc3bSPhilipp Reisner if (epoch) 11822451fc3bSPhilipp Reisner break; 1183b411b363SPhilipp Reisner } 1184b411b363SPhilipp Reisner 11852451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 11862451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 11872451fc3bSPhilipp Reisner 11882451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 11892451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1190b411b363SPhilipp Reisner 1191b411b363SPhilipp Reisner return TRUE; 11922451fc3bSPhilipp Reisner default: 11932451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 11942451fc3bSPhilipp Reisner return FALSE; 1195b411b363SPhilipp Reisner } 1196b411b363SPhilipp Reisner 1197b411b363SPhilipp Reisner epoch->flags = 0; 1198b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1199b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1200b411b363SPhilipp Reisner 1201b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1202b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1203b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1204b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1205b411b363SPhilipp Reisner mdev->epochs++; 1206b411b363SPhilipp Reisner } else { 1207b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1208b411b363SPhilipp Reisner kfree(epoch); 1209b411b363SPhilipp Reisner } 1210b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1211b411b363SPhilipp Reisner 1212b411b363SPhilipp Reisner return TRUE; 1213b411b363SPhilipp Reisner } 1214b411b363SPhilipp Reisner 1215b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1216b411b363SPhilipp Reisner * and from receive_Data */ 1217b411b363SPhilipp Reisner static struct drbd_epoch_entry * 1218b411b363SPhilipp Reisner read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, int data_size) __must_hold(local) 1219b411b363SPhilipp Reisner { 12206666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1221b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 1222b411b363SPhilipp Reisner struct page *page; 122345bb912bSLars Ellenberg int dgs, ds, rr; 1224b411b363SPhilipp Reisner void *dig_in = mdev->int_dig_in; 1225b411b363SPhilipp Reisner void *dig_vv = mdev->int_dig_vv; 12266b4388acSPhilipp Reisner unsigned long *data; 1227b411b363SPhilipp Reisner 1228b411b363SPhilipp Reisner dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_r_tfm) ? 1229b411b363SPhilipp Reisner crypto_hash_digestsize(mdev->integrity_r_tfm) : 0; 1230b411b363SPhilipp Reisner 1231b411b363SPhilipp Reisner if (dgs) { 1232b411b363SPhilipp Reisner rr = drbd_recv(mdev, dig_in, dgs); 1233b411b363SPhilipp Reisner if (rr != dgs) { 1234b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data digest: read %d expected %d\n", 1235b411b363SPhilipp Reisner rr, dgs); 1236b411b363SPhilipp Reisner return NULL; 1237b411b363SPhilipp Reisner } 1238b411b363SPhilipp Reisner } 1239b411b363SPhilipp Reisner 1240b411b363SPhilipp Reisner data_size -= dgs; 1241b411b363SPhilipp Reisner 1242b411b363SPhilipp Reisner ERR_IF(data_size & 0x1ff) return NULL; 1243b411b363SPhilipp Reisner ERR_IF(data_size > DRBD_MAX_SEGMENT_SIZE) return NULL; 1244b411b363SPhilipp Reisner 12456666032aSLars Ellenberg /* even though we trust out peer, 12466666032aSLars Ellenberg * we sometimes have to double check. */ 12476666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 12486666032aSLars Ellenberg dev_err(DEV, "capacity: %llus < sector: %llus + size: %u\n", 12496666032aSLars Ellenberg (unsigned long long)capacity, 12506666032aSLars Ellenberg (unsigned long long)sector, data_size); 12516666032aSLars Ellenberg return NULL; 12526666032aSLars Ellenberg } 12536666032aSLars Ellenberg 1254b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1255b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1256b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1257b411b363SPhilipp Reisner e = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO); 1258b411b363SPhilipp Reisner if (!e) 1259b411b363SPhilipp Reisner return NULL; 126045bb912bSLars Ellenberg 1261b411b363SPhilipp Reisner ds = data_size; 126245bb912bSLars Ellenberg page = e->pages; 126345bb912bSLars Ellenberg page_chain_for_each(page) { 126445bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 12656b4388acSPhilipp Reisner data = kmap(page); 126645bb912bSLars Ellenberg rr = drbd_recv(mdev, data, len); 12676b4388acSPhilipp Reisner if (FAULT_ACTIVE(mdev, DRBD_FAULT_RECEIVE)) { 12686b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 12696b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 12706b4388acSPhilipp Reisner } 1271b411b363SPhilipp Reisner kunmap(page); 127245bb912bSLars Ellenberg if (rr != len) { 1273b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 1274b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 127545bb912bSLars Ellenberg rr, len); 1276b411b363SPhilipp Reisner return NULL; 1277b411b363SPhilipp Reisner } 1278b411b363SPhilipp Reisner ds -= rr; 1279b411b363SPhilipp Reisner } 1280b411b363SPhilipp Reisner 1281b411b363SPhilipp Reisner if (dgs) { 128245bb912bSLars Ellenberg drbd_csum_ee(mdev, mdev->integrity_r_tfm, e, dig_vv); 1283b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1284b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED.\n"); 1285b411b363SPhilipp Reisner drbd_bcast_ee(mdev, "digest failed", 1286b411b363SPhilipp Reisner dgs, dig_in, dig_vv, e); 1287b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 1288b411b363SPhilipp Reisner return NULL; 1289b411b363SPhilipp Reisner } 1290b411b363SPhilipp Reisner } 1291b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1292b411b363SPhilipp Reisner return e; 1293b411b363SPhilipp Reisner } 1294b411b363SPhilipp Reisner 1295b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1296b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1297b411b363SPhilipp Reisner */ 1298b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1299b411b363SPhilipp Reisner { 1300b411b363SPhilipp Reisner struct page *page; 1301b411b363SPhilipp Reisner int rr, rv = 1; 1302b411b363SPhilipp Reisner void *data; 1303b411b363SPhilipp Reisner 1304c3470cdeSLars Ellenberg if (!data_size) 1305c3470cdeSLars Ellenberg return TRUE; 1306c3470cdeSLars Ellenberg 130745bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, 1, 1); 1308b411b363SPhilipp Reisner 1309b411b363SPhilipp Reisner data = kmap(page); 1310b411b363SPhilipp Reisner while (data_size) { 1311b411b363SPhilipp Reisner rr = drbd_recv(mdev, data, min_t(int, data_size, PAGE_SIZE)); 1312b411b363SPhilipp Reisner if (rr != min_t(int, data_size, PAGE_SIZE)) { 1313b411b363SPhilipp Reisner rv = 0; 1314b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 1315b411b363SPhilipp Reisner rr, min_t(int, data_size, PAGE_SIZE)); 1316b411b363SPhilipp Reisner break; 1317b411b363SPhilipp Reisner } 1318b411b363SPhilipp Reisner data_size -= rr; 1319b411b363SPhilipp Reisner } 1320b411b363SPhilipp Reisner kunmap(page); 1321435f0740SLars Ellenberg drbd_pp_free(mdev, page, 0); 1322b411b363SPhilipp Reisner return rv; 1323b411b363SPhilipp Reisner } 1324b411b363SPhilipp Reisner 1325b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1326b411b363SPhilipp Reisner sector_t sector, int data_size) 1327b411b363SPhilipp Reisner { 1328b411b363SPhilipp Reisner struct bio_vec *bvec; 1329b411b363SPhilipp Reisner struct bio *bio; 1330b411b363SPhilipp Reisner int dgs, rr, i, expect; 1331b411b363SPhilipp Reisner void *dig_in = mdev->int_dig_in; 1332b411b363SPhilipp Reisner void *dig_vv = mdev->int_dig_vv; 1333b411b363SPhilipp Reisner 1334b411b363SPhilipp Reisner dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_r_tfm) ? 1335b411b363SPhilipp Reisner crypto_hash_digestsize(mdev->integrity_r_tfm) : 0; 1336b411b363SPhilipp Reisner 1337b411b363SPhilipp Reisner if (dgs) { 1338b411b363SPhilipp Reisner rr = drbd_recv(mdev, dig_in, dgs); 1339b411b363SPhilipp Reisner if (rr != dgs) { 1340b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply digest: read %d expected %d\n", 1341b411b363SPhilipp Reisner rr, dgs); 1342b411b363SPhilipp Reisner return 0; 1343b411b363SPhilipp Reisner } 1344b411b363SPhilipp Reisner } 1345b411b363SPhilipp Reisner 1346b411b363SPhilipp Reisner data_size -= dgs; 1347b411b363SPhilipp Reisner 1348b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1349b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1350b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1351b411b363SPhilipp Reisner 1352b411b363SPhilipp Reisner bio = req->master_bio; 1353b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1354b411b363SPhilipp Reisner 1355b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1356b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1357b411b363SPhilipp Reisner rr = drbd_recv(mdev, 1358b411b363SPhilipp Reisner kmap(bvec->bv_page)+bvec->bv_offset, 1359b411b363SPhilipp Reisner expect); 1360b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1361b411b363SPhilipp Reisner if (rr != expect) { 1362b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply: " 1363b411b363SPhilipp Reisner "read %d expected %d\n", 1364b411b363SPhilipp Reisner rr, expect); 1365b411b363SPhilipp Reisner return 0; 1366b411b363SPhilipp Reisner } 1367b411b363SPhilipp Reisner data_size -= rr; 1368b411b363SPhilipp Reisner } 1369b411b363SPhilipp Reisner 1370b411b363SPhilipp Reisner if (dgs) { 137145bb912bSLars Ellenberg drbd_csum_bio(mdev, mdev->integrity_r_tfm, bio, dig_vv); 1372b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1373b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 1374b411b363SPhilipp Reisner return 0; 1375b411b363SPhilipp Reisner } 1376b411b363SPhilipp Reisner } 1377b411b363SPhilipp Reisner 1378b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 1379b411b363SPhilipp Reisner return 1; 1380b411b363SPhilipp Reisner } 1381b411b363SPhilipp Reisner 1382b411b363SPhilipp Reisner /* e_end_resync_block() is called via 1383b411b363SPhilipp Reisner * drbd_process_done_ee() by asender only */ 1384b411b363SPhilipp Reisner static int e_end_resync_block(struct drbd_conf *mdev, struct drbd_work *w, int unused) 1385b411b363SPhilipp Reisner { 1386b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1387b411b363SPhilipp Reisner sector_t sector = e->sector; 1388b411b363SPhilipp Reisner int ok; 1389b411b363SPhilipp Reisner 1390b411b363SPhilipp Reisner D_ASSERT(hlist_unhashed(&e->colision)); 1391b411b363SPhilipp Reisner 139245bb912bSLars Ellenberg if (likely((e->flags & EE_WAS_ERROR) == 0)) { 1393b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, e->size); 1394b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_RS_WRITE_ACK, e); 1395b411b363SPhilipp Reisner } else { 1396b411b363SPhilipp Reisner /* Record failure to sync */ 1397b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, e->size); 1398b411b363SPhilipp Reisner 1399b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_NEG_ACK, e); 1400b411b363SPhilipp Reisner } 1401b411b363SPhilipp Reisner dec_unacked(mdev); 1402b411b363SPhilipp Reisner 1403b411b363SPhilipp Reisner return ok; 1404b411b363SPhilipp Reisner } 1405b411b363SPhilipp Reisner 1406b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1407b411b363SPhilipp Reisner { 1408b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 1409b411b363SPhilipp Reisner 1410b411b363SPhilipp Reisner e = read_in_block(mdev, ID_SYNCER, sector, data_size); 141145bb912bSLars Ellenberg if (!e) 141245bb912bSLars Ellenberg goto fail; 1413b411b363SPhilipp Reisner 1414b411b363SPhilipp Reisner dec_rs_pending(mdev); 1415b411b363SPhilipp Reisner 1416b411b363SPhilipp Reisner inc_unacked(mdev); 1417b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1418b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1419b411b363SPhilipp Reisner 142045bb912bSLars Ellenberg e->w.cb = e_end_resync_block; 142145bb912bSLars Ellenberg 1422b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1423b411b363SPhilipp Reisner list_add(&e->w.list, &mdev->sync_ee); 1424b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1425b411b363SPhilipp Reisner 14260f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 142745bb912bSLars Ellenberg if (drbd_submit_ee(mdev, e, WRITE, DRBD_FAULT_RS_WR) == 0) 1428b411b363SPhilipp Reisner return TRUE; 142945bb912bSLars Ellenberg 143022cc37a9SLars Ellenberg /* drbd_submit_ee currently fails for one reason only: 143122cc37a9SLars Ellenberg * not being able to allocate enough bios. 143222cc37a9SLars Ellenberg * Is dropping the connection going to help? */ 143322cc37a9SLars Ellenberg spin_lock_irq(&mdev->req_lock); 143422cc37a9SLars Ellenberg list_del(&e->w.list); 143522cc37a9SLars Ellenberg spin_unlock_irq(&mdev->req_lock); 143622cc37a9SLars Ellenberg 143745bb912bSLars Ellenberg drbd_free_ee(mdev, e); 143845bb912bSLars Ellenberg fail: 143945bb912bSLars Ellenberg put_ldev(mdev); 144045bb912bSLars Ellenberg return FALSE; 1441b411b363SPhilipp Reisner } 1442b411b363SPhilipp Reisner 144302918be2SPhilipp Reisner static int receive_DataReply(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 1444b411b363SPhilipp Reisner { 1445b411b363SPhilipp Reisner struct drbd_request *req; 1446b411b363SPhilipp Reisner sector_t sector; 1447b411b363SPhilipp Reisner int ok; 144802918be2SPhilipp Reisner struct p_data *p = &mdev->data.rbuf.data; 1449b411b363SPhilipp Reisner 1450b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1451b411b363SPhilipp Reisner 1452b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1453b411b363SPhilipp Reisner req = _ar_id_to_req(mdev, p->block_id, sector); 1454b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1455b411b363SPhilipp Reisner if (unlikely(!req)) { 1456b411b363SPhilipp Reisner dev_err(DEV, "Got a corrupt block_id/sector pair(1).\n"); 1457b411b363SPhilipp Reisner return FALSE; 1458b411b363SPhilipp Reisner } 1459b411b363SPhilipp Reisner 1460b411b363SPhilipp Reisner /* hlist_del(&req->colision) is done in _req_may_be_done, to avoid 1461b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1462b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1463b411b363SPhilipp Reisner ok = recv_dless_read(mdev, req, sector, data_size); 1464b411b363SPhilipp Reisner 1465b411b363SPhilipp Reisner if (ok) 1466b411b363SPhilipp Reisner req_mod(req, data_received); 1467b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1468b411b363SPhilipp Reisner * I don't think we may complete this just yet 1469b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1470b411b363SPhilipp Reisner 1471b411b363SPhilipp Reisner return ok; 1472b411b363SPhilipp Reisner } 1473b411b363SPhilipp Reisner 147402918be2SPhilipp Reisner static int receive_RSDataReply(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 1475b411b363SPhilipp Reisner { 1476b411b363SPhilipp Reisner sector_t sector; 1477b411b363SPhilipp Reisner int ok; 147802918be2SPhilipp Reisner struct p_data *p = &mdev->data.rbuf.data; 1479b411b363SPhilipp Reisner 1480b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1481b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1482b411b363SPhilipp Reisner 1483b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1484b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1485b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1486b411b363SPhilipp Reisner * or in drbd_endio_write_sec. */ 1487b411b363SPhilipp Reisner ok = recv_resync_read(mdev, sector, data_size); 1488b411b363SPhilipp Reisner } else { 1489b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1490b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1491b411b363SPhilipp Reisner 1492b411b363SPhilipp Reisner ok = drbd_drain_block(mdev, data_size); 1493b411b363SPhilipp Reisner 14942b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1495b411b363SPhilipp Reisner } 1496b411b363SPhilipp Reisner 1497778f271dSPhilipp Reisner atomic_add(data_size >> 9, &mdev->rs_sect_in); 1498778f271dSPhilipp Reisner 1499b411b363SPhilipp Reisner return ok; 1500b411b363SPhilipp Reisner } 1501b411b363SPhilipp Reisner 1502b411b363SPhilipp Reisner /* e_end_block() is called via drbd_process_done_ee(). 1503b411b363SPhilipp Reisner * this means this function only runs in the asender thread 1504b411b363SPhilipp Reisner */ 1505b411b363SPhilipp Reisner static int e_end_block(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1506b411b363SPhilipp Reisner { 1507b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1508b411b363SPhilipp Reisner sector_t sector = e->sector; 1509b411b363SPhilipp Reisner int ok = 1, pcmd; 1510b411b363SPhilipp Reisner 1511b411b363SPhilipp Reisner if (mdev->net_conf->wire_protocol == DRBD_PROT_C) { 151245bb912bSLars Ellenberg if (likely((e->flags & EE_WAS_ERROR) == 0)) { 1513b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1514b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1515b411b363SPhilipp Reisner e->flags & EE_MAY_SET_IN_SYNC) ? 1516b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1517b411b363SPhilipp Reisner ok &= drbd_send_ack(mdev, pcmd, e); 1518b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1519b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, e->size); 1520b411b363SPhilipp Reisner } else { 1521b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_NEG_ACK, e); 1522b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1523b411b363SPhilipp Reisner * maybe assert this? */ 1524b411b363SPhilipp Reisner } 1525b411b363SPhilipp Reisner dec_unacked(mdev); 1526b411b363SPhilipp Reisner } 1527b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1528b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1529b411b363SPhilipp Reisner if (mdev->net_conf->two_primaries) { 1530b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1531b411b363SPhilipp Reisner D_ASSERT(!hlist_unhashed(&e->colision)); 1532b411b363SPhilipp Reisner hlist_del_init(&e->colision); 1533b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1534b411b363SPhilipp Reisner } else { 1535b411b363SPhilipp Reisner D_ASSERT(hlist_unhashed(&e->colision)); 1536b411b363SPhilipp Reisner } 1537b411b363SPhilipp Reisner 1538b411b363SPhilipp Reisner drbd_may_finish_epoch(mdev, e->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1539b411b363SPhilipp Reisner 1540b411b363SPhilipp Reisner return ok; 1541b411b363SPhilipp Reisner } 1542b411b363SPhilipp Reisner 1543b411b363SPhilipp Reisner static int e_send_discard_ack(struct drbd_conf *mdev, struct drbd_work *w, int unused) 1544b411b363SPhilipp Reisner { 1545b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1546b411b363SPhilipp Reisner int ok = 1; 1547b411b363SPhilipp Reisner 1548b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 1549b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_DISCARD_ACK, e); 1550b411b363SPhilipp Reisner 1551b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1552b411b363SPhilipp Reisner D_ASSERT(!hlist_unhashed(&e->colision)); 1553b411b363SPhilipp Reisner hlist_del_init(&e->colision); 1554b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1555b411b363SPhilipp Reisner 1556b411b363SPhilipp Reisner dec_unacked(mdev); 1557b411b363SPhilipp Reisner 1558b411b363SPhilipp Reisner return ok; 1559b411b363SPhilipp Reisner } 1560b411b363SPhilipp Reisner 1561b411b363SPhilipp Reisner /* Called from receive_Data. 1562b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1563b411b363SPhilipp Reisner * 1564b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1565b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1566b411b363SPhilipp Reisner * been sent. 1567b411b363SPhilipp Reisner * 1568b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1569b411b363SPhilipp Reisner * 1570b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1571b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1572b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1573b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1574b411b363SPhilipp Reisner * 1575b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1576b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1577b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1578b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1579b411b363SPhilipp Reisner * 1580b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1581b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 1582b411b363SPhilipp Reisner static int drbd_wait_peer_seq(struct drbd_conf *mdev, const u32 packet_seq) 1583b411b363SPhilipp Reisner { 1584b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1585b411b363SPhilipp Reisner unsigned int p_seq; 1586b411b363SPhilipp Reisner long timeout; 1587b411b363SPhilipp Reisner int ret = 0; 1588b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1589b411b363SPhilipp Reisner for (;;) { 1590b411b363SPhilipp Reisner prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1591b411b363SPhilipp Reisner if (seq_le(packet_seq, mdev->peer_seq+1)) 1592b411b363SPhilipp Reisner break; 1593b411b363SPhilipp Reisner if (signal_pending(current)) { 1594b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1595b411b363SPhilipp Reisner break; 1596b411b363SPhilipp Reisner } 1597b411b363SPhilipp Reisner p_seq = mdev->peer_seq; 1598b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1599b411b363SPhilipp Reisner timeout = schedule_timeout(30*HZ); 1600b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1601b411b363SPhilipp Reisner if (timeout == 0 && p_seq == mdev->peer_seq) { 1602b411b363SPhilipp Reisner ret = -ETIMEDOUT; 1603b411b363SPhilipp Reisner dev_err(DEV, "ASSERT FAILED waited 30 seconds for sequence update, forcing reconnect\n"); 1604b411b363SPhilipp Reisner break; 1605b411b363SPhilipp Reisner } 1606b411b363SPhilipp Reisner } 1607b411b363SPhilipp Reisner finish_wait(&mdev->seq_wait, &wait); 1608b411b363SPhilipp Reisner if (mdev->peer_seq+1 == packet_seq) 1609b411b363SPhilipp Reisner mdev->peer_seq++; 1610b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1611b411b363SPhilipp Reisner return ret; 1612b411b363SPhilipp Reisner } 1613b411b363SPhilipp Reisner 161476d2e7ecSPhilipp Reisner static unsigned long write_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 161576d2e7ecSPhilipp Reisner { 161676d2e7ecSPhilipp Reisner if (mdev->agreed_pro_version >= 95) 161776d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 161876d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 161976d2e7ecSPhilipp Reisner (dpf & DP_FLUSH ? REQ_FUA : 0) | 162076d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 162176d2e7ecSPhilipp Reisner else 1622721a9602SJens Axboe return dpf & DP_RW_SYNC ? REQ_SYNC : 0; 162376d2e7ecSPhilipp Reisner } 162476d2e7ecSPhilipp Reisner 1625b411b363SPhilipp Reisner /* mirrored write */ 162602918be2SPhilipp Reisner static int receive_Data(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 1627b411b363SPhilipp Reisner { 1628b411b363SPhilipp Reisner sector_t sector; 1629b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 163002918be2SPhilipp Reisner struct p_data *p = &mdev->data.rbuf.data; 1631b411b363SPhilipp Reisner int rw = WRITE; 1632b411b363SPhilipp Reisner u32 dp_flags; 1633b411b363SPhilipp Reisner 1634b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 1635b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1636b411b363SPhilipp Reisner dev_err(DEV, "Can not write mirrored data block " 1637b411b363SPhilipp Reisner "to local disk.\n"); 1638b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1639b411b363SPhilipp Reisner if (mdev->peer_seq+1 == be32_to_cpu(p->seq_num)) 1640b411b363SPhilipp Reisner mdev->peer_seq++; 1641b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1642b411b363SPhilipp Reisner 16432b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1644b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 1645b411b363SPhilipp Reisner return drbd_drain_block(mdev, data_size); 1646b411b363SPhilipp Reisner } 1647b411b363SPhilipp Reisner 1648b411b363SPhilipp Reisner /* get_ldev(mdev) successful. 1649b411b363SPhilipp Reisner * Corresponding put_ldev done either below (on various errors), 1650b411b363SPhilipp Reisner * or in drbd_endio_write_sec, if we successfully submit the data at 1651b411b363SPhilipp Reisner * the end of this function. */ 1652b411b363SPhilipp Reisner 1653b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1654b411b363SPhilipp Reisner e = read_in_block(mdev, p->block_id, sector, data_size); 1655b411b363SPhilipp Reisner if (!e) { 1656b411b363SPhilipp Reisner put_ldev(mdev); 1657b411b363SPhilipp Reisner return FALSE; 1658b411b363SPhilipp Reisner } 1659b411b363SPhilipp Reisner 1660b411b363SPhilipp Reisner e->w.cb = e_end_block; 1661b411b363SPhilipp Reisner 1662b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1663b411b363SPhilipp Reisner e->epoch = mdev->current_epoch; 1664b411b363SPhilipp Reisner atomic_inc(&e->epoch->epoch_size); 1665b411b363SPhilipp Reisner atomic_inc(&e->epoch->active); 1666b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1667b411b363SPhilipp Reisner 1668b411b363SPhilipp Reisner dp_flags = be32_to_cpu(p->dp_flags); 166976d2e7ecSPhilipp Reisner rw |= write_flags_to_bio(mdev, dp_flags); 167076d2e7ecSPhilipp Reisner 1671b411b363SPhilipp Reisner if (dp_flags & DP_MAY_SET_IN_SYNC) 1672b411b363SPhilipp Reisner e->flags |= EE_MAY_SET_IN_SYNC; 1673b411b363SPhilipp Reisner 1674b411b363SPhilipp Reisner /* I'm the receiver, I do hold a net_cnt reference. */ 1675b411b363SPhilipp Reisner if (!mdev->net_conf->two_primaries) { 1676b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1677b411b363SPhilipp Reisner } else { 1678b411b363SPhilipp Reisner /* don't get the req_lock yet, 1679b411b363SPhilipp Reisner * we may sleep in drbd_wait_peer_seq */ 1680b411b363SPhilipp Reisner const int size = e->size; 1681b411b363SPhilipp Reisner const int discard = test_bit(DISCARD_CONCURRENT, &mdev->flags); 1682b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1683b411b363SPhilipp Reisner struct drbd_request *i; 1684b411b363SPhilipp Reisner struct hlist_node *n; 1685b411b363SPhilipp Reisner struct hlist_head *slot; 1686b411b363SPhilipp Reisner int first; 1687b411b363SPhilipp Reisner 1688b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 1689b411b363SPhilipp Reisner BUG_ON(mdev->ee_hash == NULL); 1690b411b363SPhilipp Reisner BUG_ON(mdev->tl_hash == NULL); 1691b411b363SPhilipp Reisner 1692b411b363SPhilipp Reisner /* conflict detection and handling: 1693b411b363SPhilipp Reisner * 1. wait on the sequence number, 1694b411b363SPhilipp Reisner * in case this data packet overtook ACK packets. 1695b411b363SPhilipp Reisner * 2. check our hash tables for conflicting requests. 1696b411b363SPhilipp Reisner * we only need to walk the tl_hash, since an ee can not 1697b411b363SPhilipp Reisner * have a conflict with an other ee: on the submitting 1698b411b363SPhilipp Reisner * node, the corresponding req had already been conflicting, 1699b411b363SPhilipp Reisner * and a conflicting req is never sent. 1700b411b363SPhilipp Reisner * 1701b411b363SPhilipp Reisner * Note: for two_primaries, we are protocol C, 1702b411b363SPhilipp Reisner * so there cannot be any request that is DONE 1703b411b363SPhilipp Reisner * but still on the transfer log. 1704b411b363SPhilipp Reisner * 1705b411b363SPhilipp Reisner * unconditionally add to the ee_hash. 1706b411b363SPhilipp Reisner * 1707b411b363SPhilipp Reisner * if no conflicting request is found: 1708b411b363SPhilipp Reisner * submit. 1709b411b363SPhilipp Reisner * 1710b411b363SPhilipp Reisner * if any conflicting request is found 1711b411b363SPhilipp Reisner * that has not yet been acked, 1712b411b363SPhilipp Reisner * AND I have the "discard concurrent writes" flag: 1713b411b363SPhilipp Reisner * queue (via done_ee) the P_DISCARD_ACK; OUT. 1714b411b363SPhilipp Reisner * 1715b411b363SPhilipp Reisner * if any conflicting request is found: 1716b411b363SPhilipp Reisner * block the receiver, waiting on misc_wait 1717b411b363SPhilipp Reisner * until no more conflicting requests are there, 1718b411b363SPhilipp Reisner * or we get interrupted (disconnect). 1719b411b363SPhilipp Reisner * 1720b411b363SPhilipp Reisner * we do not just write after local io completion of those 1721b411b363SPhilipp Reisner * requests, but only after req is done completely, i.e. 1722b411b363SPhilipp Reisner * we wait for the P_DISCARD_ACK to arrive! 1723b411b363SPhilipp Reisner * 1724b411b363SPhilipp Reisner * then proceed normally, i.e. submit. 1725b411b363SPhilipp Reisner */ 1726b411b363SPhilipp Reisner if (drbd_wait_peer_seq(mdev, be32_to_cpu(p->seq_num))) 1727b411b363SPhilipp Reisner goto out_interrupted; 1728b411b363SPhilipp Reisner 1729b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1730b411b363SPhilipp Reisner 1731b411b363SPhilipp Reisner hlist_add_head(&e->colision, ee_hash_slot(mdev, sector)); 1732b411b363SPhilipp Reisner 1733b411b363SPhilipp Reisner #define OVERLAPS overlaps(i->sector, i->size, sector, size) 1734b411b363SPhilipp Reisner slot = tl_hash_slot(mdev, sector); 1735b411b363SPhilipp Reisner first = 1; 1736b411b363SPhilipp Reisner for (;;) { 1737b411b363SPhilipp Reisner int have_unacked = 0; 1738b411b363SPhilipp Reisner int have_conflict = 0; 1739b411b363SPhilipp Reisner prepare_to_wait(&mdev->misc_wait, &wait, 1740b411b363SPhilipp Reisner TASK_INTERRUPTIBLE); 1741b411b363SPhilipp Reisner hlist_for_each_entry(i, n, slot, colision) { 1742b411b363SPhilipp Reisner if (OVERLAPS) { 1743b411b363SPhilipp Reisner /* only ALERT on first iteration, 1744b411b363SPhilipp Reisner * we may be woken up early... */ 1745b411b363SPhilipp Reisner if (first) 1746b411b363SPhilipp Reisner dev_alert(DEV, "%s[%u] Concurrent local write detected!" 1747b411b363SPhilipp Reisner " new: %llus +%u; pending: %llus +%u\n", 1748b411b363SPhilipp Reisner current->comm, current->pid, 1749b411b363SPhilipp Reisner (unsigned long long)sector, size, 1750b411b363SPhilipp Reisner (unsigned long long)i->sector, i->size); 1751b411b363SPhilipp Reisner if (i->rq_state & RQ_NET_PENDING) 1752b411b363SPhilipp Reisner ++have_unacked; 1753b411b363SPhilipp Reisner ++have_conflict; 1754b411b363SPhilipp Reisner } 1755b411b363SPhilipp Reisner } 1756b411b363SPhilipp Reisner #undef OVERLAPS 1757b411b363SPhilipp Reisner if (!have_conflict) 1758b411b363SPhilipp Reisner break; 1759b411b363SPhilipp Reisner 1760b411b363SPhilipp Reisner /* Discard Ack only for the _first_ iteration */ 1761b411b363SPhilipp Reisner if (first && discard && have_unacked) { 1762b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [DISCARD BY FLAG] sec=%llus\n", 1763b411b363SPhilipp Reisner (unsigned long long)sector); 1764b411b363SPhilipp Reisner inc_unacked(mdev); 1765b411b363SPhilipp Reisner e->w.cb = e_send_discard_ack; 1766b411b363SPhilipp Reisner list_add_tail(&e->w.list, &mdev->done_ee); 1767b411b363SPhilipp Reisner 1768b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1769b411b363SPhilipp Reisner 1770b411b363SPhilipp Reisner /* we could probably send that P_DISCARD_ACK ourselves, 1771b411b363SPhilipp Reisner * but I don't like the receiver using the msock */ 1772b411b363SPhilipp Reisner 1773b411b363SPhilipp Reisner put_ldev(mdev); 1774b411b363SPhilipp Reisner wake_asender(mdev); 1775b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1776b411b363SPhilipp Reisner return TRUE; 1777b411b363SPhilipp Reisner } 1778b411b363SPhilipp Reisner 1779b411b363SPhilipp Reisner if (signal_pending(current)) { 1780b411b363SPhilipp Reisner hlist_del_init(&e->colision); 1781b411b363SPhilipp Reisner 1782b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1783b411b363SPhilipp Reisner 1784b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1785b411b363SPhilipp Reisner goto out_interrupted; 1786b411b363SPhilipp Reisner } 1787b411b363SPhilipp Reisner 1788b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1789b411b363SPhilipp Reisner if (first) { 1790b411b363SPhilipp Reisner first = 0; 1791b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [W AFTERWARDS] " 1792b411b363SPhilipp Reisner "sec=%llus\n", (unsigned long long)sector); 1793b411b363SPhilipp Reisner } else if (discard) { 1794b411b363SPhilipp Reisner /* we had none on the first iteration. 1795b411b363SPhilipp Reisner * there must be none now. */ 1796b411b363SPhilipp Reisner D_ASSERT(have_unacked == 0); 1797b411b363SPhilipp Reisner } 1798b411b363SPhilipp Reisner schedule(); 1799b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1800b411b363SPhilipp Reisner } 1801b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1802b411b363SPhilipp Reisner } 1803b411b363SPhilipp Reisner 1804b411b363SPhilipp Reisner list_add(&e->w.list, &mdev->active_ee); 1805b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1806b411b363SPhilipp Reisner 1807b411b363SPhilipp Reisner switch (mdev->net_conf->wire_protocol) { 1808b411b363SPhilipp Reisner case DRBD_PROT_C: 1809b411b363SPhilipp Reisner inc_unacked(mdev); 1810b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 1811b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1812b411b363SPhilipp Reisner break; 1813b411b363SPhilipp Reisner case DRBD_PROT_B: 1814b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 1815b411b363SPhilipp Reisner * sends on the msock, but anyways */ 1816b411b363SPhilipp Reisner drbd_send_ack(mdev, P_RECV_ACK, e); 1817b411b363SPhilipp Reisner break; 1818b411b363SPhilipp Reisner case DRBD_PROT_A: 1819b411b363SPhilipp Reisner /* nothing to do */ 1820b411b363SPhilipp Reisner break; 1821b411b363SPhilipp Reisner } 1822b411b363SPhilipp Reisner 18236719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 1824b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 1825b411b363SPhilipp Reisner drbd_set_out_of_sync(mdev, e->sector, e->size); 1826b411b363SPhilipp Reisner e->flags |= EE_CALL_AL_COMPLETE_IO; 18276719fb03SLars Ellenberg e->flags &= ~EE_MAY_SET_IN_SYNC; 1828b411b363SPhilipp Reisner drbd_al_begin_io(mdev, e->sector); 1829b411b363SPhilipp Reisner } 1830b411b363SPhilipp Reisner 183145bb912bSLars Ellenberg if (drbd_submit_ee(mdev, e, rw, DRBD_FAULT_DT_WR) == 0) 1832b411b363SPhilipp Reisner return TRUE; 1833b411b363SPhilipp Reisner 183422cc37a9SLars Ellenberg /* drbd_submit_ee currently fails for one reason only: 183522cc37a9SLars Ellenberg * not being able to allocate enough bios. 183622cc37a9SLars Ellenberg * Is dropping the connection going to help? */ 183722cc37a9SLars Ellenberg spin_lock_irq(&mdev->req_lock); 183822cc37a9SLars Ellenberg list_del(&e->w.list); 183922cc37a9SLars Ellenberg hlist_del_init(&e->colision); 184022cc37a9SLars Ellenberg spin_unlock_irq(&mdev->req_lock); 184122cc37a9SLars Ellenberg if (e->flags & EE_CALL_AL_COMPLETE_IO) 184222cc37a9SLars Ellenberg drbd_al_complete_io(mdev, e->sector); 184322cc37a9SLars Ellenberg 1844b411b363SPhilipp Reisner out_interrupted: 1845b411b363SPhilipp Reisner /* yes, the epoch_size now is imbalanced. 1846b411b363SPhilipp Reisner * but we drop the connection anyways, so we don't have a chance to 1847b411b363SPhilipp Reisner * receive a barrier... atomic_inc(&mdev->epoch_size); */ 1848b411b363SPhilipp Reisner put_ldev(mdev); 1849b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 1850b411b363SPhilipp Reisner return FALSE; 1851b411b363SPhilipp Reisner } 1852b411b363SPhilipp Reisner 18530f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 18540f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 18550f0601f4SLars Ellenberg * 18560f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 18570f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 18580f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 18590f0601f4SLars Ellenberg * activity, it obviously is "busy". 18600f0601f4SLars Ellenberg * 18610f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 18620f0601f4SLars Ellenberg * to have a short time average so we can react faster. 18630f0601f4SLars Ellenberg */ 18640f0601f4SLars Ellenberg int drbd_rs_should_slow_down(struct drbd_conf *mdev) 18650f0601f4SLars Ellenberg { 18660f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 18670f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 18680f0601f4SLars Ellenberg int curr_events; 18690f0601f4SLars Ellenberg int throttle = 0; 18700f0601f4SLars Ellenberg 18710f0601f4SLars Ellenberg /* feature disabled? */ 18720f0601f4SLars Ellenberg if (mdev->sync_conf.c_min_rate == 0) 18730f0601f4SLars Ellenberg return 0; 18740f0601f4SLars Ellenberg 18750f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 18760f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 18770f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 18780f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 18790f0601f4SLars Ellenberg unsigned long rs_left; 18800f0601f4SLars Ellenberg int i; 18810f0601f4SLars Ellenberg 18820f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 18830f0601f4SLars Ellenberg 18840f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 18850f0601f4SLars Ellenberg * approx. */ 18860f0601f4SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-2) % DRBD_SYNC_MARKS; 18870f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 18880f0601f4SLars Ellenberg 18890f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 18900f0601f4SLars Ellenberg if (!dt) 18910f0601f4SLars Ellenberg dt++; 18920f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 18930f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 18940f0601f4SLars Ellenberg 18950f0601f4SLars Ellenberg if (dbdt > mdev->sync_conf.c_min_rate) 18960f0601f4SLars Ellenberg throttle = 1; 18970f0601f4SLars Ellenberg } 18980f0601f4SLars Ellenberg return throttle; 18990f0601f4SLars Ellenberg } 19000f0601f4SLars Ellenberg 19010f0601f4SLars Ellenberg 190202918be2SPhilipp Reisner static int receive_DataRequest(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int digest_size) 1903b411b363SPhilipp Reisner { 1904b411b363SPhilipp Reisner sector_t sector; 1905b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1906b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 1907b411b363SPhilipp Reisner struct digest_info *di = NULL; 1908b18b37beSPhilipp Reisner int size, verb; 1909b411b363SPhilipp Reisner unsigned int fault_type; 191002918be2SPhilipp Reisner struct p_block_req *p = &mdev->data.rbuf.block_req; 1911b411b363SPhilipp Reisner 1912b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1913b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 1914b411b363SPhilipp Reisner 1915b411b363SPhilipp Reisner if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_SEGMENT_SIZE) { 1916b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 1917b411b363SPhilipp Reisner (unsigned long long)sector, size); 1918b411b363SPhilipp Reisner return FALSE; 1919b411b363SPhilipp Reisner } 1920b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 1921b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 1922b411b363SPhilipp Reisner (unsigned long long)sector, size); 1923b411b363SPhilipp Reisner return FALSE; 1924b411b363SPhilipp Reisner } 1925b411b363SPhilipp Reisner 1926b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 1927b18b37beSPhilipp Reisner verb = 1; 1928b18b37beSPhilipp Reisner switch (cmd) { 1929b18b37beSPhilipp Reisner case P_DATA_REQUEST: 1930b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 1931b18b37beSPhilipp Reisner break; 1932b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 1933b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 1934b18b37beSPhilipp Reisner case P_OV_REQUEST: 1935b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 1936b18b37beSPhilipp Reisner break; 1937b18b37beSPhilipp Reisner case P_OV_REPLY: 1938b18b37beSPhilipp Reisner verb = 0; 1939b18b37beSPhilipp Reisner dec_rs_pending(mdev); 1940b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 1941b18b37beSPhilipp Reisner break; 1942b18b37beSPhilipp Reisner default: 1943b18b37beSPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 1944b18b37beSPhilipp Reisner cmdname(cmd)); 1945b18b37beSPhilipp Reisner } 1946b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 1947b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 1948b411b363SPhilipp Reisner "no local data.\n"); 1949b18b37beSPhilipp Reisner 1950a821cc4aSLars Ellenberg /* drain possibly payload */ 1951a821cc4aSLars Ellenberg return drbd_drain_block(mdev, digest_size); 1952b411b363SPhilipp Reisner } 1953b411b363SPhilipp Reisner 1954b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1955b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1956b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1957b411b363SPhilipp Reisner e = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO); 1958b411b363SPhilipp Reisner if (!e) { 1959b411b363SPhilipp Reisner put_ldev(mdev); 1960b411b363SPhilipp Reisner return FALSE; 1961b411b363SPhilipp Reisner } 1962b411b363SPhilipp Reisner 196302918be2SPhilipp Reisner switch (cmd) { 1964b411b363SPhilipp Reisner case P_DATA_REQUEST: 1965b411b363SPhilipp Reisner e->w.cb = w_e_end_data_req; 1966b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 196780a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 196880a40e43SLars Ellenberg goto submit; 196980a40e43SLars Ellenberg 1970b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 1971b411b363SPhilipp Reisner e->w.cb = w_e_end_rsdata_req; 1972b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 1973b411b363SPhilipp Reisner break; 1974b411b363SPhilipp Reisner 1975b411b363SPhilipp Reisner case P_OV_REPLY: 1976b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 1977b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 1978b411b363SPhilipp Reisner di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO); 1979b411b363SPhilipp Reisner if (!di) 1980b411b363SPhilipp Reisner goto out_free_e; 1981b411b363SPhilipp Reisner 1982b411b363SPhilipp Reisner di->digest_size = digest_size; 1983b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 1984b411b363SPhilipp Reisner 1985c36c3cedSLars Ellenberg e->digest = di; 1986c36c3cedSLars Ellenberg e->flags |= EE_HAS_DIGEST; 1987c36c3cedSLars Ellenberg 1988b411b363SPhilipp Reisner if (drbd_recv(mdev, di->digest, digest_size) != digest_size) 1989b411b363SPhilipp Reisner goto out_free_e; 1990b411b363SPhilipp Reisner 199102918be2SPhilipp Reisner if (cmd == P_CSUM_RS_REQUEST) { 1992b411b363SPhilipp Reisner D_ASSERT(mdev->agreed_pro_version >= 89); 1993b411b363SPhilipp Reisner e->w.cb = w_e_end_csum_rs_req; 199402918be2SPhilipp Reisner } else if (cmd == P_OV_REPLY) { 1995b411b363SPhilipp Reisner e->w.cb = w_e_end_ov_reply; 1996b411b363SPhilipp Reisner dec_rs_pending(mdev); 19970f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 19980f0601f4SLars Ellenberg * but accounting still needs to be done. */ 19990f0601f4SLars Ellenberg goto submit_for_resync; 2000b411b363SPhilipp Reisner } 2001b411b363SPhilipp Reisner break; 2002b411b363SPhilipp Reisner 2003b411b363SPhilipp Reisner case P_OV_REQUEST: 2004b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 2005b411b363SPhilipp Reisner mdev->agreed_pro_version >= 90) { 2006de228bbaSLars Ellenberg unsigned long now = jiffies; 2007de228bbaSLars Ellenberg int i; 2008b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2009b411b363SPhilipp Reisner mdev->ov_position = sector; 201030b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 201130b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2012de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2013de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2014de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2015de228bbaSLars Ellenberg } 2016b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2017b411b363SPhilipp Reisner (unsigned long long)sector); 2018b411b363SPhilipp Reisner } 2019b411b363SPhilipp Reisner e->w.cb = w_e_end_ov_req; 2020b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2021b411b363SPhilipp Reisner break; 2022b411b363SPhilipp Reisner 2023b411b363SPhilipp Reisner default: 2024b411b363SPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 202502918be2SPhilipp Reisner cmdname(cmd)); 2026b411b363SPhilipp Reisner fault_type = DRBD_FAULT_MAX; 202780a40e43SLars Ellenberg goto out_free_e; 2028b411b363SPhilipp Reisner } 2029b411b363SPhilipp Reisner 20300f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 20310f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 20320f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 20330f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 20340f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 20350f0601f4SLars Ellenberg * 20360f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 20370f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 20380f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 20390f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 20400f0601f4SLars Ellenberg * a while, anyways. 20410f0601f4SLars Ellenberg */ 2042b411b363SPhilipp Reisner 20430f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 20440f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 20450f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 20460f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 20470f0601f4SLars Ellenberg * 20480f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 20490f0601f4SLars Ellenberg * we would also throttle its application reads. 20500f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 20510f0601f4SLars Ellenberg */ 20520f0601f4SLars Ellenberg if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev)) 20530f0601f4SLars Ellenberg msleep(100); 205480a40e43SLars Ellenberg if (drbd_rs_begin_io(mdev, e->sector)) 205580a40e43SLars Ellenberg goto out_free_e; 2056b411b363SPhilipp Reisner 20570f0601f4SLars Ellenberg submit_for_resync: 20580f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 20590f0601f4SLars Ellenberg 206080a40e43SLars Ellenberg submit: 2061b411b363SPhilipp Reisner inc_unacked(mdev); 206280a40e43SLars Ellenberg spin_lock_irq(&mdev->req_lock); 206380a40e43SLars Ellenberg list_add_tail(&e->w.list, &mdev->read_ee); 206480a40e43SLars Ellenberg spin_unlock_irq(&mdev->req_lock); 2065b411b363SPhilipp Reisner 206645bb912bSLars Ellenberg if (drbd_submit_ee(mdev, e, READ, fault_type) == 0) 2067b411b363SPhilipp Reisner return TRUE; 2068b411b363SPhilipp Reisner 206922cc37a9SLars Ellenberg /* drbd_submit_ee currently fails for one reason only: 207022cc37a9SLars Ellenberg * not being able to allocate enough bios. 207122cc37a9SLars Ellenberg * Is dropping the connection going to help? */ 207222cc37a9SLars Ellenberg spin_lock_irq(&mdev->req_lock); 207322cc37a9SLars Ellenberg list_del(&e->w.list); 207422cc37a9SLars Ellenberg spin_unlock_irq(&mdev->req_lock); 207522cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 207622cc37a9SLars Ellenberg 2077b411b363SPhilipp Reisner out_free_e: 2078b411b363SPhilipp Reisner put_ldev(mdev); 2079b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 2080b411b363SPhilipp Reisner return FALSE; 2081b411b363SPhilipp Reisner } 2082b411b363SPhilipp Reisner 2083b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2084b411b363SPhilipp Reisner { 2085b411b363SPhilipp Reisner int self, peer, rv = -100; 2086b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2087b411b363SPhilipp Reisner 2088b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2089b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2090b411b363SPhilipp Reisner 2091b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2092b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2093b411b363SPhilipp Reisner 2094b411b363SPhilipp Reisner switch (mdev->net_conf->after_sb_0p) { 2095b411b363SPhilipp Reisner case ASB_CONSENSUS: 2096b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2097b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2098b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2099b411b363SPhilipp Reisner break; 2100b411b363SPhilipp Reisner case ASB_DISCONNECT: 2101b411b363SPhilipp Reisner break; 2102b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2103b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2104b411b363SPhilipp Reisner rv = -1; 2105b411b363SPhilipp Reisner break; 2106b411b363SPhilipp Reisner } 2107b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2108b411b363SPhilipp Reisner rv = 1; 2109b411b363SPhilipp Reisner break; 2110b411b363SPhilipp Reisner } 2111b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2112b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2113b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2114b411b363SPhilipp Reisner rv = 1; 2115b411b363SPhilipp Reisner break; 2116b411b363SPhilipp Reisner } 2117b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2118b411b363SPhilipp Reisner rv = -1; 2119b411b363SPhilipp Reisner break; 2120b411b363SPhilipp Reisner } 2121b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2122ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2123b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2124b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2125b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 2126b411b363SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->flags) 2127b411b363SPhilipp Reisner ? -1 : 1; 2128b411b363SPhilipp Reisner break; 2129b411b363SPhilipp Reisner } else { 2130b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2131b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2132b411b363SPhilipp Reisner } 2133b411b363SPhilipp Reisner if (mdev->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2134b411b363SPhilipp Reisner break; 2135b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2136b411b363SPhilipp Reisner if (ch_self < ch_peer) 2137b411b363SPhilipp Reisner rv = -1; 2138b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2139b411b363SPhilipp Reisner rv = 1; 2140b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2141b411b363SPhilipp Reisner /* Well, then use something else. */ 2142b411b363SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->flags) 2143b411b363SPhilipp Reisner ? -1 : 1; 2144b411b363SPhilipp Reisner break; 2145b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2146b411b363SPhilipp Reisner rv = -1; 2147b411b363SPhilipp Reisner break; 2148b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2149b411b363SPhilipp Reisner rv = 1; 2150b411b363SPhilipp Reisner } 2151b411b363SPhilipp Reisner 2152b411b363SPhilipp Reisner return rv; 2153b411b363SPhilipp Reisner } 2154b411b363SPhilipp Reisner 2155b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2156b411b363SPhilipp Reisner { 2157b411b363SPhilipp Reisner int self, peer, hg, rv = -100; 2158b411b363SPhilipp Reisner 2159b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2160b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2161b411b363SPhilipp Reisner 2162b411b363SPhilipp Reisner switch (mdev->net_conf->after_sb_1p) { 2163b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2164b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2165b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2166b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2167b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2168b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2169b411b363SPhilipp Reisner break; 2170b411b363SPhilipp Reisner case ASB_DISCONNECT: 2171b411b363SPhilipp Reisner break; 2172b411b363SPhilipp Reisner case ASB_CONSENSUS: 2173b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2174b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2175b411b363SPhilipp Reisner rv = hg; 2176b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2177b411b363SPhilipp Reisner rv = hg; 2178b411b363SPhilipp Reisner break; 2179b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2180b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2181b411b363SPhilipp Reisner break; 2182b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2183b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2184b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2185b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2186b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2187b411b363SPhilipp Reisner self = drbd_set_role(mdev, R_SECONDARY, 0); 2188b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2189b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2190b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2191b411b363SPhilipp Reisner self = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2192b411b363SPhilipp Reisner if (self != SS_SUCCESS) { 2193b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2194b411b363SPhilipp Reisner } else { 2195b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2196b411b363SPhilipp Reisner rv = hg; 2197b411b363SPhilipp Reisner } 2198b411b363SPhilipp Reisner } else 2199b411b363SPhilipp Reisner rv = hg; 2200b411b363SPhilipp Reisner } 2201b411b363SPhilipp Reisner 2202b411b363SPhilipp Reisner return rv; 2203b411b363SPhilipp Reisner } 2204b411b363SPhilipp Reisner 2205b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2206b411b363SPhilipp Reisner { 2207b411b363SPhilipp Reisner int self, peer, hg, rv = -100; 2208b411b363SPhilipp Reisner 2209b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2210b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2211b411b363SPhilipp Reisner 2212b411b363SPhilipp Reisner switch (mdev->net_conf->after_sb_2p) { 2213b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2214b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2215b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2216b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2217b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2218b411b363SPhilipp Reisner case ASB_CONSENSUS: 2219b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2220b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2221b411b363SPhilipp Reisner break; 2222b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2223b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2224b411b363SPhilipp Reisner break; 2225b411b363SPhilipp Reisner case ASB_DISCONNECT: 2226b411b363SPhilipp Reisner break; 2227b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2228b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2229b411b363SPhilipp Reisner if (hg == -1) { 2230b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2231b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2232b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2233b411b363SPhilipp Reisner self = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2234b411b363SPhilipp Reisner if (self != SS_SUCCESS) { 2235b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2236b411b363SPhilipp Reisner } else { 2237b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2238b411b363SPhilipp Reisner rv = hg; 2239b411b363SPhilipp Reisner } 2240b411b363SPhilipp Reisner } else 2241b411b363SPhilipp Reisner rv = hg; 2242b411b363SPhilipp Reisner } 2243b411b363SPhilipp Reisner 2244b411b363SPhilipp Reisner return rv; 2245b411b363SPhilipp Reisner } 2246b411b363SPhilipp Reisner 2247b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2248b411b363SPhilipp Reisner u64 bits, u64 flags) 2249b411b363SPhilipp Reisner { 2250b411b363SPhilipp Reisner if (!uuid) { 2251b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2252b411b363SPhilipp Reisner return; 2253b411b363SPhilipp Reisner } 2254b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2255b411b363SPhilipp Reisner text, 2256b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2257b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2258b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2259b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2260b411b363SPhilipp Reisner (unsigned long long)bits, 2261b411b363SPhilipp Reisner (unsigned long long)flags); 2262b411b363SPhilipp Reisner } 2263b411b363SPhilipp Reisner 2264b411b363SPhilipp Reisner /* 2265b411b363SPhilipp Reisner 100 after split brain try auto recover 2266b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2267b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2268b411b363SPhilipp Reisner 0 no Sync 2269b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2270b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2271b411b363SPhilipp Reisner -100 after split brain, disconnect 2272b411b363SPhilipp Reisner -1000 unrelated data 2273b411b363SPhilipp Reisner */ 2274b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2275b411b363SPhilipp Reisner { 2276b411b363SPhilipp Reisner u64 self, peer; 2277b411b363SPhilipp Reisner int i, j; 2278b411b363SPhilipp Reisner 2279b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2280b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2281b411b363SPhilipp Reisner 2282b411b363SPhilipp Reisner *rule_nr = 10; 2283b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2284b411b363SPhilipp Reisner return 0; 2285b411b363SPhilipp Reisner 2286b411b363SPhilipp Reisner *rule_nr = 20; 2287b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2288b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2289b411b363SPhilipp Reisner return -2; 2290b411b363SPhilipp Reisner 2291b411b363SPhilipp Reisner *rule_nr = 30; 2292b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2293b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2294b411b363SPhilipp Reisner return 2; 2295b411b363SPhilipp Reisner 2296b411b363SPhilipp Reisner if (self == peer) { 2297b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2298b411b363SPhilipp Reisner 2299b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2300b411b363SPhilipp Reisner 2301b411b363SPhilipp Reisner if (mdev->agreed_pro_version < 91) 2302b411b363SPhilipp Reisner return -1001; 2303b411b363SPhilipp Reisner 2304b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2305b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2306b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2307b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2308b411b363SPhilipp Reisner 2309b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2310b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2311b411b363SPhilipp Reisner *rule_nr = 34; 2312b411b363SPhilipp Reisner } else { 2313b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2314b411b363SPhilipp Reisner *rule_nr = 36; 2315b411b363SPhilipp Reisner } 2316b411b363SPhilipp Reisner 2317b411b363SPhilipp Reisner return 1; 2318b411b363SPhilipp Reisner } 2319b411b363SPhilipp Reisner 2320b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2321b411b363SPhilipp Reisner 2322b411b363SPhilipp Reisner if (mdev->agreed_pro_version < 91) 2323b411b363SPhilipp Reisner return -1001; 2324b411b363SPhilipp Reisner 2325b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2326b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2327b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2328b411b363SPhilipp Reisner 2329b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2330b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2331b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2332b411b363SPhilipp Reisner 2333b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2334b411b363SPhilipp Reisner *rule_nr = 35; 2335b411b363SPhilipp Reisner } else { 2336b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2337b411b363SPhilipp Reisner *rule_nr = 37; 2338b411b363SPhilipp Reisner } 2339b411b363SPhilipp Reisner 2340b411b363SPhilipp Reisner return -1; 2341b411b363SPhilipp Reisner } 2342b411b363SPhilipp Reisner 2343b411b363SPhilipp Reisner /* Common power [off|failure] */ 2344b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2345b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2346b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2347b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2348b411b363SPhilipp Reisner *rule_nr = 40; 2349b411b363SPhilipp Reisner 2350b411b363SPhilipp Reisner switch (rct) { 2351b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2352b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2353b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2354b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 2355b411b363SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->flags); 2356b411b363SPhilipp Reisner return dc ? -1 : 1; 2357b411b363SPhilipp Reisner } 2358b411b363SPhilipp Reisner } 2359b411b363SPhilipp Reisner 2360b411b363SPhilipp Reisner *rule_nr = 50; 2361b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2362b411b363SPhilipp Reisner if (self == peer) 2363b411b363SPhilipp Reisner return -1; 2364b411b363SPhilipp Reisner 2365b411b363SPhilipp Reisner *rule_nr = 51; 2366b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2367b411b363SPhilipp Reisner if (self == peer) { 2368b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2369b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1); 2370b411b363SPhilipp Reisner if (self == peer) { 2371b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2372b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2373b411b363SPhilipp Reisner 2374b411b363SPhilipp Reisner if (mdev->agreed_pro_version < 91) 2375b411b363SPhilipp Reisner return -1001; 2376b411b363SPhilipp Reisner 2377b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2378b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 2379b411b363SPhilipp Reisner return -1; 2380b411b363SPhilipp Reisner } 2381b411b363SPhilipp Reisner } 2382b411b363SPhilipp Reisner 2383b411b363SPhilipp Reisner *rule_nr = 60; 2384b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2385b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2386b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2387b411b363SPhilipp Reisner if (self == peer) 2388b411b363SPhilipp Reisner return -2; 2389b411b363SPhilipp Reisner } 2390b411b363SPhilipp Reisner 2391b411b363SPhilipp Reisner *rule_nr = 70; 2392b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2393b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2394b411b363SPhilipp Reisner if (self == peer) 2395b411b363SPhilipp Reisner return 1; 2396b411b363SPhilipp Reisner 2397b411b363SPhilipp Reisner *rule_nr = 71; 2398b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2399b411b363SPhilipp Reisner if (self == peer) { 2400b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1); 2401b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2402b411b363SPhilipp Reisner if (self == peer) { 2403b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2404b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2405b411b363SPhilipp Reisner 2406b411b363SPhilipp Reisner if (mdev->agreed_pro_version < 91) 2407b411b363SPhilipp Reisner return -1001; 2408b411b363SPhilipp Reisner 2409b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2410b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2411b411b363SPhilipp Reisner 2412b411b363SPhilipp Reisner dev_info(DEV, "Undid last start of resync:\n"); 2413b411b363SPhilipp Reisner 2414b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2415b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2416b411b363SPhilipp Reisner 2417b411b363SPhilipp Reisner return 1; 2418b411b363SPhilipp Reisner } 2419b411b363SPhilipp Reisner } 2420b411b363SPhilipp Reisner 2421b411b363SPhilipp Reisner 2422b411b363SPhilipp Reisner *rule_nr = 80; 2423d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2424b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2425b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2426b411b363SPhilipp Reisner if (self == peer) 2427b411b363SPhilipp Reisner return 2; 2428b411b363SPhilipp Reisner } 2429b411b363SPhilipp Reisner 2430b411b363SPhilipp Reisner *rule_nr = 90; 2431b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2432b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2433b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2434b411b363SPhilipp Reisner return 100; 2435b411b363SPhilipp Reisner 2436b411b363SPhilipp Reisner *rule_nr = 100; 2437b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2438b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2439b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2440b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2441b411b363SPhilipp Reisner if (self == peer) 2442b411b363SPhilipp Reisner return -100; 2443b411b363SPhilipp Reisner } 2444b411b363SPhilipp Reisner } 2445b411b363SPhilipp Reisner 2446b411b363SPhilipp Reisner return -1000; 2447b411b363SPhilipp Reisner } 2448b411b363SPhilipp Reisner 2449b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2450b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2451b411b363SPhilipp Reisner */ 2452b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2453b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2454b411b363SPhilipp Reisner { 2455b411b363SPhilipp Reisner int hg, rule_nr; 2456b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2457b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2458b411b363SPhilipp Reisner 2459b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2460b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2461b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2462b411b363SPhilipp Reisner 2463b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2464b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2465b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2466b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2467b411b363SPhilipp Reisner 2468b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2469b411b363SPhilipp Reisner 2470b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2471b411b363SPhilipp Reisner 2472b411b363SPhilipp Reisner if (hg == -1000) { 2473b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2474b411b363SPhilipp Reisner return C_MASK; 2475b411b363SPhilipp Reisner } 2476b411b363SPhilipp Reisner if (hg == -1001) { 2477b411b363SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol\n"); 2478b411b363SPhilipp Reisner return C_MASK; 2479b411b363SPhilipp Reisner } 2480b411b363SPhilipp Reisner 2481b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2482b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2483b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2484b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2485b411b363SPhilipp Reisner if (f) 2486b411b363SPhilipp Reisner hg = hg*2; 2487b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2488b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2489b411b363SPhilipp Reisner } 2490b411b363SPhilipp Reisner 24913a11a487SAdam Gandelman if (abs(hg) == 100) 24923a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 24933a11a487SAdam Gandelman 2494b411b363SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->net_conf->always_asbp)) { 2495b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2496b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2497b411b363SPhilipp Reisner int forced = (hg == -100); 2498b411b363SPhilipp Reisner 2499b411b363SPhilipp Reisner switch (pcount) { 2500b411b363SPhilipp Reisner case 0: 2501b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2502b411b363SPhilipp Reisner break; 2503b411b363SPhilipp Reisner case 1: 2504b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2505b411b363SPhilipp Reisner break; 2506b411b363SPhilipp Reisner case 2: 2507b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2508b411b363SPhilipp Reisner break; 2509b411b363SPhilipp Reisner } 2510b411b363SPhilipp Reisner if (abs(hg) < 100) { 2511b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2512b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2513b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2514b411b363SPhilipp Reisner if (forced) { 2515b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2516b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2517b411b363SPhilipp Reisner hg = hg*2; 2518b411b363SPhilipp Reisner } 2519b411b363SPhilipp Reisner } 2520b411b363SPhilipp Reisner } 2521b411b363SPhilipp Reisner 2522b411b363SPhilipp Reisner if (hg == -100) { 2523b411b363SPhilipp Reisner if (mdev->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2524b411b363SPhilipp Reisner hg = -1; 2525b411b363SPhilipp Reisner if (!mdev->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2526b411b363SPhilipp Reisner hg = 1; 2527b411b363SPhilipp Reisner 2528b411b363SPhilipp Reisner if (abs(hg) < 100) 2529b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2530b411b363SPhilipp Reisner "Sync from %s node\n", 2531b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2532b411b363SPhilipp Reisner } 2533b411b363SPhilipp Reisner 2534b411b363SPhilipp Reisner if (hg == -100) { 2535580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2536580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2537580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2538580b9767SLars Ellenberg * to that disk, in a way... */ 25393a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2540b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2541b411b363SPhilipp Reisner return C_MASK; 2542b411b363SPhilipp Reisner } 2543b411b363SPhilipp Reisner 2544b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2545b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2546b411b363SPhilipp Reisner return C_MASK; 2547b411b363SPhilipp Reisner } 2548b411b363SPhilipp Reisner 2549b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2550b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 2551b411b363SPhilipp Reisner switch (mdev->net_conf->rr_conflict) { 2552b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2553b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2554b411b363SPhilipp Reisner /* fall through */ 2555b411b363SPhilipp Reisner case ASB_DISCONNECT: 2556b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2557b411b363SPhilipp Reisner return C_MASK; 2558b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2559b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2560b411b363SPhilipp Reisner "assumption\n"); 2561b411b363SPhilipp Reisner } 2562b411b363SPhilipp Reisner } 2563b411b363SPhilipp Reisner 2564cf14c2e9SPhilipp Reisner if (mdev->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->flags)) { 2565cf14c2e9SPhilipp Reisner if (hg == 0) 2566cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2567cf14c2e9SPhilipp Reisner else 2568cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2569cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2570cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2571cf14c2e9SPhilipp Reisner return C_MASK; 2572cf14c2e9SPhilipp Reisner } 2573cf14c2e9SPhilipp Reisner 2574b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2575b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 2576b411b363SPhilipp Reisner if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake")) 2577b411b363SPhilipp Reisner return C_MASK; 2578b411b363SPhilipp Reisner } 2579b411b363SPhilipp Reisner 2580b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2581b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2582b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2583b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2584b411b363SPhilipp Reisner } else { 2585b411b363SPhilipp Reisner rv = C_CONNECTED; 2586b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2587b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2588b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2589b411b363SPhilipp Reisner } 2590b411b363SPhilipp Reisner } 2591b411b363SPhilipp Reisner 2592b411b363SPhilipp Reisner return rv; 2593b411b363SPhilipp Reisner } 2594b411b363SPhilipp Reisner 2595b411b363SPhilipp Reisner /* returns 1 if invalid */ 2596b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2597b411b363SPhilipp Reisner { 2598b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2599b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2600b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2601b411b363SPhilipp Reisner return 0; 2602b411b363SPhilipp Reisner 2603b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2604b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2605b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2606b411b363SPhilipp Reisner return 1; 2607b411b363SPhilipp Reisner 2608b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2609b411b363SPhilipp Reisner if (peer == self) 2610b411b363SPhilipp Reisner return 0; 2611b411b363SPhilipp Reisner 2612b411b363SPhilipp Reisner /* everything es is invalid. */ 2613b411b363SPhilipp Reisner return 1; 2614b411b363SPhilipp Reisner } 2615b411b363SPhilipp Reisner 261602918be2SPhilipp Reisner static int receive_protocol(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 2617b411b363SPhilipp Reisner { 261802918be2SPhilipp Reisner struct p_protocol *p = &mdev->data.rbuf.protocol; 2619b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2620cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2621b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2622b411b363SPhilipp Reisner 2623b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2624b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2625b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2626b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2627b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2628cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2629cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2630cf14c2e9SPhilipp Reisner 2631cf14c2e9SPhilipp Reisner clear_bit(CONN_DRY_RUN, &mdev->flags); 2632cf14c2e9SPhilipp Reisner 2633cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 2634cf14c2e9SPhilipp Reisner set_bit(CONN_DRY_RUN, &mdev->flags); 2635b411b363SPhilipp Reisner 2636b411b363SPhilipp Reisner if (p_proto != mdev->net_conf->wire_protocol) { 2637b411b363SPhilipp Reisner dev_err(DEV, "incompatible communication protocols\n"); 2638b411b363SPhilipp Reisner goto disconnect; 2639b411b363SPhilipp Reisner } 2640b411b363SPhilipp Reisner 2641b411b363SPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, mdev->net_conf->after_sb_0p)) { 2642b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-0pri settings\n"); 2643b411b363SPhilipp Reisner goto disconnect; 2644b411b363SPhilipp Reisner } 2645b411b363SPhilipp Reisner 2646b411b363SPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, mdev->net_conf->after_sb_1p)) { 2647b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-1pri settings\n"); 2648b411b363SPhilipp Reisner goto disconnect; 2649b411b363SPhilipp Reisner } 2650b411b363SPhilipp Reisner 2651b411b363SPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, mdev->net_conf->after_sb_2p)) { 2652b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-2pri settings\n"); 2653b411b363SPhilipp Reisner goto disconnect; 2654b411b363SPhilipp Reisner } 2655b411b363SPhilipp Reisner 2656b411b363SPhilipp Reisner if (p_want_lose && mdev->net_conf->want_lose) { 2657b411b363SPhilipp Reisner dev_err(DEV, "both sides have the 'want_lose' flag set\n"); 2658b411b363SPhilipp Reisner goto disconnect; 2659b411b363SPhilipp Reisner } 2660b411b363SPhilipp Reisner 2661b411b363SPhilipp Reisner if (p_two_primaries != mdev->net_conf->two_primaries) { 2662b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the two-primaries options\n"); 2663b411b363SPhilipp Reisner goto disconnect; 2664b411b363SPhilipp Reisner } 2665b411b363SPhilipp Reisner 2666b411b363SPhilipp Reisner if (mdev->agreed_pro_version >= 87) { 2667b411b363SPhilipp Reisner unsigned char *my_alg = mdev->net_conf->integrity_alg; 2668b411b363SPhilipp Reisner 2669b411b363SPhilipp Reisner if (drbd_recv(mdev, p_integrity_alg, data_size) != data_size) 2670b411b363SPhilipp Reisner return FALSE; 2671b411b363SPhilipp Reisner 2672b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2673b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 2674b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the data-integrity-alg\n"); 2675b411b363SPhilipp Reisner goto disconnect; 2676b411b363SPhilipp Reisner } 2677b411b363SPhilipp Reisner dev_info(DEV, "data-integrity-alg: %s\n", 2678b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2679b411b363SPhilipp Reisner } 2680b411b363SPhilipp Reisner 2681b411b363SPhilipp Reisner return TRUE; 2682b411b363SPhilipp Reisner 2683b411b363SPhilipp Reisner disconnect: 2684b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 2685b411b363SPhilipp Reisner return FALSE; 2686b411b363SPhilipp Reisner } 2687b411b363SPhilipp Reisner 2688b411b363SPhilipp Reisner /* helper function 2689b411b363SPhilipp Reisner * input: alg name, feature name 2690b411b363SPhilipp Reisner * return: NULL (alg name was "") 2691b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2692b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2693b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2694b411b363SPhilipp Reisner const char *alg, const char *name) 2695b411b363SPhilipp Reisner { 2696b411b363SPhilipp Reisner struct crypto_hash *tfm; 2697b411b363SPhilipp Reisner 2698b411b363SPhilipp Reisner if (!alg[0]) 2699b411b363SPhilipp Reisner return NULL; 2700b411b363SPhilipp Reisner 2701b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2702b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 2703b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 2704b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 2705b411b363SPhilipp Reisner return tfm; 2706b411b363SPhilipp Reisner } 2707b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 2708b411b363SPhilipp Reisner crypto_free_hash(tfm); 2709b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 2710b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 2711b411b363SPhilipp Reisner } 2712b411b363SPhilipp Reisner return tfm; 2713b411b363SPhilipp Reisner } 2714b411b363SPhilipp Reisner 271502918be2SPhilipp Reisner static int receive_SyncParam(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int packet_size) 2716b411b363SPhilipp Reisner { 2717b411b363SPhilipp Reisner int ok = TRUE; 271802918be2SPhilipp Reisner struct p_rs_param_95 *p = &mdev->data.rbuf.rs_param_95; 2719b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 2720b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 2721b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 2722b411b363SPhilipp Reisner const int apv = mdev->agreed_pro_version; 2723778f271dSPhilipp Reisner int *rs_plan_s = NULL; 2724778f271dSPhilipp Reisner int fifo_size = 0; 2725b411b363SPhilipp Reisner 2726b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 2727b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 2728b411b363SPhilipp Reisner + SHARED_SECRET_MAX 27298e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 27308e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 2731b411b363SPhilipp Reisner 273202918be2SPhilipp Reisner if (packet_size > exp_max_sz) { 2733b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 273402918be2SPhilipp Reisner packet_size, exp_max_sz); 2735b411b363SPhilipp Reisner return FALSE; 2736b411b363SPhilipp Reisner } 2737b411b363SPhilipp Reisner 2738b411b363SPhilipp Reisner if (apv <= 88) { 273902918be2SPhilipp Reisner header_size = sizeof(struct p_rs_param) - sizeof(struct p_header80); 274002918be2SPhilipp Reisner data_size = packet_size - header_size; 27418e26f9ccSPhilipp Reisner } else if (apv <= 94) { 274202918be2SPhilipp Reisner header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header80); 274302918be2SPhilipp Reisner data_size = packet_size - header_size; 2744b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 27458e26f9ccSPhilipp Reisner } else { 274602918be2SPhilipp Reisner header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header80); 274702918be2SPhilipp Reisner data_size = packet_size - header_size; 2748b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 2749b411b363SPhilipp Reisner } 2750b411b363SPhilipp Reisner 2751b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 2752b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 2753b411b363SPhilipp Reisner 275402918be2SPhilipp Reisner if (drbd_recv(mdev, &p->head.payload, header_size) != header_size) 2755b411b363SPhilipp Reisner return FALSE; 2756b411b363SPhilipp Reisner 2757b411b363SPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 2758b411b363SPhilipp Reisner 2759b411b363SPhilipp Reisner if (apv >= 88) { 2760b411b363SPhilipp Reisner if (apv == 88) { 2761b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 2762b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 2763b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 2764b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 2765b411b363SPhilipp Reisner return FALSE; 2766b411b363SPhilipp Reisner } 2767b411b363SPhilipp Reisner 2768b411b363SPhilipp Reisner if (drbd_recv(mdev, p->verify_alg, data_size) != data_size) 2769b411b363SPhilipp Reisner return FALSE; 2770b411b363SPhilipp Reisner 2771b411b363SPhilipp Reisner /* we expect NUL terminated string */ 2772b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2773b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 2774b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 2775b411b363SPhilipp Reisner 2776b411b363SPhilipp Reisner } else /* apv >= 89 */ { 2777b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 2778b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2779b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 2780b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 2781b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 2782b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 2783b411b363SPhilipp Reisner } 2784b411b363SPhilipp Reisner 2785b411b363SPhilipp Reisner if (strcmp(mdev->sync_conf.verify_alg, p->verify_alg)) { 2786b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2787b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 2788b411b363SPhilipp Reisner mdev->sync_conf.verify_alg, p->verify_alg); 2789b411b363SPhilipp Reisner goto disconnect; 2790b411b363SPhilipp Reisner } 2791b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 2792b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 2793b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 2794b411b363SPhilipp Reisner verify_tfm = NULL; 2795b411b363SPhilipp Reisner goto disconnect; 2796b411b363SPhilipp Reisner } 2797b411b363SPhilipp Reisner } 2798b411b363SPhilipp Reisner 2799b411b363SPhilipp Reisner if (apv >= 89 && strcmp(mdev->sync_conf.csums_alg, p->csums_alg)) { 2800b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2801b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 2802b411b363SPhilipp Reisner mdev->sync_conf.csums_alg, p->csums_alg); 2803b411b363SPhilipp Reisner goto disconnect; 2804b411b363SPhilipp Reisner } 2805b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 2806b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 2807b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 2808b411b363SPhilipp Reisner csums_tfm = NULL; 2809b411b363SPhilipp Reisner goto disconnect; 2810b411b363SPhilipp Reisner } 2811b411b363SPhilipp Reisner } 2812b411b363SPhilipp Reisner 28138e26f9ccSPhilipp Reisner if (apv > 94) { 28148e26f9ccSPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 28158e26f9ccSPhilipp Reisner mdev->sync_conf.c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 28168e26f9ccSPhilipp Reisner mdev->sync_conf.c_delay_target = be32_to_cpu(p->c_delay_target); 28178e26f9ccSPhilipp Reisner mdev->sync_conf.c_fill_target = be32_to_cpu(p->c_fill_target); 28188e26f9ccSPhilipp Reisner mdev->sync_conf.c_max_rate = be32_to_cpu(p->c_max_rate); 2819778f271dSPhilipp Reisner 2820778f271dSPhilipp Reisner fifo_size = (mdev->sync_conf.c_plan_ahead * 10 * SLEEP_TIME) / HZ; 2821778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) { 2822778f271dSPhilipp Reisner rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL); 2823778f271dSPhilipp Reisner if (!rs_plan_s) { 2824778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 2825778f271dSPhilipp Reisner goto disconnect; 2826778f271dSPhilipp Reisner } 2827778f271dSPhilipp Reisner } 28288e26f9ccSPhilipp Reisner } 2829b411b363SPhilipp Reisner 2830b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 2831b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 2832b411b363SPhilipp Reisner if (verify_tfm) { 2833b411b363SPhilipp Reisner strcpy(mdev->sync_conf.verify_alg, p->verify_alg); 2834b411b363SPhilipp Reisner mdev->sync_conf.verify_alg_len = strlen(p->verify_alg) + 1; 2835b411b363SPhilipp Reisner crypto_free_hash(mdev->verify_tfm); 2836b411b363SPhilipp Reisner mdev->verify_tfm = verify_tfm; 2837b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 2838b411b363SPhilipp Reisner } 2839b411b363SPhilipp Reisner if (csums_tfm) { 2840b411b363SPhilipp Reisner strcpy(mdev->sync_conf.csums_alg, p->csums_alg); 2841b411b363SPhilipp Reisner mdev->sync_conf.csums_alg_len = strlen(p->csums_alg) + 1; 2842b411b363SPhilipp Reisner crypto_free_hash(mdev->csums_tfm); 2843b411b363SPhilipp Reisner mdev->csums_tfm = csums_tfm; 2844b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 2845b411b363SPhilipp Reisner } 2846778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size) { 2847778f271dSPhilipp Reisner kfree(mdev->rs_plan_s.values); 2848778f271dSPhilipp Reisner mdev->rs_plan_s.values = rs_plan_s; 2849778f271dSPhilipp Reisner mdev->rs_plan_s.size = fifo_size; 2850778f271dSPhilipp Reisner mdev->rs_planed = 0; 2851778f271dSPhilipp Reisner } 2852b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 2853b411b363SPhilipp Reisner } 2854b411b363SPhilipp Reisner 2855b411b363SPhilipp Reisner return ok; 2856b411b363SPhilipp Reisner disconnect: 2857b411b363SPhilipp Reisner /* just for completeness: actually not needed, 2858b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 2859b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 2860b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 2861b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 2862b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 2863b411b363SPhilipp Reisner return FALSE; 2864b411b363SPhilipp Reisner } 2865b411b363SPhilipp Reisner 2866b411b363SPhilipp Reisner static void drbd_setup_order_type(struct drbd_conf *mdev, int peer) 2867b411b363SPhilipp Reisner { 2868b411b363SPhilipp Reisner /* sorry, we currently have no working implementation 2869b411b363SPhilipp Reisner * of distributed TCQ */ 2870b411b363SPhilipp Reisner } 2871b411b363SPhilipp Reisner 2872b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 2873b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 2874b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 2875b411b363SPhilipp Reisner { 2876b411b363SPhilipp Reisner sector_t d; 2877b411b363SPhilipp Reisner if (a == 0 || b == 0) 2878b411b363SPhilipp Reisner return; 2879b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 2880b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 2881b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 2882b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 2883b411b363SPhilipp Reisner } 2884b411b363SPhilipp Reisner 288502918be2SPhilipp Reisner static int receive_sizes(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 2886b411b363SPhilipp Reisner { 288702918be2SPhilipp Reisner struct p_sizes *p = &mdev->data.rbuf.sizes; 2888b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 2889b411b363SPhilipp Reisner unsigned int max_seg_s; 2890b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 2891b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 2892e89b591cSPhilipp Reisner enum dds_flags ddsf; 2893b411b363SPhilipp Reisner 2894b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 2895b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 2896b411b363SPhilipp Reisner 2897b411b363SPhilipp Reisner if (p_size == 0 && mdev->state.disk == D_DISKLESS) { 2898b411b363SPhilipp Reisner dev_err(DEV, "some backing storage is needed\n"); 2899b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 2900b411b363SPhilipp Reisner return FALSE; 2901b411b363SPhilipp Reisner } 2902b411b363SPhilipp Reisner 2903b411b363SPhilipp Reisner /* just store the peer's disk size for now. 2904b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 2905b411b363SPhilipp Reisner mdev->p_size = p_size; 2906b411b363SPhilipp Reisner 2907b411b363SPhilipp Reisner if (get_ldev(mdev)) { 2908b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 2909b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 2910b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 2911b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 2912b411b363SPhilipp Reisner 2913b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 2914b411b363SPhilipp Reisner * param exchange, choose the minimum */ 2915b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 2916b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 2917b411b363SPhilipp Reisner p_usize); 2918b411b363SPhilipp Reisner 2919b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 2920b411b363SPhilipp Reisner 2921b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 2922b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 2923b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 2924b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 2925b411b363SPhilipp Reisner } 2926b411b363SPhilipp Reisner 2927b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 2928b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 2929a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 2930b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 2931b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 2932b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 2933b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 2934b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 2935b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 2936b411b363SPhilipp Reisner put_ldev(mdev); 2937b411b363SPhilipp Reisner return FALSE; 2938b411b363SPhilipp Reisner } 2939b411b363SPhilipp Reisner put_ldev(mdev); 2940b411b363SPhilipp Reisner } 2941b411b363SPhilipp Reisner #undef min_not_zero 2942b411b363SPhilipp Reisner 2943e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 2944b411b363SPhilipp Reisner if (get_ldev(mdev)) { 2945e89b591cSPhilipp Reisner dd = drbd_determin_dev_size(mdev, ddsf); 2946b411b363SPhilipp Reisner put_ldev(mdev); 2947b411b363SPhilipp Reisner if (dd == dev_size_error) 2948b411b363SPhilipp Reisner return FALSE; 2949b411b363SPhilipp Reisner drbd_md_sync(mdev); 2950b411b363SPhilipp Reisner } else { 2951b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 2952b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 2953b411b363SPhilipp Reisner } 2954b411b363SPhilipp Reisner 2955b411b363SPhilipp Reisner if (get_ldev(mdev)) { 2956b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 2957b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 2958b411b363SPhilipp Reisner ldsc = 1; 2959b411b363SPhilipp Reisner } 2960b411b363SPhilipp Reisner 2961a1c88d0dSLars Ellenberg if (mdev->agreed_pro_version < 94) 2962b411b363SPhilipp Reisner max_seg_s = be32_to_cpu(p->max_segment_size); 29638979d9c9SLars Ellenberg else if (mdev->agreed_pro_version == 94) 29648979d9c9SLars Ellenberg max_seg_s = DRBD_MAX_SIZE_H80_PACKET; 2965a1c88d0dSLars Ellenberg else /* drbd 8.3.8 onwards */ 2966a1c88d0dSLars Ellenberg max_seg_s = DRBD_MAX_SEGMENT_SIZE; 2967a1c88d0dSLars Ellenberg 2968b411b363SPhilipp Reisner if (max_seg_s != queue_max_segment_size(mdev->rq_queue)) 2969b411b363SPhilipp Reisner drbd_setup_queue_param(mdev, max_seg_s); 2970b411b363SPhilipp Reisner 2971e89b591cSPhilipp Reisner drbd_setup_order_type(mdev, be16_to_cpu(p->queue_order_type)); 2972b411b363SPhilipp Reisner put_ldev(mdev); 2973b411b363SPhilipp Reisner } 2974b411b363SPhilipp Reisner 2975b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 2976b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 2977b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 2978b411b363SPhilipp Reisner /* we have different sizes, probably peer 2979b411b363SPhilipp Reisner * needs to know my new size... */ 2980e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 2981b411b363SPhilipp Reisner } 2982b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 2983b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 2984b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 2985e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 2986e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 2987e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 2988b411b363SPhilipp Reisner else 2989e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 2990e89b591cSPhilipp Reisner } else 2991b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 2992b411b363SPhilipp Reisner } 2993b411b363SPhilipp Reisner } 2994b411b363SPhilipp Reisner 2995b411b363SPhilipp Reisner return TRUE; 2996b411b363SPhilipp Reisner } 2997b411b363SPhilipp Reisner 299802918be2SPhilipp Reisner static int receive_uuids(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 2999b411b363SPhilipp Reisner { 300002918be2SPhilipp Reisner struct p_uuids *p = &mdev->data.rbuf.uuids; 3001b411b363SPhilipp Reisner u64 *p_uuid; 3002b411b363SPhilipp Reisner int i; 3003b411b363SPhilipp Reisner 3004b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3005b411b363SPhilipp Reisner 3006b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3007b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3008b411b363SPhilipp Reisner 3009b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3010b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3011b411b363SPhilipp Reisner 3012b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3013b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3014b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3015b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3016b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3017b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 3018b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3019b411b363SPhilipp Reisner return FALSE; 3020b411b363SPhilipp Reisner } 3021b411b363SPhilipp Reisner 3022b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3023b411b363SPhilipp Reisner int skip_initial_sync = 3024b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 3025b411b363SPhilipp Reisner mdev->agreed_pro_version >= 90 && 3026b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3027b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3028b411b363SPhilipp Reisner if (skip_initial_sync) { 3029b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3030b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 3031b411b363SPhilipp Reisner "clear_n_write from receive_uuids"); 3032b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3033b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3034b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3035b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3036b411b363SPhilipp Reisner drbd_md_sync(mdev); 3037b411b363SPhilipp Reisner } 3038b411b363SPhilipp Reisner put_ldev(mdev); 303918a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 304018a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 304118a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 304218a50fa2SPhilipp Reisner for me. */ 304318a50fa2SPhilipp Reisner drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3044b411b363SPhilipp Reisner } 3045b411b363SPhilipp Reisner 3046b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3047b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3048b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3049b411b363SPhilipp Reisner new disk state... */ 3050b411b363SPhilipp Reisner wait_event(mdev->misc_wait, !test_bit(CLUSTER_ST_CHANGE, &mdev->flags)); 3051b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 3052b411b363SPhilipp Reisner drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3053b411b363SPhilipp Reisner 3054b411b363SPhilipp Reisner return TRUE; 3055b411b363SPhilipp Reisner } 3056b411b363SPhilipp Reisner 3057b411b363SPhilipp Reisner /** 3058b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3059b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3060b411b363SPhilipp Reisner */ 3061b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3062b411b363SPhilipp Reisner { 3063b411b363SPhilipp Reisner union drbd_state ms; 3064b411b363SPhilipp Reisner 3065b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3066b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3067b411b363SPhilipp Reisner 3068b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3069b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3070b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3071b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3072b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3073b411b363SPhilipp Reisner }; 3074b411b363SPhilipp Reisner 3075b411b363SPhilipp Reisner ms.i = ps.i; 3076b411b363SPhilipp Reisner 3077b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3078b411b363SPhilipp Reisner ms.peer = ps.role; 3079b411b363SPhilipp Reisner ms.role = ps.peer; 3080b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3081b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3082b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3083b411b363SPhilipp Reisner 3084b411b363SPhilipp Reisner return ms; 3085b411b363SPhilipp Reisner } 3086b411b363SPhilipp Reisner 308702918be2SPhilipp Reisner static int receive_req_state(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3088b411b363SPhilipp Reisner { 308902918be2SPhilipp Reisner struct p_req_state *p = &mdev->data.rbuf.req_state; 3090b411b363SPhilipp Reisner union drbd_state mask, val; 3091b411b363SPhilipp Reisner int rv; 3092b411b363SPhilipp Reisner 3093b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3094b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3095b411b363SPhilipp Reisner 3096b411b363SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->flags) && 3097b411b363SPhilipp Reisner test_bit(CLUSTER_ST_CHANGE, &mdev->flags)) { 3098b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 3099b411b363SPhilipp Reisner return TRUE; 3100b411b363SPhilipp Reisner } 3101b411b363SPhilipp Reisner 3102b411b363SPhilipp Reisner mask = convert_state(mask); 3103b411b363SPhilipp Reisner val = convert_state(val); 3104b411b363SPhilipp Reisner 3105b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3106b411b363SPhilipp Reisner 3107b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3108b411b363SPhilipp Reisner drbd_md_sync(mdev); 3109b411b363SPhilipp Reisner 3110b411b363SPhilipp Reisner return TRUE; 3111b411b363SPhilipp Reisner } 3112b411b363SPhilipp Reisner 311302918be2SPhilipp Reisner static int receive_state(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3114b411b363SPhilipp Reisner { 311502918be2SPhilipp Reisner struct p_state *p = &mdev->data.rbuf.state; 31164ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3117b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 311865d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3119b411b363SPhilipp Reisner int rv; 3120b411b363SPhilipp Reisner 3121b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3122b411b363SPhilipp Reisner 3123b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3124b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3125b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3126b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3127b411b363SPhilipp Reisner } 3128b411b363SPhilipp Reisner 3129b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3130b411b363SPhilipp Reisner retry: 31314ac4aadaSLars Ellenberg os = ns = mdev->state; 3132b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3133b411b363SPhilipp Reisner 3134e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3135e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3136e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3137e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3138e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3139e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3140e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3141e9ef7bb6SLars Ellenberg * syncing states. 3142e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3143e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3144e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3145e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3146e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3147e9ef7bb6SLars Ellenberg 3148e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3149e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3150e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3151e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3152e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3153e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3154e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 3155e9ef7bb6SLars Ellenberg return TRUE; 3156e9ef7bb6SLars Ellenberg } 3157e9ef7bb6SLars Ellenberg } 3158e9ef7bb6SLars Ellenberg 3159e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3160e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3161e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3162e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3163e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3164e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3165e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3166e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3167e9ef7bb6SLars Ellenberg 31684ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 31694ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3170b411b363SPhilipp Reisner 3171b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3172b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3173b411b363SPhilipp Reisner int cr; /* consider resync */ 3174b411b363SPhilipp Reisner 3175b411b363SPhilipp Reisner /* if we established a new connection */ 31764ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3177b411b363SPhilipp Reisner /* if we had an established connection 3178b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 31794ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3180b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 31814ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3182b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3183b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3184b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3185b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3186b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 31874ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3188b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3189b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3190b411b363SPhilipp Reisner 3191b411b363SPhilipp Reisner if (cr) 31924ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3193b411b363SPhilipp Reisner 3194b411b363SPhilipp Reisner put_ldev(mdev); 31954ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 31964ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3197b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 319882f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3199b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3200b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3201b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3202580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3203b411b363SPhilipp Reisner } else { 3204cf14c2e9SPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->flags)) 3205cf14c2e9SPhilipp Reisner return FALSE; 32064ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 3207b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3208b411b363SPhilipp Reisner return FALSE; 3209b411b363SPhilipp Reisner } 3210b411b363SPhilipp Reisner } 3211b411b363SPhilipp Reisner } 3212b411b363SPhilipp Reisner 3213b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 32144ac4aadaSLars Ellenberg if (mdev->state.i != os.i) 3215b411b363SPhilipp Reisner goto retry; 3216b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3217b411b363SPhilipp Reisner ns.peer = peer_state.role; 3218b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3219b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 32204ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3221b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 32224ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 32234ac4aadaSLars Ellenberg if (ns.pdsk == D_CONSISTENT && is_susp(ns) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3224481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 3225481c6f50SPhilipp Reisner /* Do not allow tl_restart(resend) for a rebooted peer. We can only allow this 3226481c6f50SPhilipp Reisner for temporal network outages! */ 3227481c6f50SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3228481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 3229481c6f50SPhilipp Reisner tl_clear(mdev); 3230481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3231481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 3232481c6f50SPhilipp Reisner drbd_force_state(mdev, NS2(conn, C_PROTOCOL_ERROR, susp, 0)); 3233481c6f50SPhilipp Reisner return FALSE; 3234481c6f50SPhilipp Reisner } 323565d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 3236b411b363SPhilipp Reisner ns = mdev->state; 3237b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3238b411b363SPhilipp Reisner 3239b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 3240b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3241b411b363SPhilipp Reisner return FALSE; 3242b411b363SPhilipp Reisner } 3243b411b363SPhilipp Reisner 32444ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 32454ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3246b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3247b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3248b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3249b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3250b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3251b411b363SPhilipp Reisner drbd_send_state(mdev); 3252b411b363SPhilipp Reisner } 3253b411b363SPhilipp Reisner } 3254b411b363SPhilipp Reisner 3255b411b363SPhilipp Reisner mdev->net_conf->want_lose = 0; 3256b411b363SPhilipp Reisner 3257b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3258b411b363SPhilipp Reisner 3259b411b363SPhilipp Reisner return TRUE; 3260b411b363SPhilipp Reisner } 3261b411b363SPhilipp Reisner 326202918be2SPhilipp Reisner static int receive_sync_uuid(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3263b411b363SPhilipp Reisner { 326402918be2SPhilipp Reisner struct p_rs_uuid *p = &mdev->data.rbuf.rs_uuid; 3265b411b363SPhilipp Reisner 3266b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3267b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3268b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3269b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3270b411b363SPhilipp Reisner 3271b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3272b411b363SPhilipp Reisner 3273b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3274b411b363SPhilipp Reisner _not_ be rotated into the history */ 3275b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3276b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3277b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3278b411b363SPhilipp Reisner 3279b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3280b411b363SPhilipp Reisner 3281b411b363SPhilipp Reisner put_ldev(mdev); 3282b411b363SPhilipp Reisner } else 3283b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3284b411b363SPhilipp Reisner 3285b411b363SPhilipp Reisner return TRUE; 3286b411b363SPhilipp Reisner } 3287b411b363SPhilipp Reisner 3288b411b363SPhilipp Reisner enum receive_bitmap_ret { OK, DONE, FAILED }; 3289b411b363SPhilipp Reisner 3290b411b363SPhilipp Reisner static enum receive_bitmap_ret 329102918be2SPhilipp Reisner receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size, 3292b411b363SPhilipp Reisner unsigned long *buffer, struct bm_xfer_ctx *c) 3293b411b363SPhilipp Reisner { 3294b411b363SPhilipp Reisner unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset); 3295b411b363SPhilipp Reisner unsigned want = num_words * sizeof(long); 3296b411b363SPhilipp Reisner 329702918be2SPhilipp Reisner if (want != data_size) { 329802918be2SPhilipp Reisner dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size); 3299b411b363SPhilipp Reisner return FAILED; 3300b411b363SPhilipp Reisner } 3301b411b363SPhilipp Reisner if (want == 0) 3302b411b363SPhilipp Reisner return DONE; 3303b411b363SPhilipp Reisner if (drbd_recv(mdev, buffer, want) != want) 3304b411b363SPhilipp Reisner return FAILED; 3305b411b363SPhilipp Reisner 3306b411b363SPhilipp Reisner drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer); 3307b411b363SPhilipp Reisner 3308b411b363SPhilipp Reisner c->word_offset += num_words; 3309b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3310b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3311b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3312b411b363SPhilipp Reisner 3313b411b363SPhilipp Reisner return OK; 3314b411b363SPhilipp Reisner } 3315b411b363SPhilipp Reisner 3316b411b363SPhilipp Reisner static enum receive_bitmap_ret 3317b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3318b411b363SPhilipp Reisner struct p_compressed_bm *p, 3319b411b363SPhilipp Reisner struct bm_xfer_ctx *c) 3320b411b363SPhilipp Reisner { 3321b411b363SPhilipp Reisner struct bitstream bs; 3322b411b363SPhilipp Reisner u64 look_ahead; 3323b411b363SPhilipp Reisner u64 rl; 3324b411b363SPhilipp Reisner u64 tmp; 3325b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3326b411b363SPhilipp Reisner unsigned long e; 3327004352faSLars Ellenberg int len = be16_to_cpu(p->head.length) - (sizeof(*p) - sizeof(p->head)); 3328b411b363SPhilipp Reisner int toggle = DCBP_get_start(p); 3329b411b363SPhilipp Reisner int have; 3330b411b363SPhilipp Reisner int bits; 3331b411b363SPhilipp Reisner 3332b411b363SPhilipp Reisner bitstream_init(&bs, p->code, len, DCBP_get_pad_bits(p)); 3333b411b363SPhilipp Reisner 3334b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3335b411b363SPhilipp Reisner if (bits < 0) 3336b411b363SPhilipp Reisner return FAILED; 3337b411b363SPhilipp Reisner 3338b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3339b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3340b411b363SPhilipp Reisner if (bits <= 0) 3341b411b363SPhilipp Reisner return FAILED; 3342b411b363SPhilipp Reisner 3343b411b363SPhilipp Reisner if (toggle) { 3344b411b363SPhilipp Reisner e = s + rl -1; 3345b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3346b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 3347b411b363SPhilipp Reisner return FAILED; 3348b411b363SPhilipp Reisner } 3349b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3350b411b363SPhilipp Reisner } 3351b411b363SPhilipp Reisner 3352b411b363SPhilipp Reisner if (have < bits) { 3353b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3354b411b363SPhilipp Reisner have, bits, look_ahead, 3355b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3356b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 3357b411b363SPhilipp Reisner return FAILED; 3358b411b363SPhilipp Reisner } 3359b411b363SPhilipp Reisner look_ahead >>= bits; 3360b411b363SPhilipp Reisner have -= bits; 3361b411b363SPhilipp Reisner 3362b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3363b411b363SPhilipp Reisner if (bits < 0) 3364b411b363SPhilipp Reisner return FAILED; 3365b411b363SPhilipp Reisner look_ahead |= tmp << have; 3366b411b363SPhilipp Reisner have += bits; 3367b411b363SPhilipp Reisner } 3368b411b363SPhilipp Reisner 3369b411b363SPhilipp Reisner c->bit_offset = s; 3370b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3371b411b363SPhilipp Reisner 3372b411b363SPhilipp Reisner return (s == c->bm_bits) ? DONE : OK; 3373b411b363SPhilipp Reisner } 3374b411b363SPhilipp Reisner 3375b411b363SPhilipp Reisner static enum receive_bitmap_ret 3376b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3377b411b363SPhilipp Reisner struct p_compressed_bm *p, 3378b411b363SPhilipp Reisner struct bm_xfer_ctx *c) 3379b411b363SPhilipp Reisner { 3380b411b363SPhilipp Reisner if (DCBP_get_code(p) == RLE_VLI_Bits) 3381b411b363SPhilipp Reisner return recv_bm_rle_bits(mdev, p, c); 3382b411b363SPhilipp Reisner 3383b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3384b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3385b411b363SPhilipp Reisner * during all our tests. */ 3386b411b363SPhilipp Reisner 3387b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 3388b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 3389b411b363SPhilipp Reisner return FAILED; 3390b411b363SPhilipp Reisner } 3391b411b363SPhilipp Reisner 3392b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3393b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3394b411b363SPhilipp Reisner { 3395b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 33960b70a13dSPhilipp Reisner unsigned plain = sizeof(struct p_header80) * 3397b411b363SPhilipp Reisner ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1) 3398b411b363SPhilipp Reisner + c->bm_words * sizeof(long); 3399b411b363SPhilipp Reisner unsigned total = c->bytes[0] + c->bytes[1]; 3400b411b363SPhilipp Reisner unsigned r; 3401b411b363SPhilipp Reisner 3402b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3403b411b363SPhilipp Reisner if (total == 0) 3404b411b363SPhilipp Reisner return; 3405b411b363SPhilipp Reisner 3406b411b363SPhilipp Reisner /* don't report if not compressed */ 3407b411b363SPhilipp Reisner if (total >= plain) 3408b411b363SPhilipp Reisner return; 3409b411b363SPhilipp Reisner 3410b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3411b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3412b411b363SPhilipp Reisner : (1000 * total / plain); 3413b411b363SPhilipp Reisner 3414b411b363SPhilipp Reisner if (r > 1000) 3415b411b363SPhilipp Reisner r = 1000; 3416b411b363SPhilipp Reisner 3417b411b363SPhilipp Reisner r = 1000 - r; 3418b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3419b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3420b411b363SPhilipp Reisner direction, 3421b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3422b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3423b411b363SPhilipp Reisner total, r/10, r % 10); 3424b411b363SPhilipp Reisner } 3425b411b363SPhilipp Reisner 3426b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3427b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3428b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3429b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3430b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3431b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3432b411b363SPhilipp Reisner 3433b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 343402918be2SPhilipp Reisner static int receive_bitmap(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3435b411b363SPhilipp Reisner { 3436b411b363SPhilipp Reisner struct bm_xfer_ctx c; 3437b411b363SPhilipp Reisner void *buffer; 3438b411b363SPhilipp Reisner enum receive_bitmap_ret ret; 3439b411b363SPhilipp Reisner int ok = FALSE; 344002918be2SPhilipp Reisner struct p_header80 *h = &mdev->data.rbuf.header.h80; 3441b411b363SPhilipp Reisner 3442b411b363SPhilipp Reisner wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt)); 3443b411b363SPhilipp Reisner 3444b411b363SPhilipp Reisner drbd_bm_lock(mdev, "receive bitmap"); 3445b411b363SPhilipp Reisner 3446b411b363SPhilipp Reisner /* maybe we should use some per thread scratch page, 3447b411b363SPhilipp Reisner * and allocate that during initial device creation? */ 3448b411b363SPhilipp Reisner buffer = (unsigned long *) __get_free_page(GFP_NOIO); 3449b411b363SPhilipp Reisner if (!buffer) { 3450b411b363SPhilipp Reisner dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__); 3451b411b363SPhilipp Reisner goto out; 3452b411b363SPhilipp Reisner } 3453b411b363SPhilipp Reisner 3454b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3455b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3456b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3457b411b363SPhilipp Reisner }; 3458b411b363SPhilipp Reisner 3459b411b363SPhilipp Reisner do { 346002918be2SPhilipp Reisner if (cmd == P_BITMAP) { 346102918be2SPhilipp Reisner ret = receive_bitmap_plain(mdev, data_size, buffer, &c); 346202918be2SPhilipp Reisner } else if (cmd == P_COMPRESSED_BITMAP) { 3463b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3464b411b363SPhilipp Reisner * and the feature is enabled! */ 3465b411b363SPhilipp Reisner struct p_compressed_bm *p; 3466b411b363SPhilipp Reisner 346702918be2SPhilipp Reisner if (data_size > BM_PACKET_PAYLOAD_BYTES) { 3468b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 3469b411b363SPhilipp Reisner goto out; 3470b411b363SPhilipp Reisner } 3471b411b363SPhilipp Reisner /* use the page buff */ 3472b411b363SPhilipp Reisner p = buffer; 3473b411b363SPhilipp Reisner memcpy(p, h, sizeof(*h)); 347402918be2SPhilipp Reisner if (drbd_recv(mdev, p->head.payload, data_size) != data_size) 3475b411b363SPhilipp Reisner goto out; 3476004352faSLars Ellenberg if (data_size <= (sizeof(*p) - sizeof(p->head))) { 3477004352faSLars Ellenberg dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", data_size); 3478b411b363SPhilipp Reisner return FAILED; 3479b411b363SPhilipp Reisner } 3480b411b363SPhilipp Reisner ret = decode_bitmap_c(mdev, p, &c); 3481b411b363SPhilipp Reisner } else { 348202918be2SPhilipp Reisner dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", cmd); 3483b411b363SPhilipp Reisner goto out; 3484b411b363SPhilipp Reisner } 3485b411b363SPhilipp Reisner 348602918be2SPhilipp Reisner c.packets[cmd == P_BITMAP]++; 348702918be2SPhilipp Reisner c.bytes[cmd == P_BITMAP] += sizeof(struct p_header80) + data_size; 3488b411b363SPhilipp Reisner 3489b411b363SPhilipp Reisner if (ret != OK) 3490b411b363SPhilipp Reisner break; 3491b411b363SPhilipp Reisner 349202918be2SPhilipp Reisner if (!drbd_recv_header(mdev, &cmd, &data_size)) 3493b411b363SPhilipp Reisner goto out; 3494b411b363SPhilipp Reisner } while (ret == OK); 3495b411b363SPhilipp Reisner if (ret == FAILED) 3496b411b363SPhilipp Reisner goto out; 3497b411b363SPhilipp Reisner 3498b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3499b411b363SPhilipp Reisner 3500b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3501b411b363SPhilipp Reisner ok = !drbd_send_bitmap(mdev); 3502b411b363SPhilipp Reisner if (!ok) 3503b411b363SPhilipp Reisner goto out; 3504b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3505b411b363SPhilipp Reisner ok = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3506b411b363SPhilipp Reisner D_ASSERT(ok == SS_SUCCESS); 3507b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3508b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3509b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3510b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3511b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3512b411b363SPhilipp Reisner } 3513b411b363SPhilipp Reisner 3514b411b363SPhilipp Reisner ok = TRUE; 3515b411b363SPhilipp Reisner out: 3516b411b363SPhilipp Reisner drbd_bm_unlock(mdev); 3517b411b363SPhilipp Reisner if (ok && mdev->state.conn == C_WF_BITMAP_S) 3518b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 3519b411b363SPhilipp Reisner free_page((unsigned long) buffer); 3520b411b363SPhilipp Reisner return ok; 3521b411b363SPhilipp Reisner } 3522b411b363SPhilipp Reisner 352302918be2SPhilipp Reisner static int receive_skip(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3524b411b363SPhilipp Reisner { 3525b411b363SPhilipp Reisner /* TODO zero copy sink :) */ 3526b411b363SPhilipp Reisner static char sink[128]; 3527b411b363SPhilipp Reisner int size, want, r; 3528b411b363SPhilipp Reisner 3529b411b363SPhilipp Reisner dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n", 353002918be2SPhilipp Reisner cmd, data_size); 3531b411b363SPhilipp Reisner 353202918be2SPhilipp Reisner size = data_size; 3533b411b363SPhilipp Reisner while (size > 0) { 3534b411b363SPhilipp Reisner want = min_t(int, size, sizeof(sink)); 3535b411b363SPhilipp Reisner r = drbd_recv(mdev, sink, want); 3536b411b363SPhilipp Reisner ERR_IF(r <= 0) break; 3537b411b363SPhilipp Reisner size -= r; 3538b411b363SPhilipp Reisner } 3539b411b363SPhilipp Reisner return size == 0; 3540b411b363SPhilipp Reisner } 3541b411b363SPhilipp Reisner 354202918be2SPhilipp Reisner static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3543b411b363SPhilipp Reisner { 3544b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3545b411b363SPhilipp Reisner * with the data requests being unplugged */ 3546b411b363SPhilipp Reisner drbd_tcp_quickack(mdev->data.socket); 3547b411b363SPhilipp Reisner 3548b411b363SPhilipp Reisner return TRUE; 3549b411b363SPhilipp Reisner } 3550b411b363SPhilipp Reisner 355102918be2SPhilipp Reisner typedef int (*drbd_cmd_handler_f)(struct drbd_conf *, enum drbd_packets cmd, unsigned int to_receive); 3552b411b363SPhilipp Reisner 355302918be2SPhilipp Reisner struct data_cmd { 355402918be2SPhilipp Reisner int expect_payload; 355502918be2SPhilipp Reisner size_t pkt_size; 355602918be2SPhilipp Reisner drbd_cmd_handler_f function; 3557b411b363SPhilipp Reisner }; 3558b411b363SPhilipp Reisner 355902918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 356002918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 356102918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 356202918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 356302918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 356402918be2SPhilipp Reisner [P_BITMAP] = { 1, sizeof(struct p_header80), receive_bitmap } , 356502918be2SPhilipp Reisner [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header80), receive_bitmap } , 356602918be2SPhilipp Reisner [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header80), receive_UnplugRemote }, 356702918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 356802918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 356902918be2SPhilipp Reisner [P_SYNC_PARAM] = { 1, sizeof(struct p_header80), receive_SyncParam }, 357002918be2SPhilipp Reisner [P_SYNC_PARAM89] = { 1, sizeof(struct p_header80), receive_SyncParam }, 357102918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 357202918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 357302918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 357402918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 357502918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 357602918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 357702918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 357802918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 357902918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 358002918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 358102918be2SPhilipp Reisner /* anything missing from this table is in 358202918be2SPhilipp Reisner * the asender_tbl, see get_asender_cmd */ 358302918be2SPhilipp Reisner [P_MAX_CMD] = { 0, 0, NULL }, 358402918be2SPhilipp Reisner }; 358502918be2SPhilipp Reisner 358602918be2SPhilipp Reisner /* All handler functions that expect a sub-header get that sub-heder in 358702918be2SPhilipp Reisner mdev->data.rbuf.header.head.payload. 358802918be2SPhilipp Reisner 358902918be2SPhilipp Reisner Usually in mdev->data.rbuf.header.head the callback can find the usual 359002918be2SPhilipp Reisner p_header, but they may not rely on that. Since there is also p_header95 ! 359102918be2SPhilipp Reisner */ 3592b411b363SPhilipp Reisner 3593b411b363SPhilipp Reisner static void drbdd(struct drbd_conf *mdev) 3594b411b363SPhilipp Reisner { 359502918be2SPhilipp Reisner union p_header *header = &mdev->data.rbuf.header; 359602918be2SPhilipp Reisner unsigned int packet_size; 359702918be2SPhilipp Reisner enum drbd_packets cmd; 359802918be2SPhilipp Reisner size_t shs; /* sub header size */ 359902918be2SPhilipp Reisner int rv; 3600b411b363SPhilipp Reisner 3601b411b363SPhilipp Reisner while (get_t_state(&mdev->receiver) == Running) { 3602b411b363SPhilipp Reisner drbd_thread_current_set_cpu(mdev); 360302918be2SPhilipp Reisner if (!drbd_recv_header(mdev, &cmd, &packet_size)) 360402918be2SPhilipp Reisner goto err_out; 360502918be2SPhilipp Reisner 360602918be2SPhilipp Reisner if (unlikely(cmd >= P_MAX_CMD || !drbd_cmd_handler[cmd].function)) { 360702918be2SPhilipp Reisner dev_err(DEV, "unknown packet type %d, l: %d!\n", cmd, packet_size); 360802918be2SPhilipp Reisner goto err_out; 36090b33a916SLars Ellenberg } 3610b411b363SPhilipp Reisner 361102918be2SPhilipp Reisner shs = drbd_cmd_handler[cmd].pkt_size - sizeof(union p_header); 3612c13f7e1aSLars Ellenberg if (packet_size - shs > 0 && !drbd_cmd_handler[cmd].expect_payload) { 3613c13f7e1aSLars Ellenberg dev_err(DEV, "No payload expected %s l:%d\n", cmdname(cmd), packet_size); 3614c13f7e1aSLars Ellenberg goto err_out; 3615c13f7e1aSLars Ellenberg } 3616c13f7e1aSLars Ellenberg 3617c13f7e1aSLars Ellenberg if (shs) { 361802918be2SPhilipp Reisner rv = drbd_recv(mdev, &header->h80.payload, shs); 361902918be2SPhilipp Reisner if (unlikely(rv != shs)) { 362002918be2SPhilipp Reisner dev_err(DEV, "short read while reading sub header: rv=%d\n", rv); 362102918be2SPhilipp Reisner goto err_out; 3622b411b363SPhilipp Reisner } 362302918be2SPhilipp Reisner } 362402918be2SPhilipp Reisner 362502918be2SPhilipp Reisner rv = drbd_cmd_handler[cmd].function(mdev, cmd, packet_size - shs); 362602918be2SPhilipp Reisner 362702918be2SPhilipp Reisner if (unlikely(!rv)) { 3628b411b363SPhilipp Reisner dev_err(DEV, "error receiving %s, l: %d!\n", 362902918be2SPhilipp Reisner cmdname(cmd), packet_size); 363002918be2SPhilipp Reisner goto err_out; 3631b411b363SPhilipp Reisner } 3632b411b363SPhilipp Reisner } 363302918be2SPhilipp Reisner 363402918be2SPhilipp Reisner if (0) { 363502918be2SPhilipp Reisner err_out: 3636b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 3637b411b363SPhilipp Reisner } 3638856c50c7SLars Ellenberg /* If we leave here, we probably want to update at least the 3639856c50c7SLars Ellenberg * "Connected" indicator on stable storage. Do so explicitly here. */ 3640856c50c7SLars Ellenberg drbd_md_sync(mdev); 3641b411b363SPhilipp Reisner } 3642b411b363SPhilipp Reisner 3643b411b363SPhilipp Reisner void drbd_flush_workqueue(struct drbd_conf *mdev) 3644b411b363SPhilipp Reisner { 3645b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 3646b411b363SPhilipp Reisner 3647b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 3648b411b363SPhilipp Reisner init_completion(&barr.done); 3649b411b363SPhilipp Reisner drbd_queue_work(&mdev->data.work, &barr.w); 3650b411b363SPhilipp Reisner wait_for_completion(&barr.done); 3651b411b363SPhilipp Reisner } 3652b411b363SPhilipp Reisner 3653f70b3511SPhilipp Reisner void drbd_free_tl_hash(struct drbd_conf *mdev) 3654f70b3511SPhilipp Reisner { 3655f70b3511SPhilipp Reisner struct hlist_head *h; 3656f70b3511SPhilipp Reisner 3657f70b3511SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3658f70b3511SPhilipp Reisner 3659f70b3511SPhilipp Reisner if (!mdev->tl_hash || mdev->state.conn != C_STANDALONE) { 3660f70b3511SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3661f70b3511SPhilipp Reisner return; 3662f70b3511SPhilipp Reisner } 3663f70b3511SPhilipp Reisner /* paranoia code */ 3664f70b3511SPhilipp Reisner for (h = mdev->ee_hash; h < mdev->ee_hash + mdev->ee_hash_s; h++) 3665f70b3511SPhilipp Reisner if (h->first) 3666f70b3511SPhilipp Reisner dev_err(DEV, "ASSERT FAILED ee_hash[%u].first == %p, expected NULL\n", 3667f70b3511SPhilipp Reisner (int)(h - mdev->ee_hash), h->first); 3668f70b3511SPhilipp Reisner kfree(mdev->ee_hash); 3669f70b3511SPhilipp Reisner mdev->ee_hash = NULL; 3670f70b3511SPhilipp Reisner mdev->ee_hash_s = 0; 3671f70b3511SPhilipp Reisner 3672f70b3511SPhilipp Reisner /* paranoia code */ 3673f70b3511SPhilipp Reisner for (h = mdev->tl_hash; h < mdev->tl_hash + mdev->tl_hash_s; h++) 3674f70b3511SPhilipp Reisner if (h->first) 3675f70b3511SPhilipp Reisner dev_err(DEV, "ASSERT FAILED tl_hash[%u] == %p, expected NULL\n", 3676f70b3511SPhilipp Reisner (int)(h - mdev->tl_hash), h->first); 3677f70b3511SPhilipp Reisner kfree(mdev->tl_hash); 3678f70b3511SPhilipp Reisner mdev->tl_hash = NULL; 3679f70b3511SPhilipp Reisner mdev->tl_hash_s = 0; 3680f70b3511SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3681f70b3511SPhilipp Reisner } 3682f70b3511SPhilipp Reisner 3683b411b363SPhilipp Reisner static void drbd_disconnect(struct drbd_conf *mdev) 3684b411b363SPhilipp Reisner { 3685b411b363SPhilipp Reisner enum drbd_fencing_p fp; 3686b411b363SPhilipp Reisner union drbd_state os, ns; 3687b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 3688b411b363SPhilipp Reisner unsigned int i; 3689b411b363SPhilipp Reisner 3690b411b363SPhilipp Reisner if (mdev->state.conn == C_STANDALONE) 3691b411b363SPhilipp Reisner return; 3692b411b363SPhilipp Reisner if (mdev->state.conn >= C_WF_CONNECTION) 3693b411b363SPhilipp Reisner dev_err(DEV, "ASSERT FAILED cstate = %s, expected < WFConnection\n", 3694b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3695b411b363SPhilipp Reisner 3696b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 3697b411b363SPhilipp Reisner drbd_thread_stop(&mdev->asender); 3698b411b363SPhilipp Reisner drbd_free_sock(mdev); 3699b411b363SPhilipp Reisner 370085719573SPhilipp Reisner /* wait for current activity to cease. */ 3701b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3702b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 3703b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 3704b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 3705b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3706b411b363SPhilipp Reisner 3707b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 3708b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 3709b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 3710b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 3711b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 3712b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 3713b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 3714b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 3715b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 3716b411b363SPhilipp Reisner * on the fly. */ 3717b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 3718b411b363SPhilipp Reisner mdev->rs_total = 0; 3719b411b363SPhilipp Reisner mdev->rs_failed = 0; 3720b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 3721b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 3722b411b363SPhilipp Reisner 3723b411b363SPhilipp Reisner /* make sure syncer is stopped and w_resume_next_sg queued */ 3724b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 3725b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 3726b411b363SPhilipp Reisner 3727b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 3728b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 3729b411b363SPhilipp Reisner * to be "canceled" */ 3730b411b363SPhilipp Reisner drbd_flush_workqueue(mdev); 3731b411b363SPhilipp Reisner 3732b411b363SPhilipp Reisner /* This also does reclaim_net_ee(). If we do this too early, we might 3733b411b363SPhilipp Reisner * miss some resync ee and pages.*/ 3734b411b363SPhilipp Reisner drbd_process_done_ee(mdev); 3735b411b363SPhilipp Reisner 3736b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3737b411b363SPhilipp Reisner mdev->p_uuid = NULL; 3738b411b363SPhilipp Reisner 3739fb22c402SPhilipp Reisner if (!is_susp(mdev->state)) 3740b411b363SPhilipp Reisner tl_clear(mdev); 3741b411b363SPhilipp Reisner 3742b411b363SPhilipp Reisner dev_info(DEV, "Connection closed\n"); 3743b411b363SPhilipp Reisner 3744b411b363SPhilipp Reisner drbd_md_sync(mdev); 3745b411b363SPhilipp Reisner 3746b411b363SPhilipp Reisner fp = FP_DONT_CARE; 3747b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3748b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 3749b411b363SPhilipp Reisner put_ldev(mdev); 3750b411b363SPhilipp Reisner } 3751b411b363SPhilipp Reisner 375287f7be4cSPhilipp Reisner if (mdev->state.role == R_PRIMARY && fp >= FP_RESOURCE && mdev->state.pdsk >= D_UNKNOWN) 375387f7be4cSPhilipp Reisner drbd_try_outdate_peer_async(mdev); 3754b411b363SPhilipp Reisner 3755b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3756b411b363SPhilipp Reisner os = mdev->state; 3757b411b363SPhilipp Reisner if (os.conn >= C_UNCONNECTED) { 3758b411b363SPhilipp Reisner /* Do not restart in case we are C_DISCONNECTING */ 3759b411b363SPhilipp Reisner ns = os; 3760b411b363SPhilipp Reisner ns.conn = C_UNCONNECTED; 3761b411b363SPhilipp Reisner rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 3762b411b363SPhilipp Reisner } 3763b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3764b411b363SPhilipp Reisner 3765b411b363SPhilipp Reisner if (os.conn == C_DISCONNECTING) { 376684dfb9f5SPhilipp Reisner wait_event(mdev->net_cnt_wait, atomic_read(&mdev->net_cnt) == 0); 3767b411b363SPhilipp Reisner 3768fb22c402SPhilipp Reisner if (!is_susp(mdev->state)) { 3769b411b363SPhilipp Reisner /* we must not free the tl_hash 3770b411b363SPhilipp Reisner * while application io is still on the fly */ 3771f70b3511SPhilipp Reisner wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt)); 3772f70b3511SPhilipp Reisner drbd_free_tl_hash(mdev); 3773f70b3511SPhilipp Reisner } 3774b411b363SPhilipp Reisner 3775b411b363SPhilipp Reisner crypto_free_hash(mdev->cram_hmac_tfm); 3776b411b363SPhilipp Reisner mdev->cram_hmac_tfm = NULL; 3777b411b363SPhilipp Reisner 3778b411b363SPhilipp Reisner kfree(mdev->net_conf); 3779b411b363SPhilipp Reisner mdev->net_conf = NULL; 3780b411b363SPhilipp Reisner drbd_request_state(mdev, NS(conn, C_STANDALONE)); 3781b411b363SPhilipp Reisner } 3782b411b363SPhilipp Reisner 3783b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 3784b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 3785b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 3786b411b363SPhilipp Reisner * 3787b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 3788b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 3789b411b363SPhilipp Reisner */ 3790b411b363SPhilipp Reisner i = drbd_release_ee(mdev, &mdev->net_ee); 3791b411b363SPhilipp Reisner if (i) 3792b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 3793435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 3794435f0740SLars Ellenberg if (i) 3795435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 3796b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 3797b411b363SPhilipp Reisner if (i) 379845bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 3799b411b363SPhilipp Reisner 3800b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 3801b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 3802b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 3803b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 3804b411b363SPhilipp Reisner 3805b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 3806b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 3807b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 3808b411b363SPhilipp Reisner } 3809b411b363SPhilipp Reisner 3810b411b363SPhilipp Reisner /* 3811b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 3812b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 3813b411b363SPhilipp Reisner * 3814b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 3815b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 3816b411b363SPhilipp Reisner * 3817b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 3818b411b363SPhilipp Reisner */ 3819b411b363SPhilipp Reisner static int drbd_send_handshake(struct drbd_conf *mdev) 3820b411b363SPhilipp Reisner { 3821b411b363SPhilipp Reisner /* ASSERT current == mdev->receiver ... */ 3822b411b363SPhilipp Reisner struct p_handshake *p = &mdev->data.sbuf.handshake; 3823b411b363SPhilipp Reisner int ok; 3824b411b363SPhilipp Reisner 3825b411b363SPhilipp Reisner if (mutex_lock_interruptible(&mdev->data.mutex)) { 3826b411b363SPhilipp Reisner dev_err(DEV, "interrupted during initial handshake\n"); 3827b411b363SPhilipp Reisner return 0; /* interrupted. not ok. */ 3828b411b363SPhilipp Reisner } 3829b411b363SPhilipp Reisner 3830b411b363SPhilipp Reisner if (mdev->data.socket == NULL) { 3831b411b363SPhilipp Reisner mutex_unlock(&mdev->data.mutex); 3832b411b363SPhilipp Reisner return 0; 3833b411b363SPhilipp Reisner } 3834b411b363SPhilipp Reisner 3835b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 3836b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 3837b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 3838b411b363SPhilipp Reisner ok = _drbd_send_cmd( mdev, mdev->data.socket, P_HAND_SHAKE, 38390b70a13dSPhilipp Reisner (struct p_header80 *)p, sizeof(*p), 0 ); 3840b411b363SPhilipp Reisner mutex_unlock(&mdev->data.mutex); 3841b411b363SPhilipp Reisner return ok; 3842b411b363SPhilipp Reisner } 3843b411b363SPhilipp Reisner 3844b411b363SPhilipp Reisner /* 3845b411b363SPhilipp Reisner * return values: 3846b411b363SPhilipp Reisner * 1 yes, we have a valid connection 3847b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 3848b411b363SPhilipp Reisner * -1 peer talks different language, 3849b411b363SPhilipp Reisner * no point in trying again, please go standalone. 3850b411b363SPhilipp Reisner */ 3851b411b363SPhilipp Reisner static int drbd_do_handshake(struct drbd_conf *mdev) 3852b411b363SPhilipp Reisner { 3853b411b363SPhilipp Reisner /* ASSERT current == mdev->receiver ... */ 3854b411b363SPhilipp Reisner struct p_handshake *p = &mdev->data.rbuf.handshake; 385502918be2SPhilipp Reisner const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80); 385602918be2SPhilipp Reisner unsigned int length; 385702918be2SPhilipp Reisner enum drbd_packets cmd; 3858b411b363SPhilipp Reisner int rv; 3859b411b363SPhilipp Reisner 3860b411b363SPhilipp Reisner rv = drbd_send_handshake(mdev); 3861b411b363SPhilipp Reisner if (!rv) 3862b411b363SPhilipp Reisner return 0; 3863b411b363SPhilipp Reisner 386402918be2SPhilipp Reisner rv = drbd_recv_header(mdev, &cmd, &length); 3865b411b363SPhilipp Reisner if (!rv) 3866b411b363SPhilipp Reisner return 0; 3867b411b363SPhilipp Reisner 386802918be2SPhilipp Reisner if (cmd != P_HAND_SHAKE) { 3869b411b363SPhilipp Reisner dev_err(DEV, "expected HandShake packet, received: %s (0x%04x)\n", 387002918be2SPhilipp Reisner cmdname(cmd), cmd); 3871b411b363SPhilipp Reisner return -1; 3872b411b363SPhilipp Reisner } 3873b411b363SPhilipp Reisner 387402918be2SPhilipp Reisner if (length != expect) { 3875b411b363SPhilipp Reisner dev_err(DEV, "expected HandShake length: %u, received: %u\n", 387602918be2SPhilipp Reisner expect, length); 3877b411b363SPhilipp Reisner return -1; 3878b411b363SPhilipp Reisner } 3879b411b363SPhilipp Reisner 3880b411b363SPhilipp Reisner rv = drbd_recv(mdev, &p->head.payload, expect); 3881b411b363SPhilipp Reisner 3882b411b363SPhilipp Reisner if (rv != expect) { 3883b411b363SPhilipp Reisner dev_err(DEV, "short read receiving handshake packet: l=%u\n", rv); 3884b411b363SPhilipp Reisner return 0; 3885b411b363SPhilipp Reisner } 3886b411b363SPhilipp Reisner 3887b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 3888b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 3889b411b363SPhilipp Reisner if (p->protocol_max == 0) 3890b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 3891b411b363SPhilipp Reisner 3892b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 3893b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 3894b411b363SPhilipp Reisner goto incompat; 3895b411b363SPhilipp Reisner 3896b411b363SPhilipp Reisner mdev->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 3897b411b363SPhilipp Reisner 3898b411b363SPhilipp Reisner dev_info(DEV, "Handshake successful: " 3899b411b363SPhilipp Reisner "Agreed network protocol version %d\n", mdev->agreed_pro_version); 3900b411b363SPhilipp Reisner 3901b411b363SPhilipp Reisner return 1; 3902b411b363SPhilipp Reisner 3903b411b363SPhilipp Reisner incompat: 3904b411b363SPhilipp Reisner dev_err(DEV, "incompatible DRBD dialects: " 3905b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 3906b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 3907b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 3908b411b363SPhilipp Reisner return -1; 3909b411b363SPhilipp Reisner } 3910b411b363SPhilipp Reisner 3911b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 3912b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev) 3913b411b363SPhilipp Reisner { 3914b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 3915b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 3916b10d96cbSJohannes Thoma return -1; 3917b411b363SPhilipp Reisner } 3918b411b363SPhilipp Reisner #else 3919b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 3920b10d96cbSJohannes Thoma 3921b10d96cbSJohannes Thoma /* Return value: 3922b10d96cbSJohannes Thoma 1 - auth succeeded, 3923b10d96cbSJohannes Thoma 0 - failed, try again (network error), 3924b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 3925b10d96cbSJohannes Thoma */ 3926b10d96cbSJohannes Thoma 3927b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev) 3928b411b363SPhilipp Reisner { 3929b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 3930b411b363SPhilipp Reisner struct scatterlist sg; 3931b411b363SPhilipp Reisner char *response = NULL; 3932b411b363SPhilipp Reisner char *right_response = NULL; 3933b411b363SPhilipp Reisner char *peers_ch = NULL; 3934b411b363SPhilipp Reisner unsigned int key_len = strlen(mdev->net_conf->shared_secret); 3935b411b363SPhilipp Reisner unsigned int resp_size; 3936b411b363SPhilipp Reisner struct hash_desc desc; 393702918be2SPhilipp Reisner enum drbd_packets cmd; 393802918be2SPhilipp Reisner unsigned int length; 3939b411b363SPhilipp Reisner int rv; 3940b411b363SPhilipp Reisner 3941b411b363SPhilipp Reisner desc.tfm = mdev->cram_hmac_tfm; 3942b411b363SPhilipp Reisner desc.flags = 0; 3943b411b363SPhilipp Reisner 3944b411b363SPhilipp Reisner rv = crypto_hash_setkey(mdev->cram_hmac_tfm, 3945b411b363SPhilipp Reisner (u8 *)mdev->net_conf->shared_secret, key_len); 3946b411b363SPhilipp Reisner if (rv) { 3947b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_setkey() failed with %d\n", rv); 3948b10d96cbSJohannes Thoma rv = -1; 3949b411b363SPhilipp Reisner goto fail; 3950b411b363SPhilipp Reisner } 3951b411b363SPhilipp Reisner 3952b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 3953b411b363SPhilipp Reisner 3954b411b363SPhilipp Reisner rv = drbd_send_cmd2(mdev, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN); 3955b411b363SPhilipp Reisner if (!rv) 3956b411b363SPhilipp Reisner goto fail; 3957b411b363SPhilipp Reisner 395802918be2SPhilipp Reisner rv = drbd_recv_header(mdev, &cmd, &length); 3959b411b363SPhilipp Reisner if (!rv) 3960b411b363SPhilipp Reisner goto fail; 3961b411b363SPhilipp Reisner 396202918be2SPhilipp Reisner if (cmd != P_AUTH_CHALLENGE) { 3963b411b363SPhilipp Reisner dev_err(DEV, "expected AuthChallenge packet, received: %s (0x%04x)\n", 396402918be2SPhilipp Reisner cmdname(cmd), cmd); 3965b411b363SPhilipp Reisner rv = 0; 3966b411b363SPhilipp Reisner goto fail; 3967b411b363SPhilipp Reisner } 3968b411b363SPhilipp Reisner 396902918be2SPhilipp Reisner if (length > CHALLENGE_LEN * 2) { 3970b411b363SPhilipp Reisner dev_err(DEV, "expected AuthChallenge payload too big.\n"); 3971b10d96cbSJohannes Thoma rv = -1; 3972b411b363SPhilipp Reisner goto fail; 3973b411b363SPhilipp Reisner } 3974b411b363SPhilipp Reisner 397502918be2SPhilipp Reisner peers_ch = kmalloc(length, GFP_NOIO); 3976b411b363SPhilipp Reisner if (peers_ch == NULL) { 3977b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of peers_ch failed\n"); 3978b10d96cbSJohannes Thoma rv = -1; 3979b411b363SPhilipp Reisner goto fail; 3980b411b363SPhilipp Reisner } 3981b411b363SPhilipp Reisner 398202918be2SPhilipp Reisner rv = drbd_recv(mdev, peers_ch, length); 3983b411b363SPhilipp Reisner 398402918be2SPhilipp Reisner if (rv != length) { 3985b411b363SPhilipp Reisner dev_err(DEV, "short read AuthChallenge: l=%u\n", rv); 3986b411b363SPhilipp Reisner rv = 0; 3987b411b363SPhilipp Reisner goto fail; 3988b411b363SPhilipp Reisner } 3989b411b363SPhilipp Reisner 3990b411b363SPhilipp Reisner resp_size = crypto_hash_digestsize(mdev->cram_hmac_tfm); 3991b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 3992b411b363SPhilipp Reisner if (response == NULL) { 3993b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of response failed\n"); 3994b10d96cbSJohannes Thoma rv = -1; 3995b411b363SPhilipp Reisner goto fail; 3996b411b363SPhilipp Reisner } 3997b411b363SPhilipp Reisner 3998b411b363SPhilipp Reisner sg_init_table(&sg, 1); 399902918be2SPhilipp Reisner sg_set_buf(&sg, peers_ch, length); 4000b411b363SPhilipp Reisner 4001b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4002b411b363SPhilipp Reisner if (rv) { 4003b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv); 4004b10d96cbSJohannes Thoma rv = -1; 4005b411b363SPhilipp Reisner goto fail; 4006b411b363SPhilipp Reisner } 4007b411b363SPhilipp Reisner 4008b411b363SPhilipp Reisner rv = drbd_send_cmd2(mdev, P_AUTH_RESPONSE, response, resp_size); 4009b411b363SPhilipp Reisner if (!rv) 4010b411b363SPhilipp Reisner goto fail; 4011b411b363SPhilipp Reisner 401202918be2SPhilipp Reisner rv = drbd_recv_header(mdev, &cmd, &length); 4013b411b363SPhilipp Reisner if (!rv) 4014b411b363SPhilipp Reisner goto fail; 4015b411b363SPhilipp Reisner 401602918be2SPhilipp Reisner if (cmd != P_AUTH_RESPONSE) { 4017b411b363SPhilipp Reisner dev_err(DEV, "expected AuthResponse packet, received: %s (0x%04x)\n", 401802918be2SPhilipp Reisner cmdname(cmd), cmd); 4019b411b363SPhilipp Reisner rv = 0; 4020b411b363SPhilipp Reisner goto fail; 4021b411b363SPhilipp Reisner } 4022b411b363SPhilipp Reisner 402302918be2SPhilipp Reisner if (length != resp_size) { 4024b411b363SPhilipp Reisner dev_err(DEV, "expected AuthResponse payload of wrong size\n"); 4025b411b363SPhilipp Reisner rv = 0; 4026b411b363SPhilipp Reisner goto fail; 4027b411b363SPhilipp Reisner } 4028b411b363SPhilipp Reisner 4029b411b363SPhilipp Reisner rv = drbd_recv(mdev, response , resp_size); 4030b411b363SPhilipp Reisner 4031b411b363SPhilipp Reisner if (rv != resp_size) { 4032b411b363SPhilipp Reisner dev_err(DEV, "short read receiving AuthResponse: l=%u\n", rv); 4033b411b363SPhilipp Reisner rv = 0; 4034b411b363SPhilipp Reisner goto fail; 4035b411b363SPhilipp Reisner } 4036b411b363SPhilipp Reisner 4037b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 40382d1ee87dSJulia Lawall if (right_response == NULL) { 4039b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of right_response failed\n"); 4040b10d96cbSJohannes Thoma rv = -1; 4041b411b363SPhilipp Reisner goto fail; 4042b411b363SPhilipp Reisner } 4043b411b363SPhilipp Reisner 4044b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4045b411b363SPhilipp Reisner 4046b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4047b411b363SPhilipp Reisner if (rv) { 4048b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv); 4049b10d96cbSJohannes Thoma rv = -1; 4050b411b363SPhilipp Reisner goto fail; 4051b411b363SPhilipp Reisner } 4052b411b363SPhilipp Reisner 4053b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4054b411b363SPhilipp Reisner 4055b411b363SPhilipp Reisner if (rv) 4056b411b363SPhilipp Reisner dev_info(DEV, "Peer authenticated using %d bytes of '%s' HMAC\n", 4057b411b363SPhilipp Reisner resp_size, mdev->net_conf->cram_hmac_alg); 4058b10d96cbSJohannes Thoma else 4059b10d96cbSJohannes Thoma rv = -1; 4060b411b363SPhilipp Reisner 4061b411b363SPhilipp Reisner fail: 4062b411b363SPhilipp Reisner kfree(peers_ch); 4063b411b363SPhilipp Reisner kfree(response); 4064b411b363SPhilipp Reisner kfree(right_response); 4065b411b363SPhilipp Reisner 4066b411b363SPhilipp Reisner return rv; 4067b411b363SPhilipp Reisner } 4068b411b363SPhilipp Reisner #endif 4069b411b363SPhilipp Reisner 4070b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4071b411b363SPhilipp Reisner { 4072b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 4073b411b363SPhilipp Reisner unsigned int minor = mdev_to_minor(mdev); 4074b411b363SPhilipp Reisner int h; 4075b411b363SPhilipp Reisner 4076b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_receiver", minor); 4077b411b363SPhilipp Reisner 4078b411b363SPhilipp Reisner dev_info(DEV, "receiver (re)started\n"); 4079b411b363SPhilipp Reisner 4080b411b363SPhilipp Reisner do { 4081b411b363SPhilipp Reisner h = drbd_connect(mdev); 4082b411b363SPhilipp Reisner if (h == 0) { 4083b411b363SPhilipp Reisner drbd_disconnect(mdev); 4084b411b363SPhilipp Reisner __set_current_state(TASK_INTERRUPTIBLE); 4085b411b363SPhilipp Reisner schedule_timeout(HZ); 4086b411b363SPhilipp Reisner } 4087b411b363SPhilipp Reisner if (h == -1) { 4088b411b363SPhilipp Reisner dev_warn(DEV, "Discarding network configuration.\n"); 4089b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 4090b411b363SPhilipp Reisner } 4091b411b363SPhilipp Reisner } while (h == 0); 4092b411b363SPhilipp Reisner 4093b411b363SPhilipp Reisner if (h > 0) { 4094b411b363SPhilipp Reisner if (get_net_conf(mdev)) { 4095b411b363SPhilipp Reisner drbdd(mdev); 4096b411b363SPhilipp Reisner put_net_conf(mdev); 4097b411b363SPhilipp Reisner } 4098b411b363SPhilipp Reisner } 4099b411b363SPhilipp Reisner 4100b411b363SPhilipp Reisner drbd_disconnect(mdev); 4101b411b363SPhilipp Reisner 4102b411b363SPhilipp Reisner dev_info(DEV, "receiver terminated\n"); 4103b411b363SPhilipp Reisner return 0; 4104b411b363SPhilipp Reisner } 4105b411b363SPhilipp Reisner 4106b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4107b411b363SPhilipp Reisner 41080b70a13dSPhilipp Reisner static int got_RqSReply(struct drbd_conf *mdev, struct p_header80 *h) 4109b411b363SPhilipp Reisner { 4110b411b363SPhilipp Reisner struct p_req_state_reply *p = (struct p_req_state_reply *)h; 4111b411b363SPhilipp Reisner 4112b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4113b411b363SPhilipp Reisner 4114b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4115b411b363SPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4116b411b363SPhilipp Reisner } else { 4117b411b363SPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4118b411b363SPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4119b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4120b411b363SPhilipp Reisner } 4121b411b363SPhilipp Reisner wake_up(&mdev->state_wait); 4122b411b363SPhilipp Reisner 4123b411b363SPhilipp Reisner return TRUE; 4124b411b363SPhilipp Reisner } 4125b411b363SPhilipp Reisner 41260b70a13dSPhilipp Reisner static int got_Ping(struct drbd_conf *mdev, struct p_header80 *h) 4127b411b363SPhilipp Reisner { 4128b411b363SPhilipp Reisner return drbd_send_ping_ack(mdev); 4129b411b363SPhilipp Reisner 4130b411b363SPhilipp Reisner } 4131b411b363SPhilipp Reisner 41320b70a13dSPhilipp Reisner static int got_PingAck(struct drbd_conf *mdev, struct p_header80 *h) 4133b411b363SPhilipp Reisner { 4134b411b363SPhilipp Reisner /* restore idle timeout */ 4135b411b363SPhilipp Reisner mdev->meta.socket->sk->sk_rcvtimeo = mdev->net_conf->ping_int*HZ; 4136309d1608SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &mdev->flags)) 4137309d1608SPhilipp Reisner wake_up(&mdev->misc_wait); 4138b411b363SPhilipp Reisner 4139b411b363SPhilipp Reisner return TRUE; 4140b411b363SPhilipp Reisner } 4141b411b363SPhilipp Reisner 41420b70a13dSPhilipp Reisner static int got_IsInSync(struct drbd_conf *mdev, struct p_header80 *h) 4143b411b363SPhilipp Reisner { 4144b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4145b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4146b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4147b411b363SPhilipp Reisner 4148b411b363SPhilipp Reisner D_ASSERT(mdev->agreed_pro_version >= 89); 4149b411b363SPhilipp Reisner 4150b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4151b411b363SPhilipp Reisner 41521d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4153b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4154b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4155b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4156b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 41571d53f09eSLars Ellenberg put_ldev(mdev); 41581d53f09eSLars Ellenberg } 4159b411b363SPhilipp Reisner dec_rs_pending(mdev); 4160778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4161b411b363SPhilipp Reisner 4162b411b363SPhilipp Reisner return TRUE; 4163b411b363SPhilipp Reisner } 4164b411b363SPhilipp Reisner 4165b411b363SPhilipp Reisner /* when we receive the ACK for a write request, 4166b411b363SPhilipp Reisner * verify that we actually know about it */ 4167b411b363SPhilipp Reisner static struct drbd_request *_ack_id_to_req(struct drbd_conf *mdev, 4168b411b363SPhilipp Reisner u64 id, sector_t sector) 4169b411b363SPhilipp Reisner { 4170b411b363SPhilipp Reisner struct hlist_head *slot = tl_hash_slot(mdev, sector); 4171b411b363SPhilipp Reisner struct hlist_node *n; 4172b411b363SPhilipp Reisner struct drbd_request *req; 4173b411b363SPhilipp Reisner 4174b411b363SPhilipp Reisner hlist_for_each_entry(req, n, slot, colision) { 4175b411b363SPhilipp Reisner if ((unsigned long)req == (unsigned long)id) { 4176b411b363SPhilipp Reisner if (req->sector != sector) { 4177b411b363SPhilipp Reisner dev_err(DEV, "_ack_id_to_req: found req %p but it has " 4178b411b363SPhilipp Reisner "wrong sector (%llus versus %llus)\n", req, 4179b411b363SPhilipp Reisner (unsigned long long)req->sector, 4180b411b363SPhilipp Reisner (unsigned long long)sector); 4181b411b363SPhilipp Reisner break; 4182b411b363SPhilipp Reisner } 4183b411b363SPhilipp Reisner return req; 4184b411b363SPhilipp Reisner } 4185b411b363SPhilipp Reisner } 4186b411b363SPhilipp Reisner dev_err(DEV, "_ack_id_to_req: failed to find req %p, sector %llus in list\n", 4187b411b363SPhilipp Reisner (void *)(unsigned long)id, (unsigned long long)sector); 4188b411b363SPhilipp Reisner return NULL; 4189b411b363SPhilipp Reisner } 4190b411b363SPhilipp Reisner 4191b411b363SPhilipp Reisner typedef struct drbd_request *(req_validator_fn) 4192b411b363SPhilipp Reisner (struct drbd_conf *mdev, u64 id, sector_t sector); 4193b411b363SPhilipp Reisner 4194b411b363SPhilipp Reisner static int validate_req_change_req_state(struct drbd_conf *mdev, 4195b411b363SPhilipp Reisner u64 id, sector_t sector, req_validator_fn validator, 4196b411b363SPhilipp Reisner const char *func, enum drbd_req_event what) 4197b411b363SPhilipp Reisner { 4198b411b363SPhilipp Reisner struct drbd_request *req; 4199b411b363SPhilipp Reisner struct bio_and_error m; 4200b411b363SPhilipp Reisner 4201b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 4202b411b363SPhilipp Reisner req = validator(mdev, id, sector); 4203b411b363SPhilipp Reisner if (unlikely(!req)) { 4204b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 4205b411b363SPhilipp Reisner dev_err(DEV, "%s: got a corrupt block_id/sector pair\n", func); 4206b411b363SPhilipp Reisner return FALSE; 4207b411b363SPhilipp Reisner } 4208b411b363SPhilipp Reisner __req_mod(req, what, &m); 4209b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 4210b411b363SPhilipp Reisner 4211b411b363SPhilipp Reisner if (m.bio) 4212b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 4213b411b363SPhilipp Reisner return TRUE; 4214b411b363SPhilipp Reisner } 4215b411b363SPhilipp Reisner 42160b70a13dSPhilipp Reisner static int got_BlockAck(struct drbd_conf *mdev, struct p_header80 *h) 4217b411b363SPhilipp Reisner { 4218b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4219b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4220b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4221b411b363SPhilipp Reisner enum drbd_req_event what; 4222b411b363SPhilipp Reisner 4223b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4224b411b363SPhilipp Reisner 4225b411b363SPhilipp Reisner if (is_syncer_block_id(p->block_id)) { 4226b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4227b411b363SPhilipp Reisner dec_rs_pending(mdev); 4228b411b363SPhilipp Reisner return TRUE; 4229b411b363SPhilipp Reisner } 4230b411b363SPhilipp Reisner switch (be16_to_cpu(h->command)) { 4231b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 4232b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 4233b411b363SPhilipp Reisner what = write_acked_by_peer_and_sis; 4234b411b363SPhilipp Reisner break; 4235b411b363SPhilipp Reisner case P_WRITE_ACK: 4236b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 4237b411b363SPhilipp Reisner what = write_acked_by_peer; 4238b411b363SPhilipp Reisner break; 4239b411b363SPhilipp Reisner case P_RECV_ACK: 4240b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_B); 4241b411b363SPhilipp Reisner what = recv_acked_by_peer; 4242b411b363SPhilipp Reisner break; 4243b411b363SPhilipp Reisner case P_DISCARD_ACK: 4244b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 4245b411b363SPhilipp Reisner what = conflict_discarded_by_peer; 4246b411b363SPhilipp Reisner break; 4247b411b363SPhilipp Reisner default: 4248b411b363SPhilipp Reisner D_ASSERT(0); 4249b411b363SPhilipp Reisner return FALSE; 4250b411b363SPhilipp Reisner } 4251b411b363SPhilipp Reisner 4252b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4253b411b363SPhilipp Reisner _ack_id_to_req, __func__ , what); 4254b411b363SPhilipp Reisner } 4255b411b363SPhilipp Reisner 42560b70a13dSPhilipp Reisner static int got_NegAck(struct drbd_conf *mdev, struct p_header80 *h) 4257b411b363SPhilipp Reisner { 4258b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4259b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4260b411b363SPhilipp Reisner 4261b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 4262b411b363SPhilipp Reisner dev_warn(DEV, "Got NegAck packet. Peer is in troubles?\n"); 4263b411b363SPhilipp Reisner 4264b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4265b411b363SPhilipp Reisner 4266b411b363SPhilipp Reisner if (is_syncer_block_id(p->block_id)) { 4267b411b363SPhilipp Reisner int size = be32_to_cpu(p->blksize); 4268b411b363SPhilipp Reisner dec_rs_pending(mdev); 4269b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4270b411b363SPhilipp Reisner return TRUE; 4271b411b363SPhilipp Reisner } 4272b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4273b411b363SPhilipp Reisner _ack_id_to_req, __func__ , neg_acked); 4274b411b363SPhilipp Reisner } 4275b411b363SPhilipp Reisner 42760b70a13dSPhilipp Reisner static int got_NegDReply(struct drbd_conf *mdev, struct p_header80 *h) 4277b411b363SPhilipp Reisner { 4278b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4279b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4280b411b363SPhilipp Reisner 4281b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4282b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4283b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4284b411b363SPhilipp Reisner 4285b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4286b411b363SPhilipp Reisner _ar_id_to_req, __func__ , neg_acked); 4287b411b363SPhilipp Reisner } 4288b411b363SPhilipp Reisner 42890b70a13dSPhilipp Reisner static int got_NegRSDReply(struct drbd_conf *mdev, struct p_header80 *h) 4290b411b363SPhilipp Reisner { 4291b411b363SPhilipp Reisner sector_t sector; 4292b411b363SPhilipp Reisner int size; 4293b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4294b411b363SPhilipp Reisner 4295b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4296b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4297b411b363SPhilipp Reisner 4298b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4299b411b363SPhilipp Reisner 4300b411b363SPhilipp Reisner dec_rs_pending(mdev); 4301b411b363SPhilipp Reisner 4302b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4303b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4304b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4305b411b363SPhilipp Reisner put_ldev(mdev); 4306b411b363SPhilipp Reisner } 4307b411b363SPhilipp Reisner 4308b411b363SPhilipp Reisner return TRUE; 4309b411b363SPhilipp Reisner } 4310b411b363SPhilipp Reisner 43110b70a13dSPhilipp Reisner static int got_BarrierAck(struct drbd_conf *mdev, struct p_header80 *h) 4312b411b363SPhilipp Reisner { 4313b411b363SPhilipp Reisner struct p_barrier_ack *p = (struct p_barrier_ack *)h; 4314b411b363SPhilipp Reisner 4315b411b363SPhilipp Reisner tl_release(mdev, p->barrier, be32_to_cpu(p->set_size)); 4316b411b363SPhilipp Reisner 4317b411b363SPhilipp Reisner return TRUE; 4318b411b363SPhilipp Reisner } 4319b411b363SPhilipp Reisner 43200b70a13dSPhilipp Reisner static int got_OVResult(struct drbd_conf *mdev, struct p_header80 *h) 4321b411b363SPhilipp Reisner { 4322b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4323b411b363SPhilipp Reisner struct drbd_work *w; 4324b411b363SPhilipp Reisner sector_t sector; 4325b411b363SPhilipp Reisner int size; 4326b411b363SPhilipp Reisner 4327b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4328b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4329b411b363SPhilipp Reisner 4330b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4331b411b363SPhilipp Reisner 4332b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 4333b411b363SPhilipp Reisner drbd_ov_oos_found(mdev, sector, size); 4334b411b363SPhilipp Reisner else 4335b411b363SPhilipp Reisner ov_oos_print(mdev); 4336b411b363SPhilipp Reisner 43371d53f09eSLars Ellenberg if (!get_ldev(mdev)) 43381d53f09eSLars Ellenberg return TRUE; 43391d53f09eSLars Ellenberg 4340b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4341b411b363SPhilipp Reisner dec_rs_pending(mdev); 4342b411b363SPhilipp Reisner 4343ea5442afSLars Ellenberg --mdev->ov_left; 4344ea5442afSLars Ellenberg 4345ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 4346ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 4347ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 4348ea5442afSLars Ellenberg 4349ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 4350b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4351b411b363SPhilipp Reisner if (w) { 4352b411b363SPhilipp Reisner w->cb = w_ov_finished; 4353b411b363SPhilipp Reisner drbd_queue_work_front(&mdev->data.work, w); 4354b411b363SPhilipp Reisner } else { 4355b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 4356b411b363SPhilipp Reisner ov_oos_print(mdev); 4357b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4358b411b363SPhilipp Reisner } 4359b411b363SPhilipp Reisner } 43601d53f09eSLars Ellenberg put_ldev(mdev); 4361b411b363SPhilipp Reisner return TRUE; 4362b411b363SPhilipp Reisner } 4363b411b363SPhilipp Reisner 436402918be2SPhilipp Reisner static int got_skip(struct drbd_conf *mdev, struct p_header80 *h) 43650ced55a3SPhilipp Reisner { 43660ced55a3SPhilipp Reisner return TRUE; 43670ced55a3SPhilipp Reisner } 43680ced55a3SPhilipp Reisner 4369b411b363SPhilipp Reisner struct asender_cmd { 4370b411b363SPhilipp Reisner size_t pkt_size; 43710b70a13dSPhilipp Reisner int (*process)(struct drbd_conf *mdev, struct p_header80 *h); 4372b411b363SPhilipp Reisner }; 4373b411b363SPhilipp Reisner 4374b411b363SPhilipp Reisner static struct asender_cmd *get_asender_cmd(int cmd) 4375b411b363SPhilipp Reisner { 4376b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 4377b411b363SPhilipp Reisner /* anything missing from this table is in 4378b411b363SPhilipp Reisner * the drbd_cmd_handler (drbd_default_handler) table, 4379b411b363SPhilipp Reisner * see the beginning of drbdd() */ 43800b70a13dSPhilipp Reisner [P_PING] = { sizeof(struct p_header80), got_Ping }, 43810b70a13dSPhilipp Reisner [P_PING_ACK] = { sizeof(struct p_header80), got_PingAck }, 4382b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4383b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4384b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4385b411b363SPhilipp Reisner [P_DISCARD_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4386b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 4387b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 4388b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply}, 4389b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 4390b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 4391b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 4392b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 439302918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 4394b411b363SPhilipp Reisner [P_MAX_CMD] = { 0, NULL }, 4395b411b363SPhilipp Reisner }; 4396b411b363SPhilipp Reisner if (cmd > P_MAX_CMD || asender_tbl[cmd].process == NULL) 4397b411b363SPhilipp Reisner return NULL; 4398b411b363SPhilipp Reisner return &asender_tbl[cmd]; 4399b411b363SPhilipp Reisner } 4400b411b363SPhilipp Reisner 4401b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4402b411b363SPhilipp Reisner { 4403b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 440402918be2SPhilipp Reisner struct p_header80 *h = &mdev->meta.rbuf.header.h80; 4405b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 4406b411b363SPhilipp Reisner 4407b411b363SPhilipp Reisner int rv, len; 4408b411b363SPhilipp Reisner void *buf = h; 4409b411b363SPhilipp Reisner int received = 0; 44100b70a13dSPhilipp Reisner int expect = sizeof(struct p_header80); 4411b411b363SPhilipp Reisner int empty; 4412b411b363SPhilipp Reisner 4413b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_asender", mdev_to_minor(mdev)); 4414b411b363SPhilipp Reisner 4415b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4416b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4417b411b363SPhilipp Reisner 4418b411b363SPhilipp Reisner while (get_t_state(thi) == Running) { 4419b411b363SPhilipp Reisner drbd_thread_current_set_cpu(mdev); 4420b411b363SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &mdev->flags)) { 4421b411b363SPhilipp Reisner ERR_IF(!drbd_send_ping(mdev)) goto reconnect; 4422b411b363SPhilipp Reisner mdev->meta.socket->sk->sk_rcvtimeo = 4423b411b363SPhilipp Reisner mdev->net_conf->ping_timeo*HZ/10; 4424b411b363SPhilipp Reisner } 4425b411b363SPhilipp Reisner 4426b411b363SPhilipp Reisner /* conditionally cork; 4427b411b363SPhilipp Reisner * it may hurt latency if we cork without much to send */ 4428b411b363SPhilipp Reisner if (!mdev->net_conf->no_cork && 4429b411b363SPhilipp Reisner 3 < atomic_read(&mdev->unacked_cnt)) 4430b411b363SPhilipp Reisner drbd_tcp_cork(mdev->meta.socket); 4431b411b363SPhilipp Reisner while (1) { 4432b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4433b411b363SPhilipp Reisner flush_signals(current); 44340f8488e1SLars Ellenberg if (!drbd_process_done_ee(mdev)) 4435b411b363SPhilipp Reisner goto reconnect; 4436b411b363SPhilipp Reisner /* to avoid race with newly queued ACKs */ 4437b411b363SPhilipp Reisner set_bit(SIGNAL_ASENDER, &mdev->flags); 4438b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 4439b411b363SPhilipp Reisner empty = list_empty(&mdev->done_ee); 4440b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 4441b411b363SPhilipp Reisner /* new ack may have been queued right here, 4442b411b363SPhilipp Reisner * but then there is also a signal pending, 4443b411b363SPhilipp Reisner * and we start over... */ 4444b411b363SPhilipp Reisner if (empty) 4445b411b363SPhilipp Reisner break; 4446b411b363SPhilipp Reisner } 4447b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 4448b411b363SPhilipp Reisner if (!mdev->net_conf->no_cork) 4449b411b363SPhilipp Reisner drbd_tcp_uncork(mdev->meta.socket); 4450b411b363SPhilipp Reisner 4451b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4452b411b363SPhilipp Reisner if (signal_pending(current)) 4453b411b363SPhilipp Reisner continue; 4454b411b363SPhilipp Reisner 4455b411b363SPhilipp Reisner rv = drbd_recv_short(mdev, mdev->meta.socket, 4456b411b363SPhilipp Reisner buf, expect-received, 0); 4457b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4458b411b363SPhilipp Reisner 4459b411b363SPhilipp Reisner flush_signals(current); 4460b411b363SPhilipp Reisner 4461b411b363SPhilipp Reisner /* Note: 4462b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4463b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4464b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4465b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4466b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4467b411b363SPhilipp Reisner * rv == expected: full header or command 4468b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4469b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4470b411b363SPhilipp Reisner */ 4471b411b363SPhilipp Reisner if (likely(rv > 0)) { 4472b411b363SPhilipp Reisner received += rv; 4473b411b363SPhilipp Reisner buf += rv; 4474b411b363SPhilipp Reisner } else if (rv == 0) { 4475b411b363SPhilipp Reisner dev_err(DEV, "meta connection shut down by peer.\n"); 4476b411b363SPhilipp Reisner goto reconnect; 4477b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4478b411b363SPhilipp Reisner if (mdev->meta.socket->sk->sk_rcvtimeo == 4479b411b363SPhilipp Reisner mdev->net_conf->ping_timeo*HZ/10) { 4480b411b363SPhilipp Reisner dev_err(DEV, "PingAck did not arrive in time.\n"); 4481b411b363SPhilipp Reisner goto reconnect; 4482b411b363SPhilipp Reisner } 4483b411b363SPhilipp Reisner set_bit(SEND_PING, &mdev->flags); 4484b411b363SPhilipp Reisner continue; 4485b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4486b411b363SPhilipp Reisner continue; 4487b411b363SPhilipp Reisner } else { 4488b411b363SPhilipp Reisner dev_err(DEV, "sock_recvmsg returned %d\n", rv); 4489b411b363SPhilipp Reisner goto reconnect; 4490b411b363SPhilipp Reisner } 4491b411b363SPhilipp Reisner 4492b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 4493b411b363SPhilipp Reisner if (unlikely(h->magic != BE_DRBD_MAGIC)) { 4494004352faSLars Ellenberg dev_err(DEV, "magic?? on meta m: 0x%08x c: %d l: %d\n", 4495004352faSLars Ellenberg be32_to_cpu(h->magic), 4496004352faSLars Ellenberg be16_to_cpu(h->command), 4497004352faSLars Ellenberg be16_to_cpu(h->length)); 4498b411b363SPhilipp Reisner goto reconnect; 4499b411b363SPhilipp Reisner } 4500b411b363SPhilipp Reisner cmd = get_asender_cmd(be16_to_cpu(h->command)); 4501b411b363SPhilipp Reisner len = be16_to_cpu(h->length); 4502b411b363SPhilipp Reisner if (unlikely(cmd == NULL)) { 4503004352faSLars Ellenberg dev_err(DEV, "unknown command?? on meta m: 0x%08x c: %d l: %d\n", 4504004352faSLars Ellenberg be32_to_cpu(h->magic), 4505004352faSLars Ellenberg be16_to_cpu(h->command), 4506004352faSLars Ellenberg be16_to_cpu(h->length)); 4507b411b363SPhilipp Reisner goto disconnect; 4508b411b363SPhilipp Reisner } 4509b411b363SPhilipp Reisner expect = cmd->pkt_size; 45100b70a13dSPhilipp Reisner ERR_IF(len != expect-sizeof(struct p_header80)) 4511b411b363SPhilipp Reisner goto reconnect; 4512b411b363SPhilipp Reisner } 4513b411b363SPhilipp Reisner if (received == expect) { 4514b411b363SPhilipp Reisner D_ASSERT(cmd != NULL); 4515b411b363SPhilipp Reisner if (!cmd->process(mdev, h)) 4516b411b363SPhilipp Reisner goto reconnect; 4517b411b363SPhilipp Reisner 4518b411b363SPhilipp Reisner buf = h; 4519b411b363SPhilipp Reisner received = 0; 45200b70a13dSPhilipp Reisner expect = sizeof(struct p_header80); 4521b411b363SPhilipp Reisner cmd = NULL; 4522b411b363SPhilipp Reisner } 4523b411b363SPhilipp Reisner } 4524b411b363SPhilipp Reisner 4525b411b363SPhilipp Reisner if (0) { 4526b411b363SPhilipp Reisner reconnect: 4527b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_NETWORK_FAILURE)); 4528856c50c7SLars Ellenberg drbd_md_sync(mdev); 4529b411b363SPhilipp Reisner } 4530b411b363SPhilipp Reisner if (0) { 4531b411b363SPhilipp Reisner disconnect: 4532b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 4533856c50c7SLars Ellenberg drbd_md_sync(mdev); 4534b411b363SPhilipp Reisner } 4535b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4536b411b363SPhilipp Reisner 4537b411b363SPhilipp Reisner D_ASSERT(mdev->state.conn < C_CONNECTED); 4538b411b363SPhilipp Reisner dev_info(DEV, "asender terminated\n"); 4539b411b363SPhilipp Reisner 4540b411b363SPhilipp Reisner return 0; 4541b411b363SPhilipp Reisner } 4542