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/smp_lock.h> 40b411b363SPhilipp Reisner #include <linux/pkt_sched.h> 41b411b363SPhilipp Reisner #define __KERNEL_SYSCALLS__ 42b411b363SPhilipp Reisner #include <linux/unistd.h> 43b411b363SPhilipp Reisner #include <linux/vmalloc.h> 44b411b363SPhilipp Reisner #include <linux/random.h> 45b411b363SPhilipp Reisner #include <linux/string.h> 46b411b363SPhilipp Reisner #include <linux/scatterlist.h> 47b411b363SPhilipp Reisner #include "drbd_int.h" 48b411b363SPhilipp Reisner #include "drbd_req.h" 49b411b363SPhilipp Reisner 50b411b363SPhilipp Reisner #include "drbd_vli.h" 51b411b363SPhilipp Reisner 52b411b363SPhilipp Reisner struct flush_work { 53b411b363SPhilipp Reisner struct drbd_work w; 54b411b363SPhilipp Reisner struct drbd_epoch *epoch; 55b411b363SPhilipp Reisner }; 56b411b363SPhilipp Reisner 57b411b363SPhilipp Reisner enum finish_epoch { 58b411b363SPhilipp Reisner FE_STILL_LIVE, 59b411b363SPhilipp Reisner FE_DESTROYED, 60b411b363SPhilipp Reisner FE_RECYCLED, 61b411b363SPhilipp Reisner }; 62b411b363SPhilipp Reisner 63b411b363SPhilipp Reisner static int drbd_do_handshake(struct drbd_conf *mdev); 64b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev); 65b411b363SPhilipp Reisner 66b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event); 67b411b363SPhilipp Reisner static int e_end_block(struct drbd_conf *, struct drbd_work *, int); 68b411b363SPhilipp Reisner 69b411b363SPhilipp Reisner static struct drbd_epoch *previous_epoch(struct drbd_conf *mdev, struct drbd_epoch *epoch) 70b411b363SPhilipp Reisner { 71b411b363SPhilipp Reisner struct drbd_epoch *prev; 72b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 73b411b363SPhilipp Reisner prev = list_entry(epoch->list.prev, struct drbd_epoch, list); 74b411b363SPhilipp Reisner if (prev == epoch || prev == mdev->current_epoch) 75b411b363SPhilipp Reisner prev = NULL; 76b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 77b411b363SPhilipp Reisner return prev; 78b411b363SPhilipp Reisner } 79b411b363SPhilipp Reisner 80b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 81b411b363SPhilipp Reisner 8245bb912bSLars Ellenberg /* 8345bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 8445bb912bSLars Ellenberg * page->private being our "next" pointer. 8545bb912bSLars Ellenberg */ 8645bb912bSLars Ellenberg 8745bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 8845bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8945bb912bSLars Ellenberg * Locking is the responsibility of the caller. 9045bb912bSLars Ellenberg */ 9145bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 9245bb912bSLars Ellenberg { 9345bb912bSLars Ellenberg struct page *page; 9445bb912bSLars Ellenberg struct page *tmp; 9545bb912bSLars Ellenberg 9645bb912bSLars Ellenberg BUG_ON(!n); 9745bb912bSLars Ellenberg BUG_ON(!head); 9845bb912bSLars Ellenberg 9945bb912bSLars Ellenberg page = *head; 10023ce4227SPhilipp Reisner 10123ce4227SPhilipp Reisner if (!page) 10223ce4227SPhilipp Reisner return NULL; 10323ce4227SPhilipp Reisner 10445bb912bSLars Ellenberg while (page) { 10545bb912bSLars Ellenberg tmp = page_chain_next(page); 10645bb912bSLars Ellenberg if (--n == 0) 10745bb912bSLars Ellenberg break; /* found sufficient pages */ 10845bb912bSLars Ellenberg if (tmp == NULL) 10945bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 11045bb912bSLars Ellenberg return NULL; 11145bb912bSLars Ellenberg page = tmp; 11245bb912bSLars Ellenberg } 11345bb912bSLars Ellenberg 11445bb912bSLars Ellenberg /* add end of list marker for the returned list */ 11545bb912bSLars Ellenberg set_page_private(page, 0); 11645bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 11745bb912bSLars Ellenberg page = *head; 11845bb912bSLars Ellenberg *head = tmp; 11945bb912bSLars Ellenberg return page; 12045bb912bSLars Ellenberg } 12145bb912bSLars Ellenberg 12245bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 12345bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 12445bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 12545bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 12645bb912bSLars Ellenberg { 12745bb912bSLars Ellenberg struct page *tmp; 12845bb912bSLars Ellenberg int i = 1; 12945bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 13045bb912bSLars Ellenberg ++i, page = tmp; 13145bb912bSLars Ellenberg if (len) 13245bb912bSLars Ellenberg *len = i; 13345bb912bSLars Ellenberg return page; 13445bb912bSLars Ellenberg } 13545bb912bSLars Ellenberg 13645bb912bSLars Ellenberg static int page_chain_free(struct page *page) 13745bb912bSLars Ellenberg { 13845bb912bSLars Ellenberg struct page *tmp; 13945bb912bSLars Ellenberg int i = 0; 14045bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 14145bb912bSLars Ellenberg put_page(page); 14245bb912bSLars Ellenberg ++i; 14345bb912bSLars Ellenberg } 14445bb912bSLars Ellenberg return i; 14545bb912bSLars Ellenberg } 14645bb912bSLars Ellenberg 14745bb912bSLars Ellenberg static void page_chain_add(struct page **head, 14845bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14945bb912bSLars Ellenberg { 15045bb912bSLars Ellenberg #if 1 15145bb912bSLars Ellenberg struct page *tmp; 15245bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 15345bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 15445bb912bSLars Ellenberg #endif 15545bb912bSLars Ellenberg 15645bb912bSLars Ellenberg /* add chain to head */ 15745bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 15845bb912bSLars Ellenberg *head = chain_first; 15945bb912bSLars Ellenberg } 16045bb912bSLars Ellenberg 16145bb912bSLars Ellenberg static struct page *drbd_pp_first_pages_or_try_alloc(struct drbd_conf *mdev, int number) 162b411b363SPhilipp Reisner { 163b411b363SPhilipp Reisner struct page *page = NULL; 16445bb912bSLars Ellenberg struct page *tmp = NULL; 16545bb912bSLars Ellenberg int i = 0; 166b411b363SPhilipp Reisner 167b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 168b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16945bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 170b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 17145bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 17245bb912bSLars Ellenberg if (page) 17345bb912bSLars Ellenberg drbd_pp_vacant -= number; 174b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 17545bb912bSLars Ellenberg if (page) 17645bb912bSLars Ellenberg return page; 177b411b363SPhilipp Reisner } 17845bb912bSLars Ellenberg 179b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 180b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 181b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 18245bb912bSLars Ellenberg for (i = 0; i < number; i++) { 18345bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 18445bb912bSLars Ellenberg if (!tmp) 18545bb912bSLars Ellenberg break; 18645bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 18745bb912bSLars Ellenberg page = tmp; 18845bb912bSLars Ellenberg } 18945bb912bSLars Ellenberg 19045bb912bSLars Ellenberg if (i == number) 191b411b363SPhilipp Reisner return page; 19245bb912bSLars Ellenberg 19345bb912bSLars Ellenberg /* Not enough pages immediately available this time. 19445bb912bSLars Ellenberg * No need to jump around here, drbd_pp_alloc will retry this 19545bb912bSLars Ellenberg * function "soon". */ 19645bb912bSLars Ellenberg if (page) { 19745bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 19845bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19945bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 20045bb912bSLars Ellenberg drbd_pp_vacant += i; 20145bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 20245bb912bSLars Ellenberg } 20345bb912bSLars Ellenberg return NULL; 204b411b363SPhilipp Reisner } 205b411b363SPhilipp Reisner 206b411b363SPhilipp Reisner /* kick lower level device, if we have more than (arbitrary number) 207b411b363SPhilipp Reisner * reference counts on it, which typically are locally submitted io 208b411b363SPhilipp Reisner * requests. don't use unacked_cnt, so we speed up proto A and B, too. */ 209b411b363SPhilipp Reisner static void maybe_kick_lo(struct drbd_conf *mdev) 210b411b363SPhilipp Reisner { 211b411b363SPhilipp Reisner if (atomic_read(&mdev->local_cnt) >= mdev->net_conf->unplug_watermark) 212b411b363SPhilipp Reisner drbd_kick_lo(mdev); 213b411b363SPhilipp Reisner } 214b411b363SPhilipp Reisner 215b411b363SPhilipp Reisner static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed) 216b411b363SPhilipp Reisner { 217b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 218b411b363SPhilipp Reisner struct list_head *le, *tle; 219b411b363SPhilipp Reisner 220b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 221b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 222b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 223b411b363SPhilipp Reisner stop to examine the list... */ 224b411b363SPhilipp Reisner 225b411b363SPhilipp Reisner list_for_each_safe(le, tle, &mdev->net_ee) { 226b411b363SPhilipp Reisner e = list_entry(le, struct drbd_epoch_entry, w.list); 22745bb912bSLars Ellenberg if (drbd_ee_has_active_page(e)) 228b411b363SPhilipp Reisner break; 229b411b363SPhilipp Reisner list_move(le, to_be_freed); 230b411b363SPhilipp Reisner } 231b411b363SPhilipp Reisner } 232b411b363SPhilipp Reisner 233b411b363SPhilipp Reisner static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev) 234b411b363SPhilipp Reisner { 235b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 236b411b363SPhilipp Reisner struct drbd_epoch_entry *e, *t; 237b411b363SPhilipp Reisner 238b411b363SPhilipp Reisner maybe_kick_lo(mdev); 239b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 240b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 241b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 242b411b363SPhilipp Reisner 243b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &reclaimed, w.list) 244435f0740SLars Ellenberg drbd_free_net_ee(mdev, e); 245b411b363SPhilipp Reisner } 246b411b363SPhilipp Reisner 247b411b363SPhilipp Reisner /** 24845bb912bSLars Ellenberg * drbd_pp_alloc() - Returns @number pages, retries forever (or until signalled) 249b411b363SPhilipp Reisner * @mdev: DRBD device. 25045bb912bSLars Ellenberg * @number: number of pages requested 25145bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 252b411b363SPhilipp Reisner * 25345bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 25445bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 25545bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 25645bb912bSLars Ellenberg * 25745bb912bSLars Ellenberg * Returns a page chain linked via page->private. 258b411b363SPhilipp Reisner */ 25945bb912bSLars Ellenberg static struct page *drbd_pp_alloc(struct drbd_conf *mdev, unsigned number, bool retry) 260b411b363SPhilipp Reisner { 261b411b363SPhilipp Reisner struct page *page = NULL; 262b411b363SPhilipp Reisner DEFINE_WAIT(wait); 263b411b363SPhilipp Reisner 26445bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 26545bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 26645bb912bSLars Ellenberg if (atomic_read(&mdev->pp_in_use) < mdev->net_conf->max_buffers) 26745bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 268b411b363SPhilipp Reisner 26945bb912bSLars Ellenberg while (page == NULL) { 270b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 271b411b363SPhilipp Reisner 272b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 273b411b363SPhilipp Reisner 274b411b363SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->net_conf->max_buffers) { 27545bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 276b411b363SPhilipp Reisner if (page) 277b411b363SPhilipp Reisner break; 278b411b363SPhilipp Reisner } 279b411b363SPhilipp Reisner 280b411b363SPhilipp Reisner if (!retry) 281b411b363SPhilipp Reisner break; 282b411b363SPhilipp Reisner 283b411b363SPhilipp Reisner if (signal_pending(current)) { 284b411b363SPhilipp Reisner dev_warn(DEV, "drbd_pp_alloc interrupted!\n"); 285b411b363SPhilipp Reisner break; 286b411b363SPhilipp Reisner } 287b411b363SPhilipp Reisner 288b411b363SPhilipp Reisner schedule(); 289b411b363SPhilipp Reisner } 290b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 291b411b363SPhilipp Reisner 29245bb912bSLars Ellenberg if (page) 29345bb912bSLars Ellenberg atomic_add(number, &mdev->pp_in_use); 294b411b363SPhilipp Reisner return page; 295b411b363SPhilipp Reisner } 296b411b363SPhilipp Reisner 297b411b363SPhilipp Reisner /* Must not be used from irq, as that may deadlock: see drbd_pp_alloc. 29845bb912bSLars Ellenberg * Is also used from inside an other spin_lock_irq(&mdev->req_lock); 29945bb912bSLars Ellenberg * Either links the page chain back to the global pool, 30045bb912bSLars Ellenberg * or returns all pages to the system. */ 301435f0740SLars Ellenberg static void drbd_pp_free(struct drbd_conf *mdev, struct page *page, int is_net) 302b411b363SPhilipp Reisner { 303435f0740SLars Ellenberg atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use; 304b411b363SPhilipp Reisner int i; 305435f0740SLars Ellenberg 30645bb912bSLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_SEGMENT_SIZE/PAGE_SIZE)*minor_count) 30745bb912bSLars Ellenberg i = page_chain_free(page); 30845bb912bSLars Ellenberg else { 30945bb912bSLars Ellenberg struct page *tmp; 31045bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 311b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 31245bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 31345bb912bSLars Ellenberg drbd_pp_vacant += i; 314b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 315b411b363SPhilipp Reisner } 316435f0740SLars Ellenberg i = atomic_sub_return(i, a); 31745bb912bSLars Ellenberg if (i < 0) 318435f0740SLars Ellenberg dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n", 319435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 320b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 321b411b363SPhilipp Reisner } 322b411b363SPhilipp Reisner 323b411b363SPhilipp Reisner /* 324b411b363SPhilipp Reisner You need to hold the req_lock: 325b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 326b411b363SPhilipp Reisner 327b411b363SPhilipp Reisner You must not have the req_lock: 328b411b363SPhilipp Reisner drbd_free_ee() 329b411b363SPhilipp Reisner drbd_alloc_ee() 330b411b363SPhilipp Reisner drbd_init_ee() 331b411b363SPhilipp Reisner drbd_release_ee() 332b411b363SPhilipp Reisner drbd_ee_fix_bhs() 333b411b363SPhilipp Reisner drbd_process_done_ee() 334b411b363SPhilipp Reisner drbd_clear_done_ee() 335b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 336b411b363SPhilipp Reisner */ 337b411b363SPhilipp Reisner 338b411b363SPhilipp Reisner struct drbd_epoch_entry *drbd_alloc_ee(struct drbd_conf *mdev, 339b411b363SPhilipp Reisner u64 id, 340b411b363SPhilipp Reisner sector_t sector, 341b411b363SPhilipp Reisner unsigned int data_size, 342b411b363SPhilipp Reisner gfp_t gfp_mask) __must_hold(local) 343b411b363SPhilipp Reisner { 344b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 345b411b363SPhilipp Reisner struct page *page; 34645bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 347b411b363SPhilipp Reisner 348b411b363SPhilipp Reisner if (FAULT_ACTIVE(mdev, DRBD_FAULT_AL_EE)) 349b411b363SPhilipp Reisner return NULL; 350b411b363SPhilipp Reisner 351b411b363SPhilipp Reisner e = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 352b411b363SPhilipp Reisner if (!e) { 353b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 354b411b363SPhilipp Reisner dev_err(DEV, "alloc_ee: Allocation of an EE failed\n"); 355b411b363SPhilipp Reisner return NULL; 356b411b363SPhilipp Reisner } 357b411b363SPhilipp Reisner 35845bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT)); 35945bb912bSLars Ellenberg if (!page) 36045bb912bSLars Ellenberg goto fail; 361b411b363SPhilipp Reisner 362b411b363SPhilipp Reisner INIT_HLIST_NODE(&e->colision); 363b411b363SPhilipp Reisner e->epoch = NULL; 36445bb912bSLars Ellenberg e->mdev = mdev; 36545bb912bSLars Ellenberg e->pages = page; 36645bb912bSLars Ellenberg atomic_set(&e->pending_bios, 0); 36745bb912bSLars Ellenberg e->size = data_size; 368b411b363SPhilipp Reisner e->flags = 0; 36945bb912bSLars Ellenberg e->sector = sector; 37045bb912bSLars Ellenberg e->block_id = id; 371b411b363SPhilipp Reisner 372b411b363SPhilipp Reisner return e; 373b411b363SPhilipp Reisner 37445bb912bSLars Ellenberg fail: 375b411b363SPhilipp Reisner mempool_free(e, drbd_ee_mempool); 376b411b363SPhilipp Reisner return NULL; 377b411b363SPhilipp Reisner } 378b411b363SPhilipp Reisner 379435f0740SLars Ellenberg void drbd_free_some_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e, int is_net) 380b411b363SPhilipp Reisner { 381c36c3cedSLars Ellenberg if (e->flags & EE_HAS_DIGEST) 382c36c3cedSLars Ellenberg kfree(e->digest); 383435f0740SLars Ellenberg drbd_pp_free(mdev, e->pages, is_net); 38445bb912bSLars Ellenberg D_ASSERT(atomic_read(&e->pending_bios) == 0); 385b411b363SPhilipp Reisner D_ASSERT(hlist_unhashed(&e->colision)); 386b411b363SPhilipp Reisner mempool_free(e, drbd_ee_mempool); 387b411b363SPhilipp Reisner } 388b411b363SPhilipp Reisner 389b411b363SPhilipp Reisner int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list) 390b411b363SPhilipp Reisner { 391b411b363SPhilipp Reisner LIST_HEAD(work_list); 392b411b363SPhilipp Reisner struct drbd_epoch_entry *e, *t; 393b411b363SPhilipp Reisner int count = 0; 394435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 395b411b363SPhilipp Reisner 396b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 397b411b363SPhilipp Reisner list_splice_init(list, &work_list); 398b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 399b411b363SPhilipp Reisner 400b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &work_list, w.list) { 401435f0740SLars Ellenberg drbd_free_some_ee(mdev, e, is_net); 402b411b363SPhilipp Reisner count++; 403b411b363SPhilipp Reisner } 404b411b363SPhilipp Reisner return count; 405b411b363SPhilipp Reisner } 406b411b363SPhilipp Reisner 407b411b363SPhilipp Reisner 408b411b363SPhilipp Reisner /* 409b411b363SPhilipp Reisner * This function is called from _asender only_ 410b411b363SPhilipp Reisner * but see also comments in _req_mod(,barrier_acked) 411b411b363SPhilipp Reisner * and receive_Barrier. 412b411b363SPhilipp Reisner * 413b411b363SPhilipp Reisner * Move entries from net_ee to done_ee, if ready. 414b411b363SPhilipp Reisner * Grab done_ee, call all callbacks, free the entries. 415b411b363SPhilipp Reisner * The callbacks typically send out ACKs. 416b411b363SPhilipp Reisner */ 417b411b363SPhilipp Reisner static int drbd_process_done_ee(struct drbd_conf *mdev) 418b411b363SPhilipp Reisner { 419b411b363SPhilipp Reisner LIST_HEAD(work_list); 420b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 421b411b363SPhilipp Reisner struct drbd_epoch_entry *e, *t; 422b411b363SPhilipp Reisner int ok = (mdev->state.conn >= C_WF_REPORT_PARAMS); 423b411b363SPhilipp Reisner 424b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 425b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 426b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 427b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 428b411b363SPhilipp Reisner 429b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &reclaimed, w.list) 430435f0740SLars Ellenberg drbd_free_net_ee(mdev, e); 431b411b363SPhilipp Reisner 432b411b363SPhilipp Reisner /* possible callbacks here: 433b411b363SPhilipp Reisner * e_end_block, and e_end_resync_block, e_send_discard_ack. 434b411b363SPhilipp Reisner * all ignore the last argument. 435b411b363SPhilipp Reisner */ 436b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &work_list, w.list) { 437b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 438b411b363SPhilipp Reisner ok = e->w.cb(mdev, &e->w, !ok) && ok; 439b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 440b411b363SPhilipp Reisner } 441b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 442b411b363SPhilipp Reisner 443b411b363SPhilipp Reisner return ok; 444b411b363SPhilipp Reisner } 445b411b363SPhilipp Reisner 446b411b363SPhilipp Reisner void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 447b411b363SPhilipp Reisner { 448b411b363SPhilipp Reisner DEFINE_WAIT(wait); 449b411b363SPhilipp Reisner 450b411b363SPhilipp Reisner /* avoids spin_lock/unlock 451b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 452b411b363SPhilipp Reisner while (!list_empty(head)) { 453b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 454b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 455b411b363SPhilipp Reisner drbd_kick_lo(mdev); 456b411b363SPhilipp Reisner schedule(); 457b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 458b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 459b411b363SPhilipp Reisner } 460b411b363SPhilipp Reisner } 461b411b363SPhilipp Reisner 462b411b363SPhilipp Reisner void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 463b411b363SPhilipp Reisner { 464b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 465b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 466b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 467b411b363SPhilipp Reisner } 468b411b363SPhilipp Reisner 469b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 470b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 471b411b363SPhilipp Reisner static int drbd_accept(struct drbd_conf *mdev, const char **what, 472b411b363SPhilipp Reisner struct socket *sock, struct socket **newsock) 473b411b363SPhilipp Reisner { 474b411b363SPhilipp Reisner struct sock *sk = sock->sk; 475b411b363SPhilipp Reisner int err = 0; 476b411b363SPhilipp Reisner 477b411b363SPhilipp Reisner *what = "listen"; 478b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 479b411b363SPhilipp Reisner if (err < 0) 480b411b363SPhilipp Reisner goto out; 481b411b363SPhilipp Reisner 482b411b363SPhilipp Reisner *what = "sock_create_lite"; 483b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 484b411b363SPhilipp Reisner newsock); 485b411b363SPhilipp Reisner if (err < 0) 486b411b363SPhilipp Reisner goto out; 487b411b363SPhilipp Reisner 488b411b363SPhilipp Reisner *what = "accept"; 489b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 490b411b363SPhilipp Reisner if (err < 0) { 491b411b363SPhilipp Reisner sock_release(*newsock); 492b411b363SPhilipp Reisner *newsock = NULL; 493b411b363SPhilipp Reisner goto out; 494b411b363SPhilipp Reisner } 495b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 496b411b363SPhilipp Reisner 497b411b363SPhilipp Reisner out: 498b411b363SPhilipp Reisner return err; 499b411b363SPhilipp Reisner } 500b411b363SPhilipp Reisner 501b411b363SPhilipp Reisner static int drbd_recv_short(struct drbd_conf *mdev, struct socket *sock, 502b411b363SPhilipp Reisner void *buf, size_t size, int flags) 503b411b363SPhilipp Reisner { 504b411b363SPhilipp Reisner mm_segment_t oldfs; 505b411b363SPhilipp Reisner struct kvec iov = { 506b411b363SPhilipp Reisner .iov_base = buf, 507b411b363SPhilipp Reisner .iov_len = size, 508b411b363SPhilipp Reisner }; 509b411b363SPhilipp Reisner struct msghdr msg = { 510b411b363SPhilipp Reisner .msg_iovlen = 1, 511b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 512b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 513b411b363SPhilipp Reisner }; 514b411b363SPhilipp Reisner int rv; 515b411b363SPhilipp Reisner 516b411b363SPhilipp Reisner oldfs = get_fs(); 517b411b363SPhilipp Reisner set_fs(KERNEL_DS); 518b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 519b411b363SPhilipp Reisner set_fs(oldfs); 520b411b363SPhilipp Reisner 521b411b363SPhilipp Reisner return rv; 522b411b363SPhilipp Reisner } 523b411b363SPhilipp Reisner 524b411b363SPhilipp Reisner static int drbd_recv(struct drbd_conf *mdev, void *buf, size_t size) 525b411b363SPhilipp Reisner { 526b411b363SPhilipp Reisner mm_segment_t oldfs; 527b411b363SPhilipp Reisner struct kvec iov = { 528b411b363SPhilipp Reisner .iov_base = buf, 529b411b363SPhilipp Reisner .iov_len = size, 530b411b363SPhilipp Reisner }; 531b411b363SPhilipp Reisner struct msghdr msg = { 532b411b363SPhilipp Reisner .msg_iovlen = 1, 533b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 534b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 535b411b363SPhilipp Reisner }; 536b411b363SPhilipp Reisner int rv; 537b411b363SPhilipp Reisner 538b411b363SPhilipp Reisner oldfs = get_fs(); 539b411b363SPhilipp Reisner set_fs(KERNEL_DS); 540b411b363SPhilipp Reisner 541b411b363SPhilipp Reisner for (;;) { 542b411b363SPhilipp Reisner rv = sock_recvmsg(mdev->data.socket, &msg, size, msg.msg_flags); 543b411b363SPhilipp Reisner if (rv == size) 544b411b363SPhilipp Reisner break; 545b411b363SPhilipp Reisner 546b411b363SPhilipp Reisner /* Note: 547b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 548b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 549b411b363SPhilipp Reisner */ 550b411b363SPhilipp Reisner 551b411b363SPhilipp Reisner if (rv < 0) { 552b411b363SPhilipp Reisner if (rv == -ECONNRESET) 553b411b363SPhilipp Reisner dev_info(DEV, "sock was reset by peer\n"); 554b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 555b411b363SPhilipp Reisner dev_err(DEV, "sock_recvmsg returned %d\n", rv); 556b411b363SPhilipp Reisner break; 557b411b363SPhilipp Reisner } else if (rv == 0) { 558b411b363SPhilipp Reisner dev_info(DEV, "sock was shut down by peer\n"); 559b411b363SPhilipp Reisner break; 560b411b363SPhilipp Reisner } else { 561b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 562b411b363SPhilipp Reisner * after we read a partial message 563b411b363SPhilipp Reisner */ 564b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 565b411b363SPhilipp Reisner break; 566b411b363SPhilipp Reisner } 567b411b363SPhilipp Reisner }; 568b411b363SPhilipp Reisner 569b411b363SPhilipp Reisner set_fs(oldfs); 570b411b363SPhilipp Reisner 571b411b363SPhilipp Reisner if (rv != size) 572b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_BROKEN_PIPE)); 573b411b363SPhilipp Reisner 574b411b363SPhilipp Reisner return rv; 575b411b363SPhilipp Reisner } 576b411b363SPhilipp Reisner 5775dbf1673SLars Ellenberg /* quoting tcp(7): 5785dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5795dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5805dbf1673SLars Ellenberg * This is our wrapper to do so. 5815dbf1673SLars Ellenberg */ 5825dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5835dbf1673SLars Ellenberg unsigned int rcv) 5845dbf1673SLars Ellenberg { 5855dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5865dbf1673SLars Ellenberg if (snd) { 5875dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5885dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5895dbf1673SLars Ellenberg } 5905dbf1673SLars Ellenberg if (rcv) { 5915dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5925dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5935dbf1673SLars Ellenberg } 5945dbf1673SLars Ellenberg } 5955dbf1673SLars Ellenberg 596b411b363SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_conf *mdev) 597b411b363SPhilipp Reisner { 598b411b363SPhilipp Reisner const char *what; 599b411b363SPhilipp Reisner struct socket *sock; 600b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 601b411b363SPhilipp Reisner int err; 602b411b363SPhilipp Reisner int disconnect_on_error = 1; 603b411b363SPhilipp Reisner 604b411b363SPhilipp Reisner if (!get_net_conf(mdev)) 605b411b363SPhilipp Reisner return NULL; 606b411b363SPhilipp Reisner 607b411b363SPhilipp Reisner what = "sock_create_kern"; 608b411b363SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)mdev->net_conf->my_addr)->sa_family, 609b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 610b411b363SPhilipp Reisner if (err < 0) { 611b411b363SPhilipp Reisner sock = NULL; 612b411b363SPhilipp Reisner goto out; 613b411b363SPhilipp Reisner } 614b411b363SPhilipp Reisner 615b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 616b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = mdev->net_conf->try_connect_int*HZ; 6175dbf1673SLars Ellenberg drbd_setbufsize(sock, mdev->net_conf->sndbuf_size, 6185dbf1673SLars Ellenberg mdev->net_conf->rcvbuf_size); 619b411b363SPhilipp Reisner 620b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 621b411b363SPhilipp Reisner * for the outgoing connections. 622b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 623b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 624b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 625b411b363SPhilipp Reisner * a free one dynamically. 626b411b363SPhilipp Reisner */ 627b411b363SPhilipp Reisner memcpy(&src_in6, mdev->net_conf->my_addr, 628b411b363SPhilipp Reisner min_t(int, mdev->net_conf->my_addr_len, sizeof(src_in6))); 629b411b363SPhilipp Reisner if (((struct sockaddr *)mdev->net_conf->my_addr)->sa_family == AF_INET6) 630b411b363SPhilipp Reisner src_in6.sin6_port = 0; 631b411b363SPhilipp Reisner else 632b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 633b411b363SPhilipp Reisner 634b411b363SPhilipp Reisner what = "bind before connect"; 635b411b363SPhilipp Reisner err = sock->ops->bind(sock, 636b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 637b411b363SPhilipp Reisner mdev->net_conf->my_addr_len); 638b411b363SPhilipp Reisner if (err < 0) 639b411b363SPhilipp Reisner goto out; 640b411b363SPhilipp Reisner 641b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 642b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 643b411b363SPhilipp Reisner disconnect_on_error = 0; 644b411b363SPhilipp Reisner what = "connect"; 645b411b363SPhilipp Reisner err = sock->ops->connect(sock, 646b411b363SPhilipp Reisner (struct sockaddr *)mdev->net_conf->peer_addr, 647b411b363SPhilipp Reisner mdev->net_conf->peer_addr_len, 0); 648b411b363SPhilipp Reisner 649b411b363SPhilipp Reisner out: 650b411b363SPhilipp Reisner if (err < 0) { 651b411b363SPhilipp Reisner if (sock) { 652b411b363SPhilipp Reisner sock_release(sock); 653b411b363SPhilipp Reisner sock = NULL; 654b411b363SPhilipp Reisner } 655b411b363SPhilipp Reisner switch (-err) { 656b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 657b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 658b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 659b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 660b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 661b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 662b411b363SPhilipp Reisner disconnect_on_error = 0; 663b411b363SPhilipp Reisner break; 664b411b363SPhilipp Reisner default: 665b411b363SPhilipp Reisner dev_err(DEV, "%s failed, err = %d\n", what, err); 666b411b363SPhilipp Reisner } 667b411b363SPhilipp Reisner if (disconnect_on_error) 668b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 669b411b363SPhilipp Reisner } 670b411b363SPhilipp Reisner put_net_conf(mdev); 671b411b363SPhilipp Reisner return sock; 672b411b363SPhilipp Reisner } 673b411b363SPhilipp Reisner 674b411b363SPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_conf *mdev) 675b411b363SPhilipp Reisner { 676b411b363SPhilipp Reisner int timeo, err; 677b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 678b411b363SPhilipp Reisner const char *what; 679b411b363SPhilipp Reisner 680b411b363SPhilipp Reisner if (!get_net_conf(mdev)) 681b411b363SPhilipp Reisner return NULL; 682b411b363SPhilipp Reisner 683b411b363SPhilipp Reisner what = "sock_create_kern"; 684b411b363SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)mdev->net_conf->my_addr)->sa_family, 685b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 686b411b363SPhilipp Reisner if (err) { 687b411b363SPhilipp Reisner s_listen = NULL; 688b411b363SPhilipp Reisner goto out; 689b411b363SPhilipp Reisner } 690b411b363SPhilipp Reisner 691b411b363SPhilipp Reisner timeo = mdev->net_conf->try_connect_int * HZ; 692b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 693b411b363SPhilipp Reisner 694b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 695b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 696b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 6975dbf1673SLars Ellenberg drbd_setbufsize(s_listen, mdev->net_conf->sndbuf_size, 6985dbf1673SLars Ellenberg mdev->net_conf->rcvbuf_size); 699b411b363SPhilipp Reisner 700b411b363SPhilipp Reisner what = "bind before listen"; 701b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 702b411b363SPhilipp Reisner (struct sockaddr *) mdev->net_conf->my_addr, 703b411b363SPhilipp Reisner mdev->net_conf->my_addr_len); 704b411b363SPhilipp Reisner if (err < 0) 705b411b363SPhilipp Reisner goto out; 706b411b363SPhilipp Reisner 707b411b363SPhilipp Reisner err = drbd_accept(mdev, &what, s_listen, &s_estab); 708b411b363SPhilipp Reisner 709b411b363SPhilipp Reisner out: 710b411b363SPhilipp Reisner if (s_listen) 711b411b363SPhilipp Reisner sock_release(s_listen); 712b411b363SPhilipp Reisner if (err < 0) { 713b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 714b411b363SPhilipp Reisner dev_err(DEV, "%s failed, err = %d\n", what, err); 715b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 716b411b363SPhilipp Reisner } 717b411b363SPhilipp Reisner } 718b411b363SPhilipp Reisner put_net_conf(mdev); 719b411b363SPhilipp Reisner 720b411b363SPhilipp Reisner return s_estab; 721b411b363SPhilipp Reisner } 722b411b363SPhilipp Reisner 723b411b363SPhilipp Reisner static int drbd_send_fp(struct drbd_conf *mdev, 724b411b363SPhilipp Reisner struct socket *sock, enum drbd_packets cmd) 725b411b363SPhilipp Reisner { 72602918be2SPhilipp Reisner struct p_header80 *h = &mdev->data.sbuf.header.h80; 727b411b363SPhilipp Reisner 728b411b363SPhilipp Reisner return _drbd_send_cmd(mdev, sock, cmd, h, sizeof(*h), 0); 729b411b363SPhilipp Reisner } 730b411b363SPhilipp Reisner 731b411b363SPhilipp Reisner static enum drbd_packets drbd_recv_fp(struct drbd_conf *mdev, struct socket *sock) 732b411b363SPhilipp Reisner { 73302918be2SPhilipp Reisner struct p_header80 *h = &mdev->data.rbuf.header.h80; 734b411b363SPhilipp Reisner int rr; 735b411b363SPhilipp Reisner 736b411b363SPhilipp Reisner rr = drbd_recv_short(mdev, sock, h, sizeof(*h), 0); 737b411b363SPhilipp Reisner 738b411b363SPhilipp Reisner if (rr == sizeof(*h) && h->magic == BE_DRBD_MAGIC) 739b411b363SPhilipp Reisner return be16_to_cpu(h->command); 740b411b363SPhilipp Reisner 741b411b363SPhilipp Reisner return 0xffff; 742b411b363SPhilipp Reisner } 743b411b363SPhilipp Reisner 744b411b363SPhilipp Reisner /** 745b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 746b411b363SPhilipp Reisner * @mdev: DRBD device. 747b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 748b411b363SPhilipp Reisner */ 749b411b363SPhilipp Reisner static int drbd_socket_okay(struct drbd_conf *mdev, struct socket **sock) 750b411b363SPhilipp Reisner { 751b411b363SPhilipp Reisner int rr; 752b411b363SPhilipp Reisner char tb[4]; 753b411b363SPhilipp Reisner 754b411b363SPhilipp Reisner if (!*sock) 755b411b363SPhilipp Reisner return FALSE; 756b411b363SPhilipp Reisner 757b411b363SPhilipp Reisner rr = drbd_recv_short(mdev, *sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 758b411b363SPhilipp Reisner 759b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 760b411b363SPhilipp Reisner return TRUE; 761b411b363SPhilipp Reisner } else { 762b411b363SPhilipp Reisner sock_release(*sock); 763b411b363SPhilipp Reisner *sock = NULL; 764b411b363SPhilipp Reisner return FALSE; 765b411b363SPhilipp Reisner } 766b411b363SPhilipp Reisner } 767b411b363SPhilipp Reisner 768b411b363SPhilipp Reisner /* 769b411b363SPhilipp Reisner * return values: 770b411b363SPhilipp Reisner * 1 yes, we have a valid connection 771b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 772b411b363SPhilipp Reisner * -1 peer talks different language, 773b411b363SPhilipp Reisner * no point in trying again, please go standalone. 774b411b363SPhilipp Reisner * -2 We do not have a network config... 775b411b363SPhilipp Reisner */ 776b411b363SPhilipp Reisner static int drbd_connect(struct drbd_conf *mdev) 777b411b363SPhilipp Reisner { 778b411b363SPhilipp Reisner struct socket *s, *sock, *msock; 779b411b363SPhilipp Reisner int try, h, ok; 780b411b363SPhilipp Reisner 781b411b363SPhilipp Reisner D_ASSERT(!mdev->data.socket); 782b411b363SPhilipp Reisner 783b411b363SPhilipp Reisner if (drbd_request_state(mdev, NS(conn, C_WF_CONNECTION)) < SS_SUCCESS) 784b411b363SPhilipp Reisner return -2; 785b411b363SPhilipp Reisner 786b411b363SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &mdev->flags); 787b411b363SPhilipp Reisner 788b411b363SPhilipp Reisner sock = NULL; 789b411b363SPhilipp Reisner msock = NULL; 790b411b363SPhilipp Reisner 791b411b363SPhilipp Reisner do { 792b411b363SPhilipp Reisner for (try = 0;;) { 793b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 794b411b363SPhilipp Reisner s = drbd_try_connect(mdev); 795b411b363SPhilipp Reisner if (s || ++try >= 3) 796b411b363SPhilipp Reisner break; 797b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 798b411b363SPhilipp Reisner __set_current_state(TASK_INTERRUPTIBLE); 799b411b363SPhilipp Reisner schedule_timeout(HZ / 10); 800b411b363SPhilipp Reisner } 801b411b363SPhilipp Reisner 802b411b363SPhilipp Reisner if (s) { 803b411b363SPhilipp Reisner if (!sock) { 804b411b363SPhilipp Reisner drbd_send_fp(mdev, s, P_HAND_SHAKE_S); 805b411b363SPhilipp Reisner sock = s; 806b411b363SPhilipp Reisner s = NULL; 807b411b363SPhilipp Reisner } else if (!msock) { 808b411b363SPhilipp Reisner drbd_send_fp(mdev, s, P_HAND_SHAKE_M); 809b411b363SPhilipp Reisner msock = s; 810b411b363SPhilipp Reisner s = NULL; 811b411b363SPhilipp Reisner } else { 812b411b363SPhilipp Reisner dev_err(DEV, "Logic error in drbd_connect()\n"); 813b411b363SPhilipp Reisner goto out_release_sockets; 814b411b363SPhilipp Reisner } 815b411b363SPhilipp Reisner } 816b411b363SPhilipp Reisner 817b411b363SPhilipp Reisner if (sock && msock) { 818b411b363SPhilipp Reisner __set_current_state(TASK_INTERRUPTIBLE); 819b411b363SPhilipp Reisner schedule_timeout(HZ / 10); 820b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &sock); 821b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &msock) && ok; 822b411b363SPhilipp Reisner if (ok) 823b411b363SPhilipp Reisner break; 824b411b363SPhilipp Reisner } 825b411b363SPhilipp Reisner 826b411b363SPhilipp Reisner retry: 827b411b363SPhilipp Reisner s = drbd_wait_for_connect(mdev); 828b411b363SPhilipp Reisner if (s) { 829b411b363SPhilipp Reisner try = drbd_recv_fp(mdev, s); 830b411b363SPhilipp Reisner drbd_socket_okay(mdev, &sock); 831b411b363SPhilipp Reisner drbd_socket_okay(mdev, &msock); 832b411b363SPhilipp Reisner switch (try) { 833b411b363SPhilipp Reisner case P_HAND_SHAKE_S: 834b411b363SPhilipp Reisner if (sock) { 835b411b363SPhilipp Reisner dev_warn(DEV, "initial packet S crossed\n"); 836b411b363SPhilipp Reisner sock_release(sock); 837b411b363SPhilipp Reisner } 838b411b363SPhilipp Reisner sock = s; 839b411b363SPhilipp Reisner break; 840b411b363SPhilipp Reisner case P_HAND_SHAKE_M: 841b411b363SPhilipp Reisner if (msock) { 842b411b363SPhilipp Reisner dev_warn(DEV, "initial packet M crossed\n"); 843b411b363SPhilipp Reisner sock_release(msock); 844b411b363SPhilipp Reisner } 845b411b363SPhilipp Reisner msock = s; 846b411b363SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &mdev->flags); 847b411b363SPhilipp Reisner break; 848b411b363SPhilipp Reisner default: 849b411b363SPhilipp Reisner dev_warn(DEV, "Error receiving initial packet\n"); 850b411b363SPhilipp Reisner sock_release(s); 851b411b363SPhilipp Reisner if (random32() & 1) 852b411b363SPhilipp Reisner goto retry; 853b411b363SPhilipp Reisner } 854b411b363SPhilipp Reisner } 855b411b363SPhilipp Reisner 856b411b363SPhilipp Reisner if (mdev->state.conn <= C_DISCONNECTING) 857b411b363SPhilipp Reisner goto out_release_sockets; 858b411b363SPhilipp Reisner if (signal_pending(current)) { 859b411b363SPhilipp Reisner flush_signals(current); 860b411b363SPhilipp Reisner smp_rmb(); 861b411b363SPhilipp Reisner if (get_t_state(&mdev->receiver) == Exiting) 862b411b363SPhilipp Reisner goto out_release_sockets; 863b411b363SPhilipp Reisner } 864b411b363SPhilipp Reisner 865b411b363SPhilipp Reisner if (sock && msock) { 866b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &sock); 867b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &msock) && ok; 868b411b363SPhilipp Reisner if (ok) 869b411b363SPhilipp Reisner break; 870b411b363SPhilipp Reisner } 871b411b363SPhilipp Reisner } while (1); 872b411b363SPhilipp Reisner 873b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 874b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 875b411b363SPhilipp Reisner 876b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 877b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 878b411b363SPhilipp Reisner 879b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 880b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 881b411b363SPhilipp Reisner 882b411b363SPhilipp Reisner /* NOT YET ... 883b411b363SPhilipp Reisner * sock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10; 884b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 885b411b363SPhilipp Reisner * first set it to the P_HAND_SHAKE timeout, 886b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 887b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 888b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = mdev->net_conf->ping_timeo*4*HZ/10; 889b411b363SPhilipp Reisner 890b411b363SPhilipp Reisner msock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10; 891b411b363SPhilipp Reisner msock->sk->sk_rcvtimeo = mdev->net_conf->ping_int*HZ; 892b411b363SPhilipp Reisner 893b411b363SPhilipp Reisner /* we don't want delays. 894b411b363SPhilipp Reisner * we use TCP_CORK where apropriate, though */ 895b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 896b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 897b411b363SPhilipp Reisner 898b411b363SPhilipp Reisner mdev->data.socket = sock; 899b411b363SPhilipp Reisner mdev->meta.socket = msock; 900b411b363SPhilipp Reisner mdev->last_received = jiffies; 901b411b363SPhilipp Reisner 902b411b363SPhilipp Reisner D_ASSERT(mdev->asender.task == NULL); 903b411b363SPhilipp Reisner 904b411b363SPhilipp Reisner h = drbd_do_handshake(mdev); 905b411b363SPhilipp Reisner if (h <= 0) 906b411b363SPhilipp Reisner return h; 907b411b363SPhilipp Reisner 908b411b363SPhilipp Reisner if (mdev->cram_hmac_tfm) { 909b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 910b10d96cbSJohannes Thoma switch (drbd_do_auth(mdev)) { 911b10d96cbSJohannes Thoma case -1: 912b411b363SPhilipp Reisner dev_err(DEV, "Authentication of peer failed\n"); 913b411b363SPhilipp Reisner return -1; 914b10d96cbSJohannes Thoma case 0: 915b10d96cbSJohannes Thoma dev_err(DEV, "Authentication of peer failed, trying again.\n"); 916b10d96cbSJohannes Thoma return 0; 917b411b363SPhilipp Reisner } 918b411b363SPhilipp Reisner } 919b411b363SPhilipp Reisner 920b411b363SPhilipp Reisner if (drbd_request_state(mdev, NS(conn, C_WF_REPORT_PARAMS)) < SS_SUCCESS) 921b411b363SPhilipp Reisner return 0; 922b411b363SPhilipp Reisner 923b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10; 924b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 925b411b363SPhilipp Reisner 926b411b363SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 927b411b363SPhilipp Reisner mdev->peer_seq = 0; 928b411b363SPhilipp Reisner 929b411b363SPhilipp Reisner drbd_thread_start(&mdev->asender); 930b411b363SPhilipp Reisner 931d5373389SPhilipp Reisner if (mdev->agreed_pro_version < 95 && get_ldev(mdev)) { 932d5373389SPhilipp Reisner drbd_setup_queue_param(mdev, DRBD_MAX_SIZE_H80_PACKET); 933d5373389SPhilipp Reisner put_ldev(mdev); 934d5373389SPhilipp Reisner } 935d5373389SPhilipp Reisner 9367e2455c1SPhilipp Reisner if (!drbd_send_protocol(mdev)) 9377e2455c1SPhilipp Reisner return -1; 938b411b363SPhilipp Reisner drbd_send_sync_param(mdev, &mdev->sync_conf); 939e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, 0); 940b411b363SPhilipp Reisner drbd_send_uuids(mdev); 941b411b363SPhilipp Reisner drbd_send_state(mdev); 942b411b363SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 943b411b363SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 944b411b363SPhilipp Reisner 945b411b363SPhilipp Reisner return 1; 946b411b363SPhilipp Reisner 947b411b363SPhilipp Reisner out_release_sockets: 948b411b363SPhilipp Reisner if (sock) 949b411b363SPhilipp Reisner sock_release(sock); 950b411b363SPhilipp Reisner if (msock) 951b411b363SPhilipp Reisner sock_release(msock); 952b411b363SPhilipp Reisner return -1; 953b411b363SPhilipp Reisner } 954b411b363SPhilipp Reisner 95502918be2SPhilipp Reisner static int drbd_recv_header(struct drbd_conf *mdev, enum drbd_packets *cmd, unsigned int *packet_size) 956b411b363SPhilipp Reisner { 95702918be2SPhilipp Reisner union p_header *h = &mdev->data.rbuf.header; 958b411b363SPhilipp Reisner int r; 959b411b363SPhilipp Reisner 960b411b363SPhilipp Reisner r = drbd_recv(mdev, h, sizeof(*h)); 961b411b363SPhilipp Reisner if (unlikely(r != sizeof(*h))) { 962b411b363SPhilipp Reisner dev_err(DEV, "short read expecting header on sock: r=%d\n", r); 963b411b363SPhilipp Reisner return FALSE; 96402918be2SPhilipp Reisner } 96502918be2SPhilipp Reisner 96602918be2SPhilipp Reisner if (likely(h->h80.magic == BE_DRBD_MAGIC)) { 96702918be2SPhilipp Reisner *cmd = be16_to_cpu(h->h80.command); 96802918be2SPhilipp Reisner *packet_size = be16_to_cpu(h->h80.length); 96902918be2SPhilipp Reisner } else if (h->h95.magic == BE_DRBD_MAGIC_BIG) { 97002918be2SPhilipp Reisner *cmd = be16_to_cpu(h->h95.command); 97102918be2SPhilipp Reisner *packet_size = be32_to_cpu(h->h95.length); 97202918be2SPhilipp Reisner } else { 973004352faSLars Ellenberg dev_err(DEV, "magic?? on data m: 0x%08x c: %d l: %d\n", 974004352faSLars Ellenberg be32_to_cpu(h->h80.magic), 975004352faSLars Ellenberg be16_to_cpu(h->h80.command), 976004352faSLars Ellenberg be16_to_cpu(h->h80.length)); 977b411b363SPhilipp Reisner return FALSE; 978b411b363SPhilipp Reisner } 979b411b363SPhilipp Reisner mdev->last_received = jiffies; 980b411b363SPhilipp Reisner 981b411b363SPhilipp Reisner return TRUE; 982b411b363SPhilipp Reisner } 983b411b363SPhilipp Reisner 984b411b363SPhilipp Reisner static enum finish_epoch drbd_flush_after_epoch(struct drbd_conf *mdev, struct drbd_epoch *epoch) 985b411b363SPhilipp Reisner { 986b411b363SPhilipp Reisner int rv; 987b411b363SPhilipp Reisner 988b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 989fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 990fbd9b09aSDmitry Monakhov NULL, BLKDEV_IFL_WAIT); 991b411b363SPhilipp Reisner if (rv) { 992b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 993b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 994b411b363SPhilipp Reisner * don't try again for ANY return value != 0 995b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 996b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 997b411b363SPhilipp Reisner } 998b411b363SPhilipp Reisner put_ldev(mdev); 999b411b363SPhilipp Reisner } 1000b411b363SPhilipp Reisner 1001b411b363SPhilipp Reisner return drbd_may_finish_epoch(mdev, epoch, EV_BARRIER_DONE); 1002b411b363SPhilipp Reisner } 1003b411b363SPhilipp Reisner 1004b411b363SPhilipp Reisner static int w_flush(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1005b411b363SPhilipp Reisner { 1006b411b363SPhilipp Reisner struct flush_work *fw = (struct flush_work *)w; 1007b411b363SPhilipp Reisner struct drbd_epoch *epoch = fw->epoch; 1008b411b363SPhilipp Reisner 1009b411b363SPhilipp Reisner kfree(w); 1010b411b363SPhilipp Reisner 1011b411b363SPhilipp Reisner if (!test_and_set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags)) 1012b411b363SPhilipp Reisner drbd_flush_after_epoch(mdev, epoch); 1013b411b363SPhilipp Reisner 1014b411b363SPhilipp Reisner drbd_may_finish_epoch(mdev, epoch, EV_PUT | 1015b411b363SPhilipp Reisner (mdev->state.conn < C_CONNECTED ? EV_CLEANUP : 0)); 1016b411b363SPhilipp Reisner 1017b411b363SPhilipp Reisner return 1; 1018b411b363SPhilipp Reisner } 1019b411b363SPhilipp Reisner 1020b411b363SPhilipp Reisner /** 1021b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1022b411b363SPhilipp Reisner * @mdev: DRBD device. 1023b411b363SPhilipp Reisner * @epoch: Epoch object. 1024b411b363SPhilipp Reisner * @ev: Epoch event. 1025b411b363SPhilipp Reisner */ 1026b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 1027b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1028b411b363SPhilipp Reisner enum epoch_event ev) 1029b411b363SPhilipp Reisner { 1030b411b363SPhilipp Reisner int finish, epoch_size; 1031b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1032b411b363SPhilipp Reisner int schedule_flush = 0; 1033b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1034b411b363SPhilipp Reisner 1035b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1036b411b363SPhilipp Reisner do { 1037b411b363SPhilipp Reisner next_epoch = NULL; 1038b411b363SPhilipp Reisner finish = 0; 1039b411b363SPhilipp Reisner 1040b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1041b411b363SPhilipp Reisner 1042b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1043b411b363SPhilipp Reisner case EV_PUT: 1044b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1045b411b363SPhilipp Reisner break; 1046b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1047b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1048b411b363SPhilipp Reisner 1049b411b363SPhilipp Reisner /* Special case: If we just switched from WO_bio_barrier to 1050b411b363SPhilipp Reisner WO_bdev_flush we should not finish the current epoch */ 1051b411b363SPhilipp Reisner if (test_bit(DE_CONTAINS_A_BARRIER, &epoch->flags) && epoch_size == 1 && 1052b411b363SPhilipp Reisner mdev->write_ordering != WO_bio_barrier && 1053b411b363SPhilipp Reisner epoch == mdev->current_epoch) 1054b411b363SPhilipp Reisner clear_bit(DE_CONTAINS_A_BARRIER, &epoch->flags); 1055b411b363SPhilipp Reisner break; 1056b411b363SPhilipp Reisner case EV_BARRIER_DONE: 1057b411b363SPhilipp Reisner set_bit(DE_BARRIER_IN_NEXT_EPOCH_DONE, &epoch->flags); 1058b411b363SPhilipp Reisner break; 1059b411b363SPhilipp Reisner case EV_BECAME_LAST: 1060b411b363SPhilipp Reisner /* nothing to do*/ 1061b411b363SPhilipp Reisner break; 1062b411b363SPhilipp Reisner } 1063b411b363SPhilipp Reisner 1064b411b363SPhilipp Reisner if (epoch_size != 0 && 1065b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 1066b411b363SPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) && 1067b411b363SPhilipp Reisner epoch->list.prev == &mdev->current_epoch->list && 1068b411b363SPhilipp Reisner !test_bit(DE_IS_FINISHING, &epoch->flags)) { 1069b411b363SPhilipp Reisner /* Nearly all conditions are met to finish that epoch... */ 1070b411b363SPhilipp Reisner if (test_bit(DE_BARRIER_IN_NEXT_EPOCH_DONE, &epoch->flags) || 1071b411b363SPhilipp Reisner mdev->write_ordering == WO_none || 1072b411b363SPhilipp Reisner (epoch_size == 1 && test_bit(DE_CONTAINS_A_BARRIER, &epoch->flags)) || 1073b411b363SPhilipp Reisner ev & EV_CLEANUP) { 1074b411b363SPhilipp Reisner finish = 1; 1075b411b363SPhilipp Reisner set_bit(DE_IS_FINISHING, &epoch->flags); 1076b411b363SPhilipp Reisner } else if (!test_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags) && 1077b411b363SPhilipp Reisner mdev->write_ordering == WO_bio_barrier) { 1078b411b363SPhilipp Reisner atomic_inc(&epoch->active); 1079b411b363SPhilipp Reisner schedule_flush = 1; 1080b411b363SPhilipp Reisner } 1081b411b363SPhilipp Reisner } 1082b411b363SPhilipp Reisner if (finish) { 1083b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1084b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1085b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1086b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1087b411b363SPhilipp Reisner } 1088b411b363SPhilipp Reisner dec_unacked(mdev); 1089b411b363SPhilipp Reisner 1090b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1091b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1092b411b363SPhilipp Reisner list_del(&epoch->list); 1093b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1094b411b363SPhilipp Reisner mdev->epochs--; 1095b411b363SPhilipp Reisner kfree(epoch); 1096b411b363SPhilipp Reisner 1097b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1098b411b363SPhilipp Reisner rv = FE_DESTROYED; 1099b411b363SPhilipp Reisner } else { 1100b411b363SPhilipp Reisner epoch->flags = 0; 1101b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1102698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1103b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1104b411b363SPhilipp Reisner rv = FE_RECYCLED; 1105b411b363SPhilipp Reisner } 1106b411b363SPhilipp Reisner } 1107b411b363SPhilipp Reisner 1108b411b363SPhilipp Reisner if (!next_epoch) 1109b411b363SPhilipp Reisner break; 1110b411b363SPhilipp Reisner 1111b411b363SPhilipp Reisner epoch = next_epoch; 1112b411b363SPhilipp Reisner } while (1); 1113b411b363SPhilipp Reisner 1114b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1115b411b363SPhilipp Reisner 1116b411b363SPhilipp Reisner if (schedule_flush) { 1117b411b363SPhilipp Reisner struct flush_work *fw; 1118b411b363SPhilipp Reisner fw = kmalloc(sizeof(*fw), GFP_ATOMIC); 1119b411b363SPhilipp Reisner if (fw) { 1120b411b363SPhilipp Reisner fw->w.cb = w_flush; 1121b411b363SPhilipp Reisner fw->epoch = epoch; 1122b411b363SPhilipp Reisner drbd_queue_work(&mdev->data.work, &fw->w); 1123b411b363SPhilipp Reisner } else { 1124b411b363SPhilipp Reisner dev_warn(DEV, "Could not kmalloc a flush_work obj\n"); 1125b411b363SPhilipp Reisner set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags); 1126b411b363SPhilipp Reisner /* That is not a recursion, only one level */ 1127b411b363SPhilipp Reisner drbd_may_finish_epoch(mdev, epoch, EV_BARRIER_DONE); 1128b411b363SPhilipp Reisner drbd_may_finish_epoch(mdev, epoch, EV_PUT); 1129b411b363SPhilipp Reisner } 1130b411b363SPhilipp Reisner } 1131b411b363SPhilipp Reisner 1132b411b363SPhilipp Reisner return rv; 1133b411b363SPhilipp Reisner } 1134b411b363SPhilipp Reisner 1135b411b363SPhilipp Reisner /** 1136b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1137b411b363SPhilipp Reisner * @mdev: DRBD device. 1138b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1139b411b363SPhilipp Reisner */ 1140b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1141b411b363SPhilipp Reisner { 1142b411b363SPhilipp Reisner enum write_ordering_e pwo; 1143b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1144b411b363SPhilipp Reisner [WO_none] = "none", 1145b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1146b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1147b411b363SPhilipp Reisner [WO_bio_barrier] = "barrier", 1148b411b363SPhilipp Reisner }; 1149b411b363SPhilipp Reisner 1150b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1151b411b363SPhilipp Reisner wo = min(pwo, wo); 1152b411b363SPhilipp Reisner if (wo == WO_bio_barrier && mdev->ldev->dc.no_disk_barrier) 1153b411b363SPhilipp Reisner wo = WO_bdev_flush; 1154b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1155b411b363SPhilipp Reisner wo = WO_drain_io; 1156b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1157b411b363SPhilipp Reisner wo = WO_none; 1158b411b363SPhilipp Reisner mdev->write_ordering = wo; 1159b411b363SPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bio_barrier) 1160b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1161b411b363SPhilipp Reisner } 1162b411b363SPhilipp Reisner 1163b411b363SPhilipp Reisner /** 116445bb912bSLars Ellenberg * drbd_submit_ee() 116545bb912bSLars Ellenberg * @mdev: DRBD device. 116645bb912bSLars Ellenberg * @e: epoch entry 116745bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 116845bb912bSLars Ellenberg */ 116945bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 117045bb912bSLars Ellenberg int drbd_submit_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e, 117145bb912bSLars Ellenberg const unsigned rw, const int fault_type) 117245bb912bSLars Ellenberg { 117345bb912bSLars Ellenberg struct bio *bios = NULL; 117445bb912bSLars Ellenberg struct bio *bio; 117545bb912bSLars Ellenberg struct page *page = e->pages; 117645bb912bSLars Ellenberg sector_t sector = e->sector; 117745bb912bSLars Ellenberg unsigned ds = e->size; 117845bb912bSLars Ellenberg unsigned n_bios = 0; 117945bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 118045bb912bSLars Ellenberg 118145bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 118245bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 118345bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 118445bb912bSLars Ellenberg * request in more than one bio. */ 118545bb912bSLars Ellenberg next_bio: 118645bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 118745bb912bSLars Ellenberg if (!bio) { 118845bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 118945bb912bSLars Ellenberg goto fail; 119045bb912bSLars Ellenberg } 119145bb912bSLars Ellenberg /* > e->sector, unless this is the first bio */ 119245bb912bSLars Ellenberg bio->bi_sector = sector; 119345bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 119445bb912bSLars Ellenberg /* we special case some flags in the multi-bio case, see below 11957b6d91daSChristoph Hellwig * (REQ_UNPLUG, REQ_HARDBARRIER) */ 119645bb912bSLars Ellenberg bio->bi_rw = rw; 119745bb912bSLars Ellenberg bio->bi_private = e; 119845bb912bSLars Ellenberg bio->bi_end_io = drbd_endio_sec; 119945bb912bSLars Ellenberg 120045bb912bSLars Ellenberg bio->bi_next = bios; 120145bb912bSLars Ellenberg bios = bio; 120245bb912bSLars Ellenberg ++n_bios; 120345bb912bSLars Ellenberg 120445bb912bSLars Ellenberg page_chain_for_each(page) { 120545bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 120645bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 120745bb912bSLars Ellenberg /* a single page must always be possible! */ 120845bb912bSLars Ellenberg BUG_ON(bio->bi_vcnt == 0); 120945bb912bSLars Ellenberg goto next_bio; 121045bb912bSLars Ellenberg } 121145bb912bSLars Ellenberg ds -= len; 121245bb912bSLars Ellenberg sector += len >> 9; 121345bb912bSLars Ellenberg --nr_pages; 121445bb912bSLars Ellenberg } 121545bb912bSLars Ellenberg D_ASSERT(page == NULL); 121645bb912bSLars Ellenberg D_ASSERT(ds == 0); 121745bb912bSLars Ellenberg 121845bb912bSLars Ellenberg atomic_set(&e->pending_bios, n_bios); 121945bb912bSLars Ellenberg do { 122045bb912bSLars Ellenberg bio = bios; 122145bb912bSLars Ellenberg bios = bios->bi_next; 122245bb912bSLars Ellenberg bio->bi_next = NULL; 122345bb912bSLars Ellenberg 12247b6d91daSChristoph Hellwig /* strip off REQ_UNPLUG unless it is the last bio */ 122545bb912bSLars Ellenberg if (bios) 12267b6d91daSChristoph Hellwig bio->bi_rw &= ~REQ_UNPLUG; 122745bb912bSLars Ellenberg 122845bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 122945bb912bSLars Ellenberg 12307b6d91daSChristoph Hellwig /* strip off REQ_HARDBARRIER, 123145bb912bSLars Ellenberg * unless it is the first or last bio */ 123245bb912bSLars Ellenberg if (bios && bios->bi_next) 12337b6d91daSChristoph Hellwig bios->bi_rw &= ~REQ_HARDBARRIER; 123445bb912bSLars Ellenberg } while (bios); 123545bb912bSLars Ellenberg maybe_kick_lo(mdev); 123645bb912bSLars Ellenberg return 0; 123745bb912bSLars Ellenberg 123845bb912bSLars Ellenberg fail: 123945bb912bSLars Ellenberg while (bios) { 124045bb912bSLars Ellenberg bio = bios; 124145bb912bSLars Ellenberg bios = bios->bi_next; 124245bb912bSLars Ellenberg bio_put(bio); 124345bb912bSLars Ellenberg } 124445bb912bSLars Ellenberg return -ENOMEM; 124545bb912bSLars Ellenberg } 124645bb912bSLars Ellenberg 124745bb912bSLars Ellenberg /** 12487b6d91daSChristoph Hellwig * w_e_reissue() - Worker callback; Resubmit a bio, without REQ_HARDBARRIER set 1249b411b363SPhilipp Reisner * @mdev: DRBD device. 1250b411b363SPhilipp Reisner * @w: work object. 1251b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways (unused in this callback) 1252b411b363SPhilipp Reisner */ 1253b411b363SPhilipp Reisner int w_e_reissue(struct drbd_conf *mdev, struct drbd_work *w, int cancel) __releases(local) 1254b411b363SPhilipp Reisner { 1255b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1256b411b363SPhilipp Reisner /* We leave DE_CONTAINS_A_BARRIER and EE_IS_BARRIER in place, 1257b411b363SPhilipp Reisner (and DE_BARRIER_IN_NEXT_EPOCH_ISSUED in the previous Epoch) 1258b411b363SPhilipp Reisner so that we can finish that epoch in drbd_may_finish_epoch(). 1259b411b363SPhilipp Reisner That is necessary if we already have a long chain of Epochs, before 12607b6d91daSChristoph Hellwig we realize that REQ_HARDBARRIER is actually not supported */ 1261b411b363SPhilipp Reisner 1262b411b363SPhilipp Reisner /* As long as the -ENOTSUPP on the barrier is reported immediately 1263b411b363SPhilipp Reisner that will never trigger. If it is reported late, we will just 1264b411b363SPhilipp Reisner print that warning and continue correctly for all future requests 1265b411b363SPhilipp Reisner with WO_bdev_flush */ 1266b411b363SPhilipp Reisner if (previous_epoch(mdev, e->epoch)) 1267b411b363SPhilipp Reisner dev_warn(DEV, "Write ordering was not enforced (one time event)\n"); 1268b411b363SPhilipp Reisner 1269b411b363SPhilipp Reisner /* we still have a local reference, 1270b411b363SPhilipp Reisner * get_ldev was done in receive_Data. */ 1271b411b363SPhilipp Reisner 1272b411b363SPhilipp Reisner e->w.cb = e_end_block; 127345bb912bSLars Ellenberg if (drbd_submit_ee(mdev, e, WRITE, DRBD_FAULT_DT_WR) != 0) { 127445bb912bSLars Ellenberg /* drbd_submit_ee fails for one reason only: 127545bb912bSLars Ellenberg * if was not able to allocate sufficient bios. 127645bb912bSLars Ellenberg * requeue, try again later. */ 127745bb912bSLars Ellenberg e->w.cb = w_e_reissue; 127845bb912bSLars Ellenberg drbd_queue_work(&mdev->data.work, &e->w); 127945bb912bSLars Ellenberg } 1280b411b363SPhilipp Reisner return 1; 1281b411b363SPhilipp Reisner } 1282b411b363SPhilipp Reisner 128302918be2SPhilipp Reisner static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 1284b411b363SPhilipp Reisner { 1285b411b363SPhilipp Reisner int rv, issue_flush; 128602918be2SPhilipp Reisner struct p_barrier *p = &mdev->data.rbuf.barrier; 1287b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1288b411b363SPhilipp Reisner 1289b411b363SPhilipp Reisner inc_unacked(mdev); 1290b411b363SPhilipp Reisner 1291b411b363SPhilipp Reisner if (mdev->net_conf->wire_protocol != DRBD_PROT_C) 1292b411b363SPhilipp Reisner drbd_kick_lo(mdev); 1293b411b363SPhilipp Reisner 1294b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1295b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1296b411b363SPhilipp Reisner 1297b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1298b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1299b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1300b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1301b411b363SPhilipp Reisner * completed. */ 1302b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1303b411b363SPhilipp Reisner case WO_bio_barrier: 1304b411b363SPhilipp Reisner case WO_none: 1305b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 1306b411b363SPhilipp Reisner return TRUE; 1307b411b363SPhilipp Reisner break; 1308b411b363SPhilipp Reisner 1309b411b363SPhilipp Reisner case WO_bdev_flush: 1310b411b363SPhilipp Reisner case WO_drain_io: 1311367a8d73SPhilipp Reisner if (rv == FE_STILL_LIVE) { 1312b411b363SPhilipp Reisner set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &mdev->current_epoch->flags); 1313b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 1314b411b363SPhilipp Reisner rv = drbd_flush_after_epoch(mdev, mdev->current_epoch); 1315367a8d73SPhilipp Reisner } 1316b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 1317b411b363SPhilipp Reisner return TRUE; 1318b411b363SPhilipp Reisner 1319b411b363SPhilipp Reisner /* The asender will send all the ACKs and barrier ACKs out, since 1320b411b363SPhilipp Reisner all EEs moved from the active_ee to the done_ee. We need to 1321b411b363SPhilipp Reisner provide a new epoch object for the EEs that come in soon */ 1322b411b363SPhilipp Reisner break; 1323b411b363SPhilipp Reisner } 1324b411b363SPhilipp Reisner 1325b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1326b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1327b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 1328b411b363SPhilipp Reisner if (!epoch) { 1329b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 1330d3db7b48SDan Carpenter issue_flush = !test_and_set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &mdev->current_epoch->flags); 1331b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 1332b411b363SPhilipp Reisner if (issue_flush) { 1333b411b363SPhilipp Reisner rv = drbd_flush_after_epoch(mdev, mdev->current_epoch); 1334b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 1335b411b363SPhilipp Reisner return TRUE; 1336b411b363SPhilipp Reisner } 1337b411b363SPhilipp Reisner 1338b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->done_ee); 1339b411b363SPhilipp Reisner 1340b411b363SPhilipp Reisner return TRUE; 1341b411b363SPhilipp Reisner } 1342b411b363SPhilipp Reisner 1343b411b363SPhilipp Reisner epoch->flags = 0; 1344b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1345b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1346b411b363SPhilipp Reisner 1347b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1348b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1349b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1350b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1351b411b363SPhilipp Reisner mdev->epochs++; 1352b411b363SPhilipp Reisner } else { 1353b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1354b411b363SPhilipp Reisner kfree(epoch); 1355b411b363SPhilipp Reisner } 1356b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1357b411b363SPhilipp Reisner 1358b411b363SPhilipp Reisner return TRUE; 1359b411b363SPhilipp Reisner } 1360b411b363SPhilipp Reisner 1361b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1362b411b363SPhilipp Reisner * and from receive_Data */ 1363b411b363SPhilipp Reisner static struct drbd_epoch_entry * 1364b411b363SPhilipp Reisner read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, int data_size) __must_hold(local) 1365b411b363SPhilipp Reisner { 13666666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1367b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 1368b411b363SPhilipp Reisner struct page *page; 136945bb912bSLars Ellenberg int dgs, ds, rr; 1370b411b363SPhilipp Reisner void *dig_in = mdev->int_dig_in; 1371b411b363SPhilipp Reisner void *dig_vv = mdev->int_dig_vv; 13726b4388acSPhilipp Reisner unsigned long *data; 1373b411b363SPhilipp Reisner 1374b411b363SPhilipp Reisner dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_r_tfm) ? 1375b411b363SPhilipp Reisner crypto_hash_digestsize(mdev->integrity_r_tfm) : 0; 1376b411b363SPhilipp Reisner 1377b411b363SPhilipp Reisner if (dgs) { 1378b411b363SPhilipp Reisner rr = drbd_recv(mdev, dig_in, dgs); 1379b411b363SPhilipp Reisner if (rr != dgs) { 1380b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data digest: read %d expected %d\n", 1381b411b363SPhilipp Reisner rr, dgs); 1382b411b363SPhilipp Reisner return NULL; 1383b411b363SPhilipp Reisner } 1384b411b363SPhilipp Reisner } 1385b411b363SPhilipp Reisner 1386b411b363SPhilipp Reisner data_size -= dgs; 1387b411b363SPhilipp Reisner 1388b411b363SPhilipp Reisner ERR_IF(data_size & 0x1ff) return NULL; 1389b411b363SPhilipp Reisner ERR_IF(data_size > DRBD_MAX_SEGMENT_SIZE) return NULL; 1390b411b363SPhilipp Reisner 13916666032aSLars Ellenberg /* even though we trust out peer, 13926666032aSLars Ellenberg * we sometimes have to double check. */ 13936666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 13946666032aSLars Ellenberg dev_err(DEV, "capacity: %llus < sector: %llus + size: %u\n", 13956666032aSLars Ellenberg (unsigned long long)capacity, 13966666032aSLars Ellenberg (unsigned long long)sector, data_size); 13976666032aSLars Ellenberg return NULL; 13986666032aSLars Ellenberg } 13996666032aSLars Ellenberg 1400b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1401b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1402b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1403b411b363SPhilipp Reisner e = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO); 1404b411b363SPhilipp Reisner if (!e) 1405b411b363SPhilipp Reisner return NULL; 140645bb912bSLars Ellenberg 1407b411b363SPhilipp Reisner ds = data_size; 140845bb912bSLars Ellenberg page = e->pages; 140945bb912bSLars Ellenberg page_chain_for_each(page) { 141045bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 14116b4388acSPhilipp Reisner data = kmap(page); 141245bb912bSLars Ellenberg rr = drbd_recv(mdev, data, len); 14136b4388acSPhilipp Reisner if (FAULT_ACTIVE(mdev, DRBD_FAULT_RECEIVE)) { 14146b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 14156b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 14166b4388acSPhilipp Reisner } 1417b411b363SPhilipp Reisner kunmap(page); 141845bb912bSLars Ellenberg if (rr != len) { 1419b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 1420b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 142145bb912bSLars Ellenberg rr, len); 1422b411b363SPhilipp Reisner return NULL; 1423b411b363SPhilipp Reisner } 1424b411b363SPhilipp Reisner ds -= rr; 1425b411b363SPhilipp Reisner } 1426b411b363SPhilipp Reisner 1427b411b363SPhilipp Reisner if (dgs) { 142845bb912bSLars Ellenberg drbd_csum_ee(mdev, mdev->integrity_r_tfm, e, dig_vv); 1429b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1430b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED.\n"); 1431b411b363SPhilipp Reisner drbd_bcast_ee(mdev, "digest failed", 1432b411b363SPhilipp Reisner dgs, dig_in, dig_vv, e); 1433b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 1434b411b363SPhilipp Reisner return NULL; 1435b411b363SPhilipp Reisner } 1436b411b363SPhilipp Reisner } 1437b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1438b411b363SPhilipp Reisner return e; 1439b411b363SPhilipp Reisner } 1440b411b363SPhilipp Reisner 1441b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1442b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1443b411b363SPhilipp Reisner */ 1444b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1445b411b363SPhilipp Reisner { 1446b411b363SPhilipp Reisner struct page *page; 1447b411b363SPhilipp Reisner int rr, rv = 1; 1448b411b363SPhilipp Reisner void *data; 1449b411b363SPhilipp Reisner 1450c3470cdeSLars Ellenberg if (!data_size) 1451c3470cdeSLars Ellenberg return TRUE; 1452c3470cdeSLars Ellenberg 145345bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, 1, 1); 1454b411b363SPhilipp Reisner 1455b411b363SPhilipp Reisner data = kmap(page); 1456b411b363SPhilipp Reisner while (data_size) { 1457b411b363SPhilipp Reisner rr = drbd_recv(mdev, data, min_t(int, data_size, PAGE_SIZE)); 1458b411b363SPhilipp Reisner if (rr != min_t(int, data_size, PAGE_SIZE)) { 1459b411b363SPhilipp Reisner rv = 0; 1460b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 1461b411b363SPhilipp Reisner rr, min_t(int, data_size, PAGE_SIZE)); 1462b411b363SPhilipp Reisner break; 1463b411b363SPhilipp Reisner } 1464b411b363SPhilipp Reisner data_size -= rr; 1465b411b363SPhilipp Reisner } 1466b411b363SPhilipp Reisner kunmap(page); 1467435f0740SLars Ellenberg drbd_pp_free(mdev, page, 0); 1468b411b363SPhilipp Reisner return rv; 1469b411b363SPhilipp Reisner } 1470b411b363SPhilipp Reisner 1471b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1472b411b363SPhilipp Reisner sector_t sector, int data_size) 1473b411b363SPhilipp Reisner { 1474b411b363SPhilipp Reisner struct bio_vec *bvec; 1475b411b363SPhilipp Reisner struct bio *bio; 1476b411b363SPhilipp Reisner int dgs, rr, i, expect; 1477b411b363SPhilipp Reisner void *dig_in = mdev->int_dig_in; 1478b411b363SPhilipp Reisner void *dig_vv = mdev->int_dig_vv; 1479b411b363SPhilipp Reisner 1480b411b363SPhilipp Reisner dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_r_tfm) ? 1481b411b363SPhilipp Reisner crypto_hash_digestsize(mdev->integrity_r_tfm) : 0; 1482b411b363SPhilipp Reisner 1483b411b363SPhilipp Reisner if (dgs) { 1484b411b363SPhilipp Reisner rr = drbd_recv(mdev, dig_in, dgs); 1485b411b363SPhilipp Reisner if (rr != dgs) { 1486b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply digest: read %d expected %d\n", 1487b411b363SPhilipp Reisner rr, dgs); 1488b411b363SPhilipp Reisner return 0; 1489b411b363SPhilipp Reisner } 1490b411b363SPhilipp Reisner } 1491b411b363SPhilipp Reisner 1492b411b363SPhilipp Reisner data_size -= dgs; 1493b411b363SPhilipp Reisner 1494b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1495b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1496b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1497b411b363SPhilipp Reisner 1498b411b363SPhilipp Reisner bio = req->master_bio; 1499b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1500b411b363SPhilipp Reisner 1501b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1502b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1503b411b363SPhilipp Reisner rr = drbd_recv(mdev, 1504b411b363SPhilipp Reisner kmap(bvec->bv_page)+bvec->bv_offset, 1505b411b363SPhilipp Reisner expect); 1506b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1507b411b363SPhilipp Reisner if (rr != expect) { 1508b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply: " 1509b411b363SPhilipp Reisner "read %d expected %d\n", 1510b411b363SPhilipp Reisner rr, expect); 1511b411b363SPhilipp Reisner return 0; 1512b411b363SPhilipp Reisner } 1513b411b363SPhilipp Reisner data_size -= rr; 1514b411b363SPhilipp Reisner } 1515b411b363SPhilipp Reisner 1516b411b363SPhilipp Reisner if (dgs) { 151745bb912bSLars Ellenberg drbd_csum_bio(mdev, mdev->integrity_r_tfm, bio, dig_vv); 1518b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1519b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 1520b411b363SPhilipp Reisner return 0; 1521b411b363SPhilipp Reisner } 1522b411b363SPhilipp Reisner } 1523b411b363SPhilipp Reisner 1524b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 1525b411b363SPhilipp Reisner return 1; 1526b411b363SPhilipp Reisner } 1527b411b363SPhilipp Reisner 1528b411b363SPhilipp Reisner /* e_end_resync_block() is called via 1529b411b363SPhilipp Reisner * drbd_process_done_ee() by asender only */ 1530b411b363SPhilipp Reisner static int e_end_resync_block(struct drbd_conf *mdev, struct drbd_work *w, int unused) 1531b411b363SPhilipp Reisner { 1532b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1533b411b363SPhilipp Reisner sector_t sector = e->sector; 1534b411b363SPhilipp Reisner int ok; 1535b411b363SPhilipp Reisner 1536b411b363SPhilipp Reisner D_ASSERT(hlist_unhashed(&e->colision)); 1537b411b363SPhilipp Reisner 153845bb912bSLars Ellenberg if (likely((e->flags & EE_WAS_ERROR) == 0)) { 1539b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, e->size); 1540b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_RS_WRITE_ACK, e); 1541b411b363SPhilipp Reisner } else { 1542b411b363SPhilipp Reisner /* Record failure to sync */ 1543b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, e->size); 1544b411b363SPhilipp Reisner 1545b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_NEG_ACK, e); 1546b411b363SPhilipp Reisner } 1547b411b363SPhilipp Reisner dec_unacked(mdev); 1548b411b363SPhilipp Reisner 1549b411b363SPhilipp Reisner return ok; 1550b411b363SPhilipp Reisner } 1551b411b363SPhilipp Reisner 1552b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1553b411b363SPhilipp Reisner { 1554b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 1555b411b363SPhilipp Reisner 1556b411b363SPhilipp Reisner e = read_in_block(mdev, ID_SYNCER, sector, data_size); 155745bb912bSLars Ellenberg if (!e) 155845bb912bSLars Ellenberg goto fail; 1559b411b363SPhilipp Reisner 1560b411b363SPhilipp Reisner dec_rs_pending(mdev); 1561b411b363SPhilipp Reisner 1562b411b363SPhilipp Reisner inc_unacked(mdev); 1563b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1564b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1565b411b363SPhilipp Reisner 156645bb912bSLars Ellenberg e->w.cb = e_end_resync_block; 156745bb912bSLars Ellenberg 1568b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1569b411b363SPhilipp Reisner list_add(&e->w.list, &mdev->sync_ee); 1570b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1571b411b363SPhilipp Reisner 15720f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 157345bb912bSLars Ellenberg if (drbd_submit_ee(mdev, e, WRITE, DRBD_FAULT_RS_WR) == 0) 1574b411b363SPhilipp Reisner return TRUE; 157545bb912bSLars Ellenberg 157622cc37a9SLars Ellenberg /* drbd_submit_ee currently fails for one reason only: 157722cc37a9SLars Ellenberg * not being able to allocate enough bios. 157822cc37a9SLars Ellenberg * Is dropping the connection going to help? */ 157922cc37a9SLars Ellenberg spin_lock_irq(&mdev->req_lock); 158022cc37a9SLars Ellenberg list_del(&e->w.list); 158122cc37a9SLars Ellenberg spin_unlock_irq(&mdev->req_lock); 158222cc37a9SLars Ellenberg 158345bb912bSLars Ellenberg drbd_free_ee(mdev, e); 158445bb912bSLars Ellenberg fail: 158545bb912bSLars Ellenberg put_ldev(mdev); 158645bb912bSLars Ellenberg return FALSE; 1587b411b363SPhilipp Reisner } 1588b411b363SPhilipp Reisner 158902918be2SPhilipp Reisner static int receive_DataReply(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 1590b411b363SPhilipp Reisner { 1591b411b363SPhilipp Reisner struct drbd_request *req; 1592b411b363SPhilipp Reisner sector_t sector; 1593b411b363SPhilipp Reisner int ok; 159402918be2SPhilipp Reisner struct p_data *p = &mdev->data.rbuf.data; 1595b411b363SPhilipp Reisner 1596b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1597b411b363SPhilipp Reisner 1598b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1599b411b363SPhilipp Reisner req = _ar_id_to_req(mdev, p->block_id, sector); 1600b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1601b411b363SPhilipp Reisner if (unlikely(!req)) { 1602b411b363SPhilipp Reisner dev_err(DEV, "Got a corrupt block_id/sector pair(1).\n"); 1603b411b363SPhilipp Reisner return FALSE; 1604b411b363SPhilipp Reisner } 1605b411b363SPhilipp Reisner 1606b411b363SPhilipp Reisner /* hlist_del(&req->colision) is done in _req_may_be_done, to avoid 1607b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1608b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1609b411b363SPhilipp Reisner ok = recv_dless_read(mdev, req, sector, data_size); 1610b411b363SPhilipp Reisner 1611b411b363SPhilipp Reisner if (ok) 1612b411b363SPhilipp Reisner req_mod(req, data_received); 1613b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1614b411b363SPhilipp Reisner * I don't think we may complete this just yet 1615b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1616b411b363SPhilipp Reisner 1617b411b363SPhilipp Reisner return ok; 1618b411b363SPhilipp Reisner } 1619b411b363SPhilipp Reisner 162002918be2SPhilipp Reisner static int receive_RSDataReply(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 1621b411b363SPhilipp Reisner { 1622b411b363SPhilipp Reisner sector_t sector; 1623b411b363SPhilipp Reisner int ok; 162402918be2SPhilipp Reisner struct p_data *p = &mdev->data.rbuf.data; 1625b411b363SPhilipp Reisner 1626b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1627b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1628b411b363SPhilipp Reisner 1629b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1630b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1631b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1632b411b363SPhilipp Reisner * or in drbd_endio_write_sec. */ 1633b411b363SPhilipp Reisner ok = recv_resync_read(mdev, sector, data_size); 1634b411b363SPhilipp Reisner } else { 1635b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1636b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1637b411b363SPhilipp Reisner 1638b411b363SPhilipp Reisner ok = drbd_drain_block(mdev, data_size); 1639b411b363SPhilipp Reisner 16402b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1641b411b363SPhilipp Reisner } 1642b411b363SPhilipp Reisner 1643778f271dSPhilipp Reisner atomic_add(data_size >> 9, &mdev->rs_sect_in); 1644778f271dSPhilipp Reisner 1645b411b363SPhilipp Reisner return ok; 1646b411b363SPhilipp Reisner } 1647b411b363SPhilipp Reisner 1648b411b363SPhilipp Reisner /* e_end_block() is called via drbd_process_done_ee(). 1649b411b363SPhilipp Reisner * this means this function only runs in the asender thread 1650b411b363SPhilipp Reisner */ 1651b411b363SPhilipp Reisner static int e_end_block(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1652b411b363SPhilipp Reisner { 1653b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1654b411b363SPhilipp Reisner sector_t sector = e->sector; 1655b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1656b411b363SPhilipp Reisner int ok = 1, pcmd; 1657b411b363SPhilipp Reisner 1658b411b363SPhilipp Reisner if (e->flags & EE_IS_BARRIER) { 1659b411b363SPhilipp Reisner epoch = previous_epoch(mdev, e->epoch); 1660b411b363SPhilipp Reisner if (epoch) 1661b411b363SPhilipp Reisner drbd_may_finish_epoch(mdev, epoch, EV_BARRIER_DONE + (cancel ? EV_CLEANUP : 0)); 1662b411b363SPhilipp Reisner } 1663b411b363SPhilipp Reisner 1664b411b363SPhilipp Reisner if (mdev->net_conf->wire_protocol == DRBD_PROT_C) { 166545bb912bSLars Ellenberg if (likely((e->flags & EE_WAS_ERROR) == 0)) { 1666b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1667b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1668b411b363SPhilipp Reisner e->flags & EE_MAY_SET_IN_SYNC) ? 1669b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1670b411b363SPhilipp Reisner ok &= drbd_send_ack(mdev, pcmd, e); 1671b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1672b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, e->size); 1673b411b363SPhilipp Reisner } else { 1674b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_NEG_ACK, e); 1675b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1676b411b363SPhilipp Reisner * maybe assert this? */ 1677b411b363SPhilipp Reisner } 1678b411b363SPhilipp Reisner dec_unacked(mdev); 1679b411b363SPhilipp Reisner } 1680b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1681b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1682b411b363SPhilipp Reisner if (mdev->net_conf->two_primaries) { 1683b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1684b411b363SPhilipp Reisner D_ASSERT(!hlist_unhashed(&e->colision)); 1685b411b363SPhilipp Reisner hlist_del_init(&e->colision); 1686b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1687b411b363SPhilipp Reisner } else { 1688b411b363SPhilipp Reisner D_ASSERT(hlist_unhashed(&e->colision)); 1689b411b363SPhilipp Reisner } 1690b411b363SPhilipp Reisner 1691b411b363SPhilipp Reisner drbd_may_finish_epoch(mdev, e->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1692b411b363SPhilipp Reisner 1693b411b363SPhilipp Reisner return ok; 1694b411b363SPhilipp Reisner } 1695b411b363SPhilipp Reisner 1696b411b363SPhilipp Reisner static int e_send_discard_ack(struct drbd_conf *mdev, struct drbd_work *w, int unused) 1697b411b363SPhilipp Reisner { 1698b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1699b411b363SPhilipp Reisner int ok = 1; 1700b411b363SPhilipp Reisner 1701b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 1702b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_DISCARD_ACK, e); 1703b411b363SPhilipp Reisner 1704b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1705b411b363SPhilipp Reisner D_ASSERT(!hlist_unhashed(&e->colision)); 1706b411b363SPhilipp Reisner hlist_del_init(&e->colision); 1707b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1708b411b363SPhilipp Reisner 1709b411b363SPhilipp Reisner dec_unacked(mdev); 1710b411b363SPhilipp Reisner 1711b411b363SPhilipp Reisner return ok; 1712b411b363SPhilipp Reisner } 1713b411b363SPhilipp Reisner 1714b411b363SPhilipp Reisner /* Called from receive_Data. 1715b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1716b411b363SPhilipp Reisner * 1717b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1718b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1719b411b363SPhilipp Reisner * been sent. 1720b411b363SPhilipp Reisner * 1721b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1722b411b363SPhilipp Reisner * 1723b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1724b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1725b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1726b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1727b411b363SPhilipp Reisner * 1728b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1729b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1730b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1731b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1732b411b363SPhilipp Reisner * 1733b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1734b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 1735b411b363SPhilipp Reisner static int drbd_wait_peer_seq(struct drbd_conf *mdev, const u32 packet_seq) 1736b411b363SPhilipp Reisner { 1737b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1738b411b363SPhilipp Reisner unsigned int p_seq; 1739b411b363SPhilipp Reisner long timeout; 1740b411b363SPhilipp Reisner int ret = 0; 1741b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1742b411b363SPhilipp Reisner for (;;) { 1743b411b363SPhilipp Reisner prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1744b411b363SPhilipp Reisner if (seq_le(packet_seq, mdev->peer_seq+1)) 1745b411b363SPhilipp Reisner break; 1746b411b363SPhilipp Reisner if (signal_pending(current)) { 1747b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1748b411b363SPhilipp Reisner break; 1749b411b363SPhilipp Reisner } 1750b411b363SPhilipp Reisner p_seq = mdev->peer_seq; 1751b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1752b411b363SPhilipp Reisner timeout = schedule_timeout(30*HZ); 1753b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1754b411b363SPhilipp Reisner if (timeout == 0 && p_seq == mdev->peer_seq) { 1755b411b363SPhilipp Reisner ret = -ETIMEDOUT; 1756b411b363SPhilipp Reisner dev_err(DEV, "ASSERT FAILED waited 30 seconds for sequence update, forcing reconnect\n"); 1757b411b363SPhilipp Reisner break; 1758b411b363SPhilipp Reisner } 1759b411b363SPhilipp Reisner } 1760b411b363SPhilipp Reisner finish_wait(&mdev->seq_wait, &wait); 1761b411b363SPhilipp Reisner if (mdev->peer_seq+1 == packet_seq) 1762b411b363SPhilipp Reisner mdev->peer_seq++; 1763b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1764b411b363SPhilipp Reisner return ret; 1765b411b363SPhilipp Reisner } 1766b411b363SPhilipp Reisner 176776d2e7ecSPhilipp Reisner static unsigned long write_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 176876d2e7ecSPhilipp Reisner { 176976d2e7ecSPhilipp Reisner if (mdev->agreed_pro_version >= 95) 177076d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 177176d2e7ecSPhilipp Reisner (dpf & DP_UNPLUG ? REQ_UNPLUG : 0) | 177276d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 177376d2e7ecSPhilipp Reisner (dpf & DP_FLUSH ? REQ_FUA : 0) | 177476d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 177576d2e7ecSPhilipp Reisner else 177676d2e7ecSPhilipp Reisner return dpf & DP_RW_SYNC ? (REQ_SYNC | REQ_UNPLUG) : 0; 177776d2e7ecSPhilipp Reisner } 177876d2e7ecSPhilipp Reisner 1779b411b363SPhilipp Reisner /* mirrored write */ 178002918be2SPhilipp Reisner static int receive_Data(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 1781b411b363SPhilipp Reisner { 1782b411b363SPhilipp Reisner sector_t sector; 1783b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 178402918be2SPhilipp Reisner struct p_data *p = &mdev->data.rbuf.data; 1785b411b363SPhilipp Reisner int rw = WRITE; 1786b411b363SPhilipp Reisner u32 dp_flags; 1787b411b363SPhilipp Reisner 1788b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 1789b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1790b411b363SPhilipp Reisner dev_err(DEV, "Can not write mirrored data block " 1791b411b363SPhilipp Reisner "to local disk.\n"); 1792b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1793b411b363SPhilipp Reisner if (mdev->peer_seq+1 == be32_to_cpu(p->seq_num)) 1794b411b363SPhilipp Reisner mdev->peer_seq++; 1795b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1796b411b363SPhilipp Reisner 17972b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1798b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 1799b411b363SPhilipp Reisner return drbd_drain_block(mdev, data_size); 1800b411b363SPhilipp Reisner } 1801b411b363SPhilipp Reisner 1802b411b363SPhilipp Reisner /* get_ldev(mdev) successful. 1803b411b363SPhilipp Reisner * Corresponding put_ldev done either below (on various errors), 1804b411b363SPhilipp Reisner * or in drbd_endio_write_sec, if we successfully submit the data at 1805b411b363SPhilipp Reisner * the end of this function. */ 1806b411b363SPhilipp Reisner 1807b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1808b411b363SPhilipp Reisner e = read_in_block(mdev, p->block_id, sector, data_size); 1809b411b363SPhilipp Reisner if (!e) { 1810b411b363SPhilipp Reisner put_ldev(mdev); 1811b411b363SPhilipp Reisner return FALSE; 1812b411b363SPhilipp Reisner } 1813b411b363SPhilipp Reisner 1814b411b363SPhilipp Reisner e->w.cb = e_end_block; 1815b411b363SPhilipp Reisner 1816b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1817b411b363SPhilipp Reisner e->epoch = mdev->current_epoch; 1818b411b363SPhilipp Reisner atomic_inc(&e->epoch->epoch_size); 1819b411b363SPhilipp Reisner atomic_inc(&e->epoch->active); 1820b411b363SPhilipp Reisner 1821b411b363SPhilipp Reisner if (mdev->write_ordering == WO_bio_barrier && atomic_read(&e->epoch->epoch_size) == 1) { 1822b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1823b411b363SPhilipp Reisner /* Issue a barrier if we start a new epoch, and the previous epoch 1824b411b363SPhilipp Reisner was not a epoch containing a single request which already was 1825b411b363SPhilipp Reisner a Barrier. */ 1826b411b363SPhilipp Reisner epoch = list_entry(e->epoch->list.prev, struct drbd_epoch, list); 1827b411b363SPhilipp Reisner if (epoch == e->epoch) { 1828b411b363SPhilipp Reisner set_bit(DE_CONTAINS_A_BARRIER, &e->epoch->flags); 18297b6d91daSChristoph Hellwig rw |= REQ_HARDBARRIER; 1830b411b363SPhilipp Reisner e->flags |= EE_IS_BARRIER; 1831b411b363SPhilipp Reisner } else { 1832b411b363SPhilipp Reisner if (atomic_read(&epoch->epoch_size) > 1 || 1833b411b363SPhilipp Reisner !test_bit(DE_CONTAINS_A_BARRIER, &epoch->flags)) { 1834b411b363SPhilipp Reisner set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags); 1835b411b363SPhilipp Reisner set_bit(DE_CONTAINS_A_BARRIER, &e->epoch->flags); 18367b6d91daSChristoph Hellwig rw |= REQ_HARDBARRIER; 1837b411b363SPhilipp Reisner e->flags |= EE_IS_BARRIER; 1838b411b363SPhilipp Reisner } 1839b411b363SPhilipp Reisner } 1840b411b363SPhilipp Reisner } 1841b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1842b411b363SPhilipp Reisner 1843b411b363SPhilipp Reisner dp_flags = be32_to_cpu(p->dp_flags); 184476d2e7ecSPhilipp Reisner rw |= write_flags_to_bio(mdev, dp_flags); 184576d2e7ecSPhilipp Reisner 1846b411b363SPhilipp Reisner if (dp_flags & DP_MAY_SET_IN_SYNC) 1847b411b363SPhilipp Reisner e->flags |= EE_MAY_SET_IN_SYNC; 1848b411b363SPhilipp Reisner 1849b411b363SPhilipp Reisner /* I'm the receiver, I do hold a net_cnt reference. */ 1850b411b363SPhilipp Reisner if (!mdev->net_conf->two_primaries) { 1851b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1852b411b363SPhilipp Reisner } else { 1853b411b363SPhilipp Reisner /* don't get the req_lock yet, 1854b411b363SPhilipp Reisner * we may sleep in drbd_wait_peer_seq */ 1855b411b363SPhilipp Reisner const int size = e->size; 1856b411b363SPhilipp Reisner const int discard = test_bit(DISCARD_CONCURRENT, &mdev->flags); 1857b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1858b411b363SPhilipp Reisner struct drbd_request *i; 1859b411b363SPhilipp Reisner struct hlist_node *n; 1860b411b363SPhilipp Reisner struct hlist_head *slot; 1861b411b363SPhilipp Reisner int first; 1862b411b363SPhilipp Reisner 1863b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 1864b411b363SPhilipp Reisner BUG_ON(mdev->ee_hash == NULL); 1865b411b363SPhilipp Reisner BUG_ON(mdev->tl_hash == NULL); 1866b411b363SPhilipp Reisner 1867b411b363SPhilipp Reisner /* conflict detection and handling: 1868b411b363SPhilipp Reisner * 1. wait on the sequence number, 1869b411b363SPhilipp Reisner * in case this data packet overtook ACK packets. 1870b411b363SPhilipp Reisner * 2. check our hash tables for conflicting requests. 1871b411b363SPhilipp Reisner * we only need to walk the tl_hash, since an ee can not 1872b411b363SPhilipp Reisner * have a conflict with an other ee: on the submitting 1873b411b363SPhilipp Reisner * node, the corresponding req had already been conflicting, 1874b411b363SPhilipp Reisner * and a conflicting req is never sent. 1875b411b363SPhilipp Reisner * 1876b411b363SPhilipp Reisner * Note: for two_primaries, we are protocol C, 1877b411b363SPhilipp Reisner * so there cannot be any request that is DONE 1878b411b363SPhilipp Reisner * but still on the transfer log. 1879b411b363SPhilipp Reisner * 1880b411b363SPhilipp Reisner * unconditionally add to the ee_hash. 1881b411b363SPhilipp Reisner * 1882b411b363SPhilipp Reisner * if no conflicting request is found: 1883b411b363SPhilipp Reisner * submit. 1884b411b363SPhilipp Reisner * 1885b411b363SPhilipp Reisner * if any conflicting request is found 1886b411b363SPhilipp Reisner * that has not yet been acked, 1887b411b363SPhilipp Reisner * AND I have the "discard concurrent writes" flag: 1888b411b363SPhilipp Reisner * queue (via done_ee) the P_DISCARD_ACK; OUT. 1889b411b363SPhilipp Reisner * 1890b411b363SPhilipp Reisner * if any conflicting request is found: 1891b411b363SPhilipp Reisner * block the receiver, waiting on misc_wait 1892b411b363SPhilipp Reisner * until no more conflicting requests are there, 1893b411b363SPhilipp Reisner * or we get interrupted (disconnect). 1894b411b363SPhilipp Reisner * 1895b411b363SPhilipp Reisner * we do not just write after local io completion of those 1896b411b363SPhilipp Reisner * requests, but only after req is done completely, i.e. 1897b411b363SPhilipp Reisner * we wait for the P_DISCARD_ACK to arrive! 1898b411b363SPhilipp Reisner * 1899b411b363SPhilipp Reisner * then proceed normally, i.e. submit. 1900b411b363SPhilipp Reisner */ 1901b411b363SPhilipp Reisner if (drbd_wait_peer_seq(mdev, be32_to_cpu(p->seq_num))) 1902b411b363SPhilipp Reisner goto out_interrupted; 1903b411b363SPhilipp Reisner 1904b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1905b411b363SPhilipp Reisner 1906b411b363SPhilipp Reisner hlist_add_head(&e->colision, ee_hash_slot(mdev, sector)); 1907b411b363SPhilipp Reisner 1908b411b363SPhilipp Reisner #define OVERLAPS overlaps(i->sector, i->size, sector, size) 1909b411b363SPhilipp Reisner slot = tl_hash_slot(mdev, sector); 1910b411b363SPhilipp Reisner first = 1; 1911b411b363SPhilipp Reisner for (;;) { 1912b411b363SPhilipp Reisner int have_unacked = 0; 1913b411b363SPhilipp Reisner int have_conflict = 0; 1914b411b363SPhilipp Reisner prepare_to_wait(&mdev->misc_wait, &wait, 1915b411b363SPhilipp Reisner TASK_INTERRUPTIBLE); 1916b411b363SPhilipp Reisner hlist_for_each_entry(i, n, slot, colision) { 1917b411b363SPhilipp Reisner if (OVERLAPS) { 1918b411b363SPhilipp Reisner /* only ALERT on first iteration, 1919b411b363SPhilipp Reisner * we may be woken up early... */ 1920b411b363SPhilipp Reisner if (first) 1921b411b363SPhilipp Reisner dev_alert(DEV, "%s[%u] Concurrent local write detected!" 1922b411b363SPhilipp Reisner " new: %llus +%u; pending: %llus +%u\n", 1923b411b363SPhilipp Reisner current->comm, current->pid, 1924b411b363SPhilipp Reisner (unsigned long long)sector, size, 1925b411b363SPhilipp Reisner (unsigned long long)i->sector, i->size); 1926b411b363SPhilipp Reisner if (i->rq_state & RQ_NET_PENDING) 1927b411b363SPhilipp Reisner ++have_unacked; 1928b411b363SPhilipp Reisner ++have_conflict; 1929b411b363SPhilipp Reisner } 1930b411b363SPhilipp Reisner } 1931b411b363SPhilipp Reisner #undef OVERLAPS 1932b411b363SPhilipp Reisner if (!have_conflict) 1933b411b363SPhilipp Reisner break; 1934b411b363SPhilipp Reisner 1935b411b363SPhilipp Reisner /* Discard Ack only for the _first_ iteration */ 1936b411b363SPhilipp Reisner if (first && discard && have_unacked) { 1937b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [DISCARD BY FLAG] sec=%llus\n", 1938b411b363SPhilipp Reisner (unsigned long long)sector); 1939b411b363SPhilipp Reisner inc_unacked(mdev); 1940b411b363SPhilipp Reisner e->w.cb = e_send_discard_ack; 1941b411b363SPhilipp Reisner list_add_tail(&e->w.list, &mdev->done_ee); 1942b411b363SPhilipp Reisner 1943b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1944b411b363SPhilipp Reisner 1945b411b363SPhilipp Reisner /* we could probably send that P_DISCARD_ACK ourselves, 1946b411b363SPhilipp Reisner * but I don't like the receiver using the msock */ 1947b411b363SPhilipp Reisner 1948b411b363SPhilipp Reisner put_ldev(mdev); 1949b411b363SPhilipp Reisner wake_asender(mdev); 1950b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1951b411b363SPhilipp Reisner return TRUE; 1952b411b363SPhilipp Reisner } 1953b411b363SPhilipp Reisner 1954b411b363SPhilipp Reisner if (signal_pending(current)) { 1955b411b363SPhilipp Reisner hlist_del_init(&e->colision); 1956b411b363SPhilipp Reisner 1957b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1958b411b363SPhilipp Reisner 1959b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1960b411b363SPhilipp Reisner goto out_interrupted; 1961b411b363SPhilipp Reisner } 1962b411b363SPhilipp Reisner 1963b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1964b411b363SPhilipp Reisner if (first) { 1965b411b363SPhilipp Reisner first = 0; 1966b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [W AFTERWARDS] " 1967b411b363SPhilipp Reisner "sec=%llus\n", (unsigned long long)sector); 1968b411b363SPhilipp Reisner } else if (discard) { 1969b411b363SPhilipp Reisner /* we had none on the first iteration. 1970b411b363SPhilipp Reisner * there must be none now. */ 1971b411b363SPhilipp Reisner D_ASSERT(have_unacked == 0); 1972b411b363SPhilipp Reisner } 1973b411b363SPhilipp Reisner schedule(); 1974b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1975b411b363SPhilipp Reisner } 1976b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1977b411b363SPhilipp Reisner } 1978b411b363SPhilipp Reisner 1979b411b363SPhilipp Reisner list_add(&e->w.list, &mdev->active_ee); 1980b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1981b411b363SPhilipp Reisner 1982b411b363SPhilipp Reisner switch (mdev->net_conf->wire_protocol) { 1983b411b363SPhilipp Reisner case DRBD_PROT_C: 1984b411b363SPhilipp Reisner inc_unacked(mdev); 1985b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 1986b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1987b411b363SPhilipp Reisner break; 1988b411b363SPhilipp Reisner case DRBD_PROT_B: 1989b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 1990b411b363SPhilipp Reisner * sends on the msock, but anyways */ 1991b411b363SPhilipp Reisner drbd_send_ack(mdev, P_RECV_ACK, e); 1992b411b363SPhilipp Reisner break; 1993b411b363SPhilipp Reisner case DRBD_PROT_A: 1994b411b363SPhilipp Reisner /* nothing to do */ 1995b411b363SPhilipp Reisner break; 1996b411b363SPhilipp Reisner } 1997b411b363SPhilipp Reisner 1998b411b363SPhilipp Reisner if (mdev->state.pdsk == D_DISKLESS) { 1999b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2000b411b363SPhilipp Reisner drbd_set_out_of_sync(mdev, e->sector, e->size); 2001b411b363SPhilipp Reisner e->flags |= EE_CALL_AL_COMPLETE_IO; 2002b411b363SPhilipp Reisner drbd_al_begin_io(mdev, e->sector); 2003b411b363SPhilipp Reisner } 2004b411b363SPhilipp Reisner 200545bb912bSLars Ellenberg if (drbd_submit_ee(mdev, e, rw, DRBD_FAULT_DT_WR) == 0) 2006b411b363SPhilipp Reisner return TRUE; 2007b411b363SPhilipp Reisner 200822cc37a9SLars Ellenberg /* drbd_submit_ee currently fails for one reason only: 200922cc37a9SLars Ellenberg * not being able to allocate enough bios. 201022cc37a9SLars Ellenberg * Is dropping the connection going to help? */ 201122cc37a9SLars Ellenberg spin_lock_irq(&mdev->req_lock); 201222cc37a9SLars Ellenberg list_del(&e->w.list); 201322cc37a9SLars Ellenberg hlist_del_init(&e->colision); 201422cc37a9SLars Ellenberg spin_unlock_irq(&mdev->req_lock); 201522cc37a9SLars Ellenberg if (e->flags & EE_CALL_AL_COMPLETE_IO) 201622cc37a9SLars Ellenberg drbd_al_complete_io(mdev, e->sector); 201722cc37a9SLars Ellenberg 2018b411b363SPhilipp Reisner out_interrupted: 2019b411b363SPhilipp Reisner /* yes, the epoch_size now is imbalanced. 2020b411b363SPhilipp Reisner * but we drop the connection anyways, so we don't have a chance to 2021b411b363SPhilipp Reisner * receive a barrier... atomic_inc(&mdev->epoch_size); */ 2022b411b363SPhilipp Reisner put_ldev(mdev); 2023b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 2024b411b363SPhilipp Reisner return FALSE; 2025b411b363SPhilipp Reisner } 2026b411b363SPhilipp Reisner 20270f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 20280f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 20290f0601f4SLars Ellenberg * 20300f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 20310f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 20320f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 20330f0601f4SLars Ellenberg * activity, it obviously is "busy". 20340f0601f4SLars Ellenberg * 20350f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 20360f0601f4SLars Ellenberg * to have a short time average so we can react faster. 20370f0601f4SLars Ellenberg */ 20380f0601f4SLars Ellenberg int drbd_rs_should_slow_down(struct drbd_conf *mdev) 20390f0601f4SLars Ellenberg { 20400f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 20410f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 20420f0601f4SLars Ellenberg int curr_events; 20430f0601f4SLars Ellenberg int throttle = 0; 20440f0601f4SLars Ellenberg 20450f0601f4SLars Ellenberg /* feature disabled? */ 20460f0601f4SLars Ellenberg if (mdev->sync_conf.c_min_rate == 0) 20470f0601f4SLars Ellenberg return 0; 20480f0601f4SLars Ellenberg 20490f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 20500f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 20510f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 20520f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 20530f0601f4SLars Ellenberg unsigned long rs_left; 20540f0601f4SLars Ellenberg int i; 20550f0601f4SLars Ellenberg 20560f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 20570f0601f4SLars Ellenberg 20580f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 20590f0601f4SLars Ellenberg * approx. */ 20600f0601f4SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-2) % DRBD_SYNC_MARKS; 20610f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 20620f0601f4SLars Ellenberg 20630f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 20640f0601f4SLars Ellenberg if (!dt) 20650f0601f4SLars Ellenberg dt++; 20660f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 20670f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 20680f0601f4SLars Ellenberg 20690f0601f4SLars Ellenberg if (dbdt > mdev->sync_conf.c_min_rate) 20700f0601f4SLars Ellenberg throttle = 1; 20710f0601f4SLars Ellenberg } 20720f0601f4SLars Ellenberg return throttle; 20730f0601f4SLars Ellenberg } 20740f0601f4SLars Ellenberg 20750f0601f4SLars Ellenberg 207602918be2SPhilipp Reisner static int receive_DataRequest(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int digest_size) 2077b411b363SPhilipp Reisner { 2078b411b363SPhilipp Reisner sector_t sector; 2079b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 2080b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 2081b411b363SPhilipp Reisner struct digest_info *di = NULL; 2082b18b37beSPhilipp Reisner int size, verb; 2083b411b363SPhilipp Reisner unsigned int fault_type; 208402918be2SPhilipp Reisner struct p_block_req *p = &mdev->data.rbuf.block_req; 2085b411b363SPhilipp Reisner 2086b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2087b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2088b411b363SPhilipp Reisner 2089b411b363SPhilipp Reisner if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_SEGMENT_SIZE) { 2090b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2091b411b363SPhilipp Reisner (unsigned long long)sector, size); 2092b411b363SPhilipp Reisner return FALSE; 2093b411b363SPhilipp Reisner } 2094b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2095b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2096b411b363SPhilipp Reisner (unsigned long long)sector, size); 2097b411b363SPhilipp Reisner return FALSE; 2098b411b363SPhilipp Reisner } 2099b411b363SPhilipp Reisner 2100b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2101b18b37beSPhilipp Reisner verb = 1; 2102b18b37beSPhilipp Reisner switch (cmd) { 2103b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2104b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2105b18b37beSPhilipp Reisner break; 2106b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2107b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2108b18b37beSPhilipp Reisner case P_OV_REQUEST: 2109b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2110b18b37beSPhilipp Reisner break; 2111b18b37beSPhilipp Reisner case P_OV_REPLY: 2112b18b37beSPhilipp Reisner verb = 0; 2113b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2114b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2115b18b37beSPhilipp Reisner break; 2116b18b37beSPhilipp Reisner default: 2117b18b37beSPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 2118b18b37beSPhilipp Reisner cmdname(cmd)); 2119b18b37beSPhilipp Reisner } 2120b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2121b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2122b411b363SPhilipp Reisner "no local data.\n"); 2123b18b37beSPhilipp Reisner 2124a821cc4aSLars Ellenberg /* drain possibly payload */ 2125a821cc4aSLars Ellenberg return drbd_drain_block(mdev, digest_size); 2126b411b363SPhilipp Reisner } 2127b411b363SPhilipp Reisner 2128b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2129b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2130b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2131b411b363SPhilipp Reisner e = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO); 2132b411b363SPhilipp Reisner if (!e) { 2133b411b363SPhilipp Reisner put_ldev(mdev); 2134b411b363SPhilipp Reisner return FALSE; 2135b411b363SPhilipp Reisner } 2136b411b363SPhilipp Reisner 213702918be2SPhilipp Reisner switch (cmd) { 2138b411b363SPhilipp Reisner case P_DATA_REQUEST: 2139b411b363SPhilipp Reisner e->w.cb = w_e_end_data_req; 2140b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 214180a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 214280a40e43SLars Ellenberg goto submit; 214380a40e43SLars Ellenberg 2144b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2145b411b363SPhilipp Reisner e->w.cb = w_e_end_rsdata_req; 2146b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2147b411b363SPhilipp Reisner break; 2148b411b363SPhilipp Reisner 2149b411b363SPhilipp Reisner case P_OV_REPLY: 2150b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2151b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2152b411b363SPhilipp Reisner di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO); 2153b411b363SPhilipp Reisner if (!di) 2154b411b363SPhilipp Reisner goto out_free_e; 2155b411b363SPhilipp Reisner 2156b411b363SPhilipp Reisner di->digest_size = digest_size; 2157b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2158b411b363SPhilipp Reisner 2159c36c3cedSLars Ellenberg e->digest = di; 2160c36c3cedSLars Ellenberg e->flags |= EE_HAS_DIGEST; 2161c36c3cedSLars Ellenberg 2162b411b363SPhilipp Reisner if (drbd_recv(mdev, di->digest, digest_size) != digest_size) 2163b411b363SPhilipp Reisner goto out_free_e; 2164b411b363SPhilipp Reisner 216502918be2SPhilipp Reisner if (cmd == P_CSUM_RS_REQUEST) { 2166b411b363SPhilipp Reisner D_ASSERT(mdev->agreed_pro_version >= 89); 2167b411b363SPhilipp Reisner e->w.cb = w_e_end_csum_rs_req; 216802918be2SPhilipp Reisner } else if (cmd == P_OV_REPLY) { 2169b411b363SPhilipp Reisner e->w.cb = w_e_end_ov_reply; 2170b411b363SPhilipp Reisner dec_rs_pending(mdev); 21710f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 21720f0601f4SLars Ellenberg * but accounting still needs to be done. */ 21730f0601f4SLars Ellenberg goto submit_for_resync; 2174b411b363SPhilipp Reisner } 2175b411b363SPhilipp Reisner break; 2176b411b363SPhilipp Reisner 2177b411b363SPhilipp Reisner case P_OV_REQUEST: 2178b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 2179b411b363SPhilipp Reisner mdev->agreed_pro_version >= 90) { 2180b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2181b411b363SPhilipp Reisner mdev->ov_position = sector; 2182b411b363SPhilipp Reisner mdev->ov_left = mdev->rs_total - BM_SECT_TO_BIT(sector); 2183b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2184b411b363SPhilipp Reisner (unsigned long long)sector); 2185b411b363SPhilipp Reisner } 2186b411b363SPhilipp Reisner e->w.cb = w_e_end_ov_req; 2187b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2188b411b363SPhilipp Reisner break; 2189b411b363SPhilipp Reisner 2190b411b363SPhilipp Reisner default: 2191b411b363SPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 219202918be2SPhilipp Reisner cmdname(cmd)); 2193b411b363SPhilipp Reisner fault_type = DRBD_FAULT_MAX; 219480a40e43SLars Ellenberg goto out_free_e; 2195b411b363SPhilipp Reisner } 2196b411b363SPhilipp Reisner 21970f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 21980f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 21990f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 22000f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 22010f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 22020f0601f4SLars Ellenberg * 22030f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 22040f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 22050f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 22060f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 22070f0601f4SLars Ellenberg * a while, anyways. 22080f0601f4SLars Ellenberg */ 22090f0601f4SLars Ellenberg 22100f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 22110f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 22120f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 22130f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 22140f0601f4SLars Ellenberg * 22150f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 22160f0601f4SLars Ellenberg * we would also throttle its application reads. 22170f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 22180f0601f4SLars Ellenberg */ 22190f0601f4SLars Ellenberg if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev)) 22200f0601f4SLars Ellenberg msleep(100); 222180a40e43SLars Ellenberg if (drbd_rs_begin_io(mdev, e->sector)) 222280a40e43SLars Ellenberg goto out_free_e; 2223b411b363SPhilipp Reisner 22240f0601f4SLars Ellenberg submit_for_resync: 22250f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 22260f0601f4SLars Ellenberg 222780a40e43SLars Ellenberg submit: 2228b411b363SPhilipp Reisner inc_unacked(mdev); 222980a40e43SLars Ellenberg spin_lock_irq(&mdev->req_lock); 223080a40e43SLars Ellenberg list_add_tail(&e->w.list, &mdev->read_ee); 223180a40e43SLars Ellenberg spin_unlock_irq(&mdev->req_lock); 2232b411b363SPhilipp Reisner 223345bb912bSLars Ellenberg if (drbd_submit_ee(mdev, e, READ, fault_type) == 0) 2234b411b363SPhilipp Reisner return TRUE; 2235b411b363SPhilipp Reisner 223622cc37a9SLars Ellenberg /* drbd_submit_ee currently fails for one reason only: 223722cc37a9SLars Ellenberg * not being able to allocate enough bios. 223822cc37a9SLars Ellenberg * Is dropping the connection going to help? */ 223922cc37a9SLars Ellenberg spin_lock_irq(&mdev->req_lock); 224022cc37a9SLars Ellenberg list_del(&e->w.list); 224122cc37a9SLars Ellenberg spin_unlock_irq(&mdev->req_lock); 224222cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 224322cc37a9SLars Ellenberg 2244b411b363SPhilipp Reisner out_free_e: 2245b411b363SPhilipp Reisner put_ldev(mdev); 2246b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 2247b411b363SPhilipp Reisner return FALSE; 2248b411b363SPhilipp Reisner } 2249b411b363SPhilipp Reisner 2250b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2251b411b363SPhilipp Reisner { 2252b411b363SPhilipp Reisner int self, peer, rv = -100; 2253b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2254b411b363SPhilipp Reisner 2255b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2256b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2257b411b363SPhilipp Reisner 2258b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2259b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2260b411b363SPhilipp Reisner 2261b411b363SPhilipp Reisner switch (mdev->net_conf->after_sb_0p) { 2262b411b363SPhilipp Reisner case ASB_CONSENSUS: 2263b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2264b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2265b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2266b411b363SPhilipp Reisner break; 2267b411b363SPhilipp Reisner case ASB_DISCONNECT: 2268b411b363SPhilipp Reisner break; 2269b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2270b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2271b411b363SPhilipp Reisner rv = -1; 2272b411b363SPhilipp Reisner break; 2273b411b363SPhilipp Reisner } 2274b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2275b411b363SPhilipp Reisner rv = 1; 2276b411b363SPhilipp Reisner break; 2277b411b363SPhilipp Reisner } 2278b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2279b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2280b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2281b411b363SPhilipp Reisner rv = 1; 2282b411b363SPhilipp Reisner break; 2283b411b363SPhilipp Reisner } 2284b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2285b411b363SPhilipp Reisner rv = -1; 2286b411b363SPhilipp Reisner break; 2287b411b363SPhilipp Reisner } 2288b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2289ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2290b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2291b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2292b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 2293b411b363SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->flags) 2294b411b363SPhilipp Reisner ? -1 : 1; 2295b411b363SPhilipp Reisner break; 2296b411b363SPhilipp Reisner } else { 2297b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2298b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2299b411b363SPhilipp Reisner } 2300b411b363SPhilipp Reisner if (mdev->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2301b411b363SPhilipp Reisner break; 2302b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2303b411b363SPhilipp Reisner if (ch_self < ch_peer) 2304b411b363SPhilipp Reisner rv = -1; 2305b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2306b411b363SPhilipp Reisner rv = 1; 2307b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2308b411b363SPhilipp Reisner /* Well, then use something else. */ 2309b411b363SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->flags) 2310b411b363SPhilipp Reisner ? -1 : 1; 2311b411b363SPhilipp Reisner break; 2312b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2313b411b363SPhilipp Reisner rv = -1; 2314b411b363SPhilipp Reisner break; 2315b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2316b411b363SPhilipp Reisner rv = 1; 2317b411b363SPhilipp Reisner } 2318b411b363SPhilipp Reisner 2319b411b363SPhilipp Reisner return rv; 2320b411b363SPhilipp Reisner } 2321b411b363SPhilipp Reisner 2322b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2323b411b363SPhilipp Reisner { 2324b411b363SPhilipp Reisner int self, peer, hg, rv = -100; 2325b411b363SPhilipp Reisner 2326b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2327b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2328b411b363SPhilipp Reisner 2329b411b363SPhilipp Reisner switch (mdev->net_conf->after_sb_1p) { 2330b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2331b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2332b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2333b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2334b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2335b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2336b411b363SPhilipp Reisner break; 2337b411b363SPhilipp Reisner case ASB_DISCONNECT: 2338b411b363SPhilipp Reisner break; 2339b411b363SPhilipp Reisner case ASB_CONSENSUS: 2340b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2341b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2342b411b363SPhilipp Reisner rv = hg; 2343b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2344b411b363SPhilipp Reisner rv = hg; 2345b411b363SPhilipp Reisner break; 2346b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2347b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2348b411b363SPhilipp Reisner break; 2349b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2350b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2351b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2352b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2353b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2354b411b363SPhilipp Reisner self = drbd_set_role(mdev, R_SECONDARY, 0); 2355b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2356b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2357b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2358b411b363SPhilipp Reisner self = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2359b411b363SPhilipp Reisner if (self != SS_SUCCESS) { 2360b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2361b411b363SPhilipp Reisner } else { 2362b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2363b411b363SPhilipp Reisner rv = hg; 2364b411b363SPhilipp Reisner } 2365b411b363SPhilipp Reisner } else 2366b411b363SPhilipp Reisner rv = hg; 2367b411b363SPhilipp Reisner } 2368b411b363SPhilipp Reisner 2369b411b363SPhilipp Reisner return rv; 2370b411b363SPhilipp Reisner } 2371b411b363SPhilipp Reisner 2372b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2373b411b363SPhilipp Reisner { 2374b411b363SPhilipp Reisner int self, peer, hg, rv = -100; 2375b411b363SPhilipp Reisner 2376b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2377b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2378b411b363SPhilipp Reisner 2379b411b363SPhilipp Reisner switch (mdev->net_conf->after_sb_2p) { 2380b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2381b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2382b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2383b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2384b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2385b411b363SPhilipp Reisner case ASB_CONSENSUS: 2386b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2387b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2388b411b363SPhilipp Reisner break; 2389b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2390b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2391b411b363SPhilipp Reisner break; 2392b411b363SPhilipp Reisner case ASB_DISCONNECT: 2393b411b363SPhilipp Reisner break; 2394b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2395b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2396b411b363SPhilipp Reisner if (hg == -1) { 2397b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2398b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2399b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2400b411b363SPhilipp Reisner self = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2401b411b363SPhilipp Reisner if (self != SS_SUCCESS) { 2402b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2403b411b363SPhilipp Reisner } else { 2404b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2405b411b363SPhilipp Reisner rv = hg; 2406b411b363SPhilipp Reisner } 2407b411b363SPhilipp Reisner } else 2408b411b363SPhilipp Reisner rv = hg; 2409b411b363SPhilipp Reisner } 2410b411b363SPhilipp Reisner 2411b411b363SPhilipp Reisner return rv; 2412b411b363SPhilipp Reisner } 2413b411b363SPhilipp Reisner 2414b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2415b411b363SPhilipp Reisner u64 bits, u64 flags) 2416b411b363SPhilipp Reisner { 2417b411b363SPhilipp Reisner if (!uuid) { 2418b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2419b411b363SPhilipp Reisner return; 2420b411b363SPhilipp Reisner } 2421b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2422b411b363SPhilipp Reisner text, 2423b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2424b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2425b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2426b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2427b411b363SPhilipp Reisner (unsigned long long)bits, 2428b411b363SPhilipp Reisner (unsigned long long)flags); 2429b411b363SPhilipp Reisner } 2430b411b363SPhilipp Reisner 2431b411b363SPhilipp Reisner /* 2432b411b363SPhilipp Reisner 100 after split brain try auto recover 2433b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2434b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2435b411b363SPhilipp Reisner 0 no Sync 2436b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2437b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2438b411b363SPhilipp Reisner -100 after split brain, disconnect 2439b411b363SPhilipp Reisner -1000 unrelated data 2440b411b363SPhilipp Reisner */ 2441b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2442b411b363SPhilipp Reisner { 2443b411b363SPhilipp Reisner u64 self, peer; 2444b411b363SPhilipp Reisner int i, j; 2445b411b363SPhilipp Reisner 2446b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2447b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2448b411b363SPhilipp Reisner 2449b411b363SPhilipp Reisner *rule_nr = 10; 2450b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2451b411b363SPhilipp Reisner return 0; 2452b411b363SPhilipp Reisner 2453b411b363SPhilipp Reisner *rule_nr = 20; 2454b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2455b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2456b411b363SPhilipp Reisner return -2; 2457b411b363SPhilipp Reisner 2458b411b363SPhilipp Reisner *rule_nr = 30; 2459b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2460b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2461b411b363SPhilipp Reisner return 2; 2462b411b363SPhilipp Reisner 2463b411b363SPhilipp Reisner if (self == peer) { 2464b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2465b411b363SPhilipp Reisner 2466b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2467b411b363SPhilipp Reisner 2468b411b363SPhilipp Reisner if (mdev->agreed_pro_version < 91) 2469b411b363SPhilipp Reisner return -1001; 2470b411b363SPhilipp Reisner 2471b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2472b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2473b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2474b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2475b411b363SPhilipp Reisner 2476b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2477b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2478b411b363SPhilipp Reisner *rule_nr = 34; 2479b411b363SPhilipp Reisner } else { 2480b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2481b411b363SPhilipp Reisner *rule_nr = 36; 2482b411b363SPhilipp Reisner } 2483b411b363SPhilipp Reisner 2484b411b363SPhilipp Reisner return 1; 2485b411b363SPhilipp Reisner } 2486b411b363SPhilipp Reisner 2487b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2488b411b363SPhilipp Reisner 2489b411b363SPhilipp Reisner if (mdev->agreed_pro_version < 91) 2490b411b363SPhilipp Reisner return -1001; 2491b411b363SPhilipp Reisner 2492b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2493b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2494b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2495b411b363SPhilipp Reisner 2496b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2497b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2498b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2499b411b363SPhilipp Reisner 2500b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2501b411b363SPhilipp Reisner *rule_nr = 35; 2502b411b363SPhilipp Reisner } else { 2503b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2504b411b363SPhilipp Reisner *rule_nr = 37; 2505b411b363SPhilipp Reisner } 2506b411b363SPhilipp Reisner 2507b411b363SPhilipp Reisner return -1; 2508b411b363SPhilipp Reisner } 2509b411b363SPhilipp Reisner 2510b411b363SPhilipp Reisner /* Common power [off|failure] */ 2511b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2512b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2513b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2514b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2515b411b363SPhilipp Reisner *rule_nr = 40; 2516b411b363SPhilipp Reisner 2517b411b363SPhilipp Reisner switch (rct) { 2518b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2519b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2520b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2521b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 2522b411b363SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->flags); 2523b411b363SPhilipp Reisner return dc ? -1 : 1; 2524b411b363SPhilipp Reisner } 2525b411b363SPhilipp Reisner } 2526b411b363SPhilipp Reisner 2527b411b363SPhilipp Reisner *rule_nr = 50; 2528b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2529b411b363SPhilipp Reisner if (self == peer) 2530b411b363SPhilipp Reisner return -1; 2531b411b363SPhilipp Reisner 2532b411b363SPhilipp Reisner *rule_nr = 51; 2533b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2534b411b363SPhilipp Reisner if (self == peer) { 2535b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2536b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1); 2537b411b363SPhilipp Reisner if (self == peer) { 2538b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2539b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2540b411b363SPhilipp Reisner 2541b411b363SPhilipp Reisner if (mdev->agreed_pro_version < 91) 2542b411b363SPhilipp Reisner return -1001; 2543b411b363SPhilipp Reisner 2544b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2545b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 2546b411b363SPhilipp Reisner return -1; 2547b411b363SPhilipp Reisner } 2548b411b363SPhilipp Reisner } 2549b411b363SPhilipp Reisner 2550b411b363SPhilipp Reisner *rule_nr = 60; 2551b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2552b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2553b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2554b411b363SPhilipp Reisner if (self == peer) 2555b411b363SPhilipp Reisner return -2; 2556b411b363SPhilipp Reisner } 2557b411b363SPhilipp Reisner 2558b411b363SPhilipp Reisner *rule_nr = 70; 2559b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2560b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2561b411b363SPhilipp Reisner if (self == peer) 2562b411b363SPhilipp Reisner return 1; 2563b411b363SPhilipp Reisner 2564b411b363SPhilipp Reisner *rule_nr = 71; 2565b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2566b411b363SPhilipp Reisner if (self == peer) { 2567b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1); 2568b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2569b411b363SPhilipp Reisner if (self == peer) { 2570b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2571b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2572b411b363SPhilipp Reisner 2573b411b363SPhilipp Reisner if (mdev->agreed_pro_version < 91) 2574b411b363SPhilipp Reisner return -1001; 2575b411b363SPhilipp Reisner 2576b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2577b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2578b411b363SPhilipp Reisner 2579b411b363SPhilipp Reisner dev_info(DEV, "Undid last start of resync:\n"); 2580b411b363SPhilipp Reisner 2581b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2582b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2583b411b363SPhilipp Reisner 2584b411b363SPhilipp Reisner return 1; 2585b411b363SPhilipp Reisner } 2586b411b363SPhilipp Reisner } 2587b411b363SPhilipp Reisner 2588b411b363SPhilipp Reisner 2589b411b363SPhilipp Reisner *rule_nr = 80; 2590d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2591b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2592b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2593b411b363SPhilipp Reisner if (self == peer) 2594b411b363SPhilipp Reisner return 2; 2595b411b363SPhilipp Reisner } 2596b411b363SPhilipp Reisner 2597b411b363SPhilipp Reisner *rule_nr = 90; 2598b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2599b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2600b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2601b411b363SPhilipp Reisner return 100; 2602b411b363SPhilipp Reisner 2603b411b363SPhilipp Reisner *rule_nr = 100; 2604b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2605b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2606b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2607b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2608b411b363SPhilipp Reisner if (self == peer) 2609b411b363SPhilipp Reisner return -100; 2610b411b363SPhilipp Reisner } 2611b411b363SPhilipp Reisner } 2612b411b363SPhilipp Reisner 2613b411b363SPhilipp Reisner return -1000; 2614b411b363SPhilipp Reisner } 2615b411b363SPhilipp Reisner 2616b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2617b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2618b411b363SPhilipp Reisner */ 2619b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2620b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2621b411b363SPhilipp Reisner { 2622b411b363SPhilipp Reisner int hg, rule_nr; 2623b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2624b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2625b411b363SPhilipp Reisner 2626b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2627b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2628b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2629b411b363SPhilipp Reisner 2630b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2631b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2632b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2633b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2634b411b363SPhilipp Reisner 2635b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2636b411b363SPhilipp Reisner 2637b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2638b411b363SPhilipp Reisner 2639b411b363SPhilipp Reisner if (hg == -1000) { 2640b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2641b411b363SPhilipp Reisner return C_MASK; 2642b411b363SPhilipp Reisner } 2643b411b363SPhilipp Reisner if (hg == -1001) { 2644b411b363SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol\n"); 2645b411b363SPhilipp Reisner return C_MASK; 2646b411b363SPhilipp Reisner } 2647b411b363SPhilipp Reisner 2648b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2649b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2650b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2651b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2652b411b363SPhilipp Reisner if (f) 2653b411b363SPhilipp Reisner hg = hg*2; 2654b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2655b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2656b411b363SPhilipp Reisner } 2657b411b363SPhilipp Reisner 26583a11a487SAdam Gandelman if (abs(hg) == 100) 26593a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 26603a11a487SAdam Gandelman 2661b411b363SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->net_conf->always_asbp)) { 2662b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2663b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2664b411b363SPhilipp Reisner int forced = (hg == -100); 2665b411b363SPhilipp Reisner 2666b411b363SPhilipp Reisner switch (pcount) { 2667b411b363SPhilipp Reisner case 0: 2668b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2669b411b363SPhilipp Reisner break; 2670b411b363SPhilipp Reisner case 1: 2671b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2672b411b363SPhilipp Reisner break; 2673b411b363SPhilipp Reisner case 2: 2674b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2675b411b363SPhilipp Reisner break; 2676b411b363SPhilipp Reisner } 2677b411b363SPhilipp Reisner if (abs(hg) < 100) { 2678b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2679b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2680b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2681b411b363SPhilipp Reisner if (forced) { 2682b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2683b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2684b411b363SPhilipp Reisner hg = hg*2; 2685b411b363SPhilipp Reisner } 2686b411b363SPhilipp Reisner } 2687b411b363SPhilipp Reisner } 2688b411b363SPhilipp Reisner 2689b411b363SPhilipp Reisner if (hg == -100) { 2690b411b363SPhilipp Reisner if (mdev->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2691b411b363SPhilipp Reisner hg = -1; 2692b411b363SPhilipp Reisner if (!mdev->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2693b411b363SPhilipp Reisner hg = 1; 2694b411b363SPhilipp Reisner 2695b411b363SPhilipp Reisner if (abs(hg) < 100) 2696b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2697b411b363SPhilipp Reisner "Sync from %s node\n", 2698b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2699b411b363SPhilipp Reisner } 2700b411b363SPhilipp Reisner 2701b411b363SPhilipp Reisner if (hg == -100) { 2702580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2703580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2704580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2705580b9767SLars Ellenberg * to that disk, in a way... */ 27063a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2707b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2708b411b363SPhilipp Reisner return C_MASK; 2709b411b363SPhilipp Reisner } 2710b411b363SPhilipp Reisner 2711b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2712b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2713b411b363SPhilipp Reisner return C_MASK; 2714b411b363SPhilipp Reisner } 2715b411b363SPhilipp Reisner 2716b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2717b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 2718b411b363SPhilipp Reisner switch (mdev->net_conf->rr_conflict) { 2719b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2720b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2721b411b363SPhilipp Reisner /* fall through */ 2722b411b363SPhilipp Reisner case ASB_DISCONNECT: 2723b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2724b411b363SPhilipp Reisner return C_MASK; 2725b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2726b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2727b411b363SPhilipp Reisner "assumption\n"); 2728b411b363SPhilipp Reisner } 2729b411b363SPhilipp Reisner } 2730b411b363SPhilipp Reisner 2731cf14c2e9SPhilipp Reisner if (mdev->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->flags)) { 2732cf14c2e9SPhilipp Reisner if (hg == 0) 2733cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2734cf14c2e9SPhilipp Reisner else 2735cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2736cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2737cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2738cf14c2e9SPhilipp Reisner return C_MASK; 2739cf14c2e9SPhilipp Reisner } 2740cf14c2e9SPhilipp Reisner 2741b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2742b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 2743b411b363SPhilipp Reisner if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake")) 2744b411b363SPhilipp Reisner return C_MASK; 2745b411b363SPhilipp Reisner } 2746b411b363SPhilipp Reisner 2747b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2748b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2749b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2750b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2751b411b363SPhilipp Reisner } else { 2752b411b363SPhilipp Reisner rv = C_CONNECTED; 2753b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2754b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2755b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2756b411b363SPhilipp Reisner } 2757b411b363SPhilipp Reisner } 2758b411b363SPhilipp Reisner 2759b411b363SPhilipp Reisner return rv; 2760b411b363SPhilipp Reisner } 2761b411b363SPhilipp Reisner 2762b411b363SPhilipp Reisner /* returns 1 if invalid */ 2763b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2764b411b363SPhilipp Reisner { 2765b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2766b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2767b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2768b411b363SPhilipp Reisner return 0; 2769b411b363SPhilipp Reisner 2770b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2771b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2772b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2773b411b363SPhilipp Reisner return 1; 2774b411b363SPhilipp Reisner 2775b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2776b411b363SPhilipp Reisner if (peer == self) 2777b411b363SPhilipp Reisner return 0; 2778b411b363SPhilipp Reisner 2779b411b363SPhilipp Reisner /* everything es is invalid. */ 2780b411b363SPhilipp Reisner return 1; 2781b411b363SPhilipp Reisner } 2782b411b363SPhilipp Reisner 278302918be2SPhilipp Reisner static int receive_protocol(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 2784b411b363SPhilipp Reisner { 278502918be2SPhilipp Reisner struct p_protocol *p = &mdev->data.rbuf.protocol; 2786b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2787cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2788b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2789b411b363SPhilipp Reisner 2790b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2791b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2792b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2793b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2794b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2795cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2796cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2797cf14c2e9SPhilipp Reisner 2798cf14c2e9SPhilipp Reisner clear_bit(CONN_DRY_RUN, &mdev->flags); 2799cf14c2e9SPhilipp Reisner 2800cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 2801cf14c2e9SPhilipp Reisner set_bit(CONN_DRY_RUN, &mdev->flags); 2802b411b363SPhilipp Reisner 2803b411b363SPhilipp Reisner if (p_proto != mdev->net_conf->wire_protocol) { 2804b411b363SPhilipp Reisner dev_err(DEV, "incompatible communication protocols\n"); 2805b411b363SPhilipp Reisner goto disconnect; 2806b411b363SPhilipp Reisner } 2807b411b363SPhilipp Reisner 2808b411b363SPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, mdev->net_conf->after_sb_0p)) { 2809b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-0pri settings\n"); 2810b411b363SPhilipp Reisner goto disconnect; 2811b411b363SPhilipp Reisner } 2812b411b363SPhilipp Reisner 2813b411b363SPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, mdev->net_conf->after_sb_1p)) { 2814b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-1pri settings\n"); 2815b411b363SPhilipp Reisner goto disconnect; 2816b411b363SPhilipp Reisner } 2817b411b363SPhilipp Reisner 2818b411b363SPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, mdev->net_conf->after_sb_2p)) { 2819b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-2pri settings\n"); 2820b411b363SPhilipp Reisner goto disconnect; 2821b411b363SPhilipp Reisner } 2822b411b363SPhilipp Reisner 2823b411b363SPhilipp Reisner if (p_want_lose && mdev->net_conf->want_lose) { 2824b411b363SPhilipp Reisner dev_err(DEV, "both sides have the 'want_lose' flag set\n"); 2825b411b363SPhilipp Reisner goto disconnect; 2826b411b363SPhilipp Reisner } 2827b411b363SPhilipp Reisner 2828b411b363SPhilipp Reisner if (p_two_primaries != mdev->net_conf->two_primaries) { 2829b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the two-primaries options\n"); 2830b411b363SPhilipp Reisner goto disconnect; 2831b411b363SPhilipp Reisner } 2832b411b363SPhilipp Reisner 2833b411b363SPhilipp Reisner if (mdev->agreed_pro_version >= 87) { 2834b411b363SPhilipp Reisner unsigned char *my_alg = mdev->net_conf->integrity_alg; 2835b411b363SPhilipp Reisner 2836b411b363SPhilipp Reisner if (drbd_recv(mdev, p_integrity_alg, data_size) != data_size) 2837b411b363SPhilipp Reisner return FALSE; 2838b411b363SPhilipp Reisner 2839b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2840b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 2841b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the data-integrity-alg\n"); 2842b411b363SPhilipp Reisner goto disconnect; 2843b411b363SPhilipp Reisner } 2844b411b363SPhilipp Reisner dev_info(DEV, "data-integrity-alg: %s\n", 2845b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2846b411b363SPhilipp Reisner } 2847b411b363SPhilipp Reisner 2848b411b363SPhilipp Reisner return TRUE; 2849b411b363SPhilipp Reisner 2850b411b363SPhilipp Reisner disconnect: 2851b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 2852b411b363SPhilipp Reisner return FALSE; 2853b411b363SPhilipp Reisner } 2854b411b363SPhilipp Reisner 2855b411b363SPhilipp Reisner /* helper function 2856b411b363SPhilipp Reisner * input: alg name, feature name 2857b411b363SPhilipp Reisner * return: NULL (alg name was "") 2858b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2859b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2860b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2861b411b363SPhilipp Reisner const char *alg, const char *name) 2862b411b363SPhilipp Reisner { 2863b411b363SPhilipp Reisner struct crypto_hash *tfm; 2864b411b363SPhilipp Reisner 2865b411b363SPhilipp Reisner if (!alg[0]) 2866b411b363SPhilipp Reisner return NULL; 2867b411b363SPhilipp Reisner 2868b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2869b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 2870b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 2871b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 2872b411b363SPhilipp Reisner return tfm; 2873b411b363SPhilipp Reisner } 2874b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 2875b411b363SPhilipp Reisner crypto_free_hash(tfm); 2876b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 2877b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 2878b411b363SPhilipp Reisner } 2879b411b363SPhilipp Reisner return tfm; 2880b411b363SPhilipp Reisner } 2881b411b363SPhilipp Reisner 288202918be2SPhilipp Reisner static int receive_SyncParam(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int packet_size) 2883b411b363SPhilipp Reisner { 2884b411b363SPhilipp Reisner int ok = TRUE; 288502918be2SPhilipp Reisner struct p_rs_param_95 *p = &mdev->data.rbuf.rs_param_95; 2886b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 2887b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 2888b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 2889b411b363SPhilipp Reisner const int apv = mdev->agreed_pro_version; 2890778f271dSPhilipp Reisner int *rs_plan_s = NULL; 2891778f271dSPhilipp Reisner int fifo_size = 0; 2892b411b363SPhilipp Reisner 2893b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 2894b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 2895b411b363SPhilipp Reisner + SHARED_SECRET_MAX 28968e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 28978e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 2898b411b363SPhilipp Reisner 289902918be2SPhilipp Reisner if (packet_size > exp_max_sz) { 2900b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 290102918be2SPhilipp Reisner packet_size, exp_max_sz); 2902b411b363SPhilipp Reisner return FALSE; 2903b411b363SPhilipp Reisner } 2904b411b363SPhilipp Reisner 2905b411b363SPhilipp Reisner if (apv <= 88) { 290602918be2SPhilipp Reisner header_size = sizeof(struct p_rs_param) - sizeof(struct p_header80); 290702918be2SPhilipp Reisner data_size = packet_size - header_size; 29088e26f9ccSPhilipp Reisner } else if (apv <= 94) { 290902918be2SPhilipp Reisner header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header80); 291002918be2SPhilipp Reisner data_size = packet_size - header_size; 2911b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 29128e26f9ccSPhilipp Reisner } else { 291302918be2SPhilipp Reisner header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header80); 291402918be2SPhilipp Reisner data_size = packet_size - header_size; 29158e26f9ccSPhilipp Reisner D_ASSERT(data_size == 0); 2916b411b363SPhilipp Reisner } 2917b411b363SPhilipp Reisner 2918b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 2919b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 2920b411b363SPhilipp Reisner 292102918be2SPhilipp Reisner if (drbd_recv(mdev, &p->head.payload, header_size) != header_size) 2922b411b363SPhilipp Reisner return FALSE; 2923b411b363SPhilipp Reisner 2924b411b363SPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 2925b411b363SPhilipp Reisner 2926b411b363SPhilipp Reisner if (apv >= 88) { 2927b411b363SPhilipp Reisner if (apv == 88) { 2928b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 2929b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 2930b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 2931b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 2932b411b363SPhilipp Reisner return FALSE; 2933b411b363SPhilipp Reisner } 2934b411b363SPhilipp Reisner 2935b411b363SPhilipp Reisner if (drbd_recv(mdev, p->verify_alg, data_size) != data_size) 2936b411b363SPhilipp Reisner return FALSE; 2937b411b363SPhilipp Reisner 2938b411b363SPhilipp Reisner /* we expect NUL terminated string */ 2939b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2940b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 2941b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 2942b411b363SPhilipp Reisner 2943b411b363SPhilipp Reisner } else /* apv >= 89 */ { 2944b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 2945b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2946b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 2947b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 2948b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 2949b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 2950b411b363SPhilipp Reisner } 2951b411b363SPhilipp Reisner 2952b411b363SPhilipp Reisner if (strcmp(mdev->sync_conf.verify_alg, p->verify_alg)) { 2953b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2954b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 2955b411b363SPhilipp Reisner mdev->sync_conf.verify_alg, p->verify_alg); 2956b411b363SPhilipp Reisner goto disconnect; 2957b411b363SPhilipp Reisner } 2958b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 2959b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 2960b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 2961b411b363SPhilipp Reisner verify_tfm = NULL; 2962b411b363SPhilipp Reisner goto disconnect; 2963b411b363SPhilipp Reisner } 2964b411b363SPhilipp Reisner } 2965b411b363SPhilipp Reisner 2966b411b363SPhilipp Reisner if (apv >= 89 && strcmp(mdev->sync_conf.csums_alg, p->csums_alg)) { 2967b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2968b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 2969b411b363SPhilipp Reisner mdev->sync_conf.csums_alg, p->csums_alg); 2970b411b363SPhilipp Reisner goto disconnect; 2971b411b363SPhilipp Reisner } 2972b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 2973b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 2974b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 2975b411b363SPhilipp Reisner csums_tfm = NULL; 2976b411b363SPhilipp Reisner goto disconnect; 2977b411b363SPhilipp Reisner } 2978b411b363SPhilipp Reisner } 2979b411b363SPhilipp Reisner 29808e26f9ccSPhilipp Reisner if (apv > 94) { 29818e26f9ccSPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 29828e26f9ccSPhilipp Reisner mdev->sync_conf.c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 29838e26f9ccSPhilipp Reisner mdev->sync_conf.c_delay_target = be32_to_cpu(p->c_delay_target); 29848e26f9ccSPhilipp Reisner mdev->sync_conf.c_fill_target = be32_to_cpu(p->c_fill_target); 29858e26f9ccSPhilipp Reisner mdev->sync_conf.c_max_rate = be32_to_cpu(p->c_max_rate); 2986778f271dSPhilipp Reisner 2987778f271dSPhilipp Reisner fifo_size = (mdev->sync_conf.c_plan_ahead * 10 * SLEEP_TIME) / HZ; 2988778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) { 2989778f271dSPhilipp Reisner rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL); 2990778f271dSPhilipp Reisner if (!rs_plan_s) { 2991778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 2992778f271dSPhilipp Reisner goto disconnect; 2993778f271dSPhilipp Reisner } 2994778f271dSPhilipp Reisner } 29958e26f9ccSPhilipp Reisner } 2996b411b363SPhilipp Reisner 2997b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 2998b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 2999b411b363SPhilipp Reisner if (verify_tfm) { 3000b411b363SPhilipp Reisner strcpy(mdev->sync_conf.verify_alg, p->verify_alg); 3001b411b363SPhilipp Reisner mdev->sync_conf.verify_alg_len = strlen(p->verify_alg) + 1; 3002b411b363SPhilipp Reisner crypto_free_hash(mdev->verify_tfm); 3003b411b363SPhilipp Reisner mdev->verify_tfm = verify_tfm; 3004b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3005b411b363SPhilipp Reisner } 3006b411b363SPhilipp Reisner if (csums_tfm) { 3007b411b363SPhilipp Reisner strcpy(mdev->sync_conf.csums_alg, p->csums_alg); 3008b411b363SPhilipp Reisner mdev->sync_conf.csums_alg_len = strlen(p->csums_alg) + 1; 3009b411b363SPhilipp Reisner crypto_free_hash(mdev->csums_tfm); 3010b411b363SPhilipp Reisner mdev->csums_tfm = csums_tfm; 3011b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3012b411b363SPhilipp Reisner } 3013778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size) { 3014778f271dSPhilipp Reisner kfree(mdev->rs_plan_s.values); 3015778f271dSPhilipp Reisner mdev->rs_plan_s.values = rs_plan_s; 3016778f271dSPhilipp Reisner mdev->rs_plan_s.size = fifo_size; 3017778f271dSPhilipp Reisner mdev->rs_planed = 0; 3018778f271dSPhilipp Reisner } 3019b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 3020b411b363SPhilipp Reisner } 3021b411b363SPhilipp Reisner 3022b411b363SPhilipp Reisner return ok; 3023b411b363SPhilipp Reisner disconnect: 3024b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3025b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3026b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3027b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3028b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 3029b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3030b411b363SPhilipp Reisner return FALSE; 3031b411b363SPhilipp Reisner } 3032b411b363SPhilipp Reisner 3033b411b363SPhilipp Reisner static void drbd_setup_order_type(struct drbd_conf *mdev, int peer) 3034b411b363SPhilipp Reisner { 3035b411b363SPhilipp Reisner /* sorry, we currently have no working implementation 3036b411b363SPhilipp Reisner * of distributed TCQ */ 3037b411b363SPhilipp Reisner } 3038b411b363SPhilipp Reisner 3039b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3040b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3041b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3042b411b363SPhilipp Reisner { 3043b411b363SPhilipp Reisner sector_t d; 3044b411b363SPhilipp Reisner if (a == 0 || b == 0) 3045b411b363SPhilipp Reisner return; 3046b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3047b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3048b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3049b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3050b411b363SPhilipp Reisner } 3051b411b363SPhilipp Reisner 305202918be2SPhilipp Reisner static int receive_sizes(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3053b411b363SPhilipp Reisner { 305402918be2SPhilipp Reisner struct p_sizes *p = &mdev->data.rbuf.sizes; 3055b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3056b411b363SPhilipp Reisner unsigned int max_seg_s; 3057b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3058b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3059e89b591cSPhilipp Reisner enum dds_flags ddsf; 3060b411b363SPhilipp Reisner 3061b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3062b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3063b411b363SPhilipp Reisner 3064b411b363SPhilipp Reisner if (p_size == 0 && mdev->state.disk == D_DISKLESS) { 3065b411b363SPhilipp Reisner dev_err(DEV, "some backing storage is needed\n"); 3066b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3067b411b363SPhilipp Reisner return FALSE; 3068b411b363SPhilipp Reisner } 3069b411b363SPhilipp Reisner 3070b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3071b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3072b411b363SPhilipp Reisner mdev->p_size = p_size; 3073b411b363SPhilipp Reisner 3074b411b363SPhilipp Reisner #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r)) 3075b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3076b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3077b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3078b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3079b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 3080b411b363SPhilipp Reisner 3081b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3082b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3083b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3084b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 3085b411b363SPhilipp Reisner p_usize); 3086b411b363SPhilipp Reisner 3087b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 3088b411b363SPhilipp Reisner 3089b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 3090b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 3091b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3092b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 3093b411b363SPhilipp Reisner } 3094b411b363SPhilipp Reisner 3095b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3096b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3097a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 3098b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3099b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3100b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3101b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 3102b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3103b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 3104b411b363SPhilipp Reisner put_ldev(mdev); 3105b411b363SPhilipp Reisner return FALSE; 3106b411b363SPhilipp Reisner } 3107b411b363SPhilipp Reisner put_ldev(mdev); 3108b411b363SPhilipp Reisner } 3109b411b363SPhilipp Reisner #undef min_not_zero 3110b411b363SPhilipp Reisner 3111e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3112b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3113e89b591cSPhilipp Reisner dd = drbd_determin_dev_size(mdev, ddsf); 3114b411b363SPhilipp Reisner put_ldev(mdev); 3115b411b363SPhilipp Reisner if (dd == dev_size_error) 3116b411b363SPhilipp Reisner return FALSE; 3117b411b363SPhilipp Reisner drbd_md_sync(mdev); 3118b411b363SPhilipp Reisner } else { 3119b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3120b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3121b411b363SPhilipp Reisner } 3122b411b363SPhilipp Reisner 3123b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3124b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3125b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3126b411b363SPhilipp Reisner ldsc = 1; 3127b411b363SPhilipp Reisner } 3128b411b363SPhilipp Reisner 3129a1c88d0dSLars Ellenberg if (mdev->agreed_pro_version < 94) 3130b411b363SPhilipp Reisner max_seg_s = be32_to_cpu(p->max_segment_size); 31318979d9c9SLars Ellenberg else if (mdev->agreed_pro_version == 94) 31328979d9c9SLars Ellenberg max_seg_s = DRBD_MAX_SIZE_H80_PACKET; 3133a1c88d0dSLars Ellenberg else /* drbd 8.3.8 onwards */ 3134a1c88d0dSLars Ellenberg max_seg_s = DRBD_MAX_SEGMENT_SIZE; 3135a1c88d0dSLars Ellenberg 3136b411b363SPhilipp Reisner if (max_seg_s != queue_max_segment_size(mdev->rq_queue)) 3137b411b363SPhilipp Reisner drbd_setup_queue_param(mdev, max_seg_s); 3138b411b363SPhilipp Reisner 3139e89b591cSPhilipp Reisner drbd_setup_order_type(mdev, be16_to_cpu(p->queue_order_type)); 3140b411b363SPhilipp Reisner put_ldev(mdev); 3141b411b363SPhilipp Reisner } 3142b411b363SPhilipp Reisner 3143b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3144b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3145b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3146b411b363SPhilipp Reisner /* we have different sizes, probably peer 3147b411b363SPhilipp Reisner * needs to know my new size... */ 3148e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3149b411b363SPhilipp Reisner } 3150b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3151b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3152b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3153e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3154e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3155e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3156b411b363SPhilipp Reisner else 3157e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3158e89b591cSPhilipp Reisner } else 3159b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3160b411b363SPhilipp Reisner } 3161b411b363SPhilipp Reisner } 3162b411b363SPhilipp Reisner 3163b411b363SPhilipp Reisner return TRUE; 3164b411b363SPhilipp Reisner } 3165b411b363SPhilipp Reisner 316602918be2SPhilipp Reisner static int receive_uuids(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3167b411b363SPhilipp Reisner { 316802918be2SPhilipp Reisner struct p_uuids *p = &mdev->data.rbuf.uuids; 3169b411b363SPhilipp Reisner u64 *p_uuid; 3170b411b363SPhilipp Reisner int i; 3171b411b363SPhilipp Reisner 3172b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3173b411b363SPhilipp Reisner 3174b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3175b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3176b411b363SPhilipp Reisner 3177b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3178b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3179b411b363SPhilipp Reisner 3180b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3181b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3182b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3183b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3184b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3185b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 3186b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3187b411b363SPhilipp Reisner return FALSE; 3188b411b363SPhilipp Reisner } 3189b411b363SPhilipp Reisner 3190b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3191b411b363SPhilipp Reisner int skip_initial_sync = 3192b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 3193b411b363SPhilipp Reisner mdev->agreed_pro_version >= 90 && 3194b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3195b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3196b411b363SPhilipp Reisner if (skip_initial_sync) { 3197b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3198b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 3199b411b363SPhilipp Reisner "clear_n_write from receive_uuids"); 3200b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3201b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3202b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3203b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3204b411b363SPhilipp Reisner drbd_md_sync(mdev); 3205b411b363SPhilipp Reisner } 3206b411b363SPhilipp Reisner put_ldev(mdev); 320718a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 320818a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 320918a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 321018a50fa2SPhilipp Reisner for me. */ 321118a50fa2SPhilipp Reisner drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3212b411b363SPhilipp Reisner } 3213b411b363SPhilipp Reisner 3214b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3215b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3216b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3217b411b363SPhilipp Reisner new disk state... */ 3218b411b363SPhilipp Reisner wait_event(mdev->misc_wait, !test_bit(CLUSTER_ST_CHANGE, &mdev->flags)); 3219b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 3220b411b363SPhilipp Reisner drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3221b411b363SPhilipp Reisner 3222b411b363SPhilipp Reisner return TRUE; 3223b411b363SPhilipp Reisner } 3224b411b363SPhilipp Reisner 3225b411b363SPhilipp Reisner /** 3226b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3227b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3228b411b363SPhilipp Reisner */ 3229b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3230b411b363SPhilipp Reisner { 3231b411b363SPhilipp Reisner union drbd_state ms; 3232b411b363SPhilipp Reisner 3233b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3234b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3235b411b363SPhilipp Reisner 3236b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3237b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3238b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3239b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3240b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3241b411b363SPhilipp Reisner }; 3242b411b363SPhilipp Reisner 3243b411b363SPhilipp Reisner ms.i = ps.i; 3244b411b363SPhilipp Reisner 3245b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3246b411b363SPhilipp Reisner ms.peer = ps.role; 3247b411b363SPhilipp Reisner ms.role = ps.peer; 3248b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3249b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3250b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3251b411b363SPhilipp Reisner 3252b411b363SPhilipp Reisner return ms; 3253b411b363SPhilipp Reisner } 3254b411b363SPhilipp Reisner 325502918be2SPhilipp Reisner static int receive_req_state(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3256b411b363SPhilipp Reisner { 325702918be2SPhilipp Reisner struct p_req_state *p = &mdev->data.rbuf.req_state; 3258b411b363SPhilipp Reisner union drbd_state mask, val; 3259b411b363SPhilipp Reisner int rv; 3260b411b363SPhilipp Reisner 3261b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3262b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3263b411b363SPhilipp Reisner 3264b411b363SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->flags) && 3265b411b363SPhilipp Reisner test_bit(CLUSTER_ST_CHANGE, &mdev->flags)) { 3266b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 3267b411b363SPhilipp Reisner return TRUE; 3268b411b363SPhilipp Reisner } 3269b411b363SPhilipp Reisner 3270b411b363SPhilipp Reisner mask = convert_state(mask); 3271b411b363SPhilipp Reisner val = convert_state(val); 3272b411b363SPhilipp Reisner 3273b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3274b411b363SPhilipp Reisner 3275b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3276b411b363SPhilipp Reisner drbd_md_sync(mdev); 3277b411b363SPhilipp Reisner 3278b411b363SPhilipp Reisner return TRUE; 3279b411b363SPhilipp Reisner } 3280b411b363SPhilipp Reisner 328102918be2SPhilipp Reisner static int receive_state(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3282b411b363SPhilipp Reisner { 328302918be2SPhilipp Reisner struct p_state *p = &mdev->data.rbuf.state; 32844ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3285b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 328665d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3287b411b363SPhilipp Reisner int rv; 3288b411b363SPhilipp Reisner 3289b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3290b411b363SPhilipp Reisner 3291b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3292b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3293b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3294b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3295b411b363SPhilipp Reisner } 3296b411b363SPhilipp Reisner 3297b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3298b411b363SPhilipp Reisner retry: 32994ac4aadaSLars Ellenberg os = ns = mdev->state; 3300b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3301b411b363SPhilipp Reisner 3302e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3303e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3304e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3305e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3306e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3307e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3308e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3309e9ef7bb6SLars Ellenberg * syncing states. 3310e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3311e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3312e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3313e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3314e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3315e9ef7bb6SLars Ellenberg 3316e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3317e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3318e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3319e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3320e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3321e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3322e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 3323e9ef7bb6SLars Ellenberg return TRUE; 3324e9ef7bb6SLars Ellenberg } 3325e9ef7bb6SLars Ellenberg } 3326e9ef7bb6SLars Ellenberg 3327e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3328e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3329e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3330e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3331e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3332e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3333e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3334e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3335e9ef7bb6SLars Ellenberg 33364ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 33374ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3338b411b363SPhilipp Reisner 3339b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3340b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3341b411b363SPhilipp Reisner int cr; /* consider resync */ 3342b411b363SPhilipp Reisner 3343b411b363SPhilipp Reisner /* if we established a new connection */ 33444ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3345b411b363SPhilipp Reisner /* if we had an established connection 3346b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 33474ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3348b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 33494ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3350b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3351b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3352b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3353b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3354b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 33554ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3356b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3357b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3358b411b363SPhilipp Reisner 3359b411b363SPhilipp Reisner if (cr) 33604ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3361b411b363SPhilipp Reisner 3362b411b363SPhilipp Reisner put_ldev(mdev); 33634ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 33644ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3365b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 336682f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3367b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3368b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3369b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3370580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3371b411b363SPhilipp Reisner } else { 3372cf14c2e9SPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->flags)) 3373cf14c2e9SPhilipp Reisner return FALSE; 33744ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 3375b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3376b411b363SPhilipp Reisner return FALSE; 3377b411b363SPhilipp Reisner } 3378b411b363SPhilipp Reisner } 3379b411b363SPhilipp Reisner } 3380b411b363SPhilipp Reisner 3381b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 33824ac4aadaSLars Ellenberg if (mdev->state.i != os.i) 3383b411b363SPhilipp Reisner goto retry; 3384b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3385b411b363SPhilipp Reisner ns.peer = peer_state.role; 3386b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3387b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 33884ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3389b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 33904ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 33914ac4aadaSLars Ellenberg if (ns.pdsk == D_CONSISTENT && is_susp(ns) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3392481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 3393481c6f50SPhilipp Reisner /* Do not allow tl_restart(resend) for a rebooted peer. We can only allow this 3394481c6f50SPhilipp Reisner for temporal network outages! */ 3395481c6f50SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3396481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 3397481c6f50SPhilipp Reisner tl_clear(mdev); 3398481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3399481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 3400481c6f50SPhilipp Reisner drbd_force_state(mdev, NS2(conn, C_PROTOCOL_ERROR, susp, 0)); 3401481c6f50SPhilipp Reisner return FALSE; 3402481c6f50SPhilipp Reisner } 340365d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 3404b411b363SPhilipp Reisner ns = mdev->state; 3405b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3406b411b363SPhilipp Reisner 3407b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 3408b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3409b411b363SPhilipp Reisner return FALSE; 3410b411b363SPhilipp Reisner } 3411b411b363SPhilipp Reisner 34124ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 34134ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3414b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3415b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3416b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3417b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3418b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3419b411b363SPhilipp Reisner drbd_send_state(mdev); 3420b411b363SPhilipp Reisner } 3421b411b363SPhilipp Reisner } 3422b411b363SPhilipp Reisner 3423b411b363SPhilipp Reisner mdev->net_conf->want_lose = 0; 3424b411b363SPhilipp Reisner 3425b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3426b411b363SPhilipp Reisner 3427b411b363SPhilipp Reisner return TRUE; 3428b411b363SPhilipp Reisner } 3429b411b363SPhilipp Reisner 343002918be2SPhilipp Reisner static int receive_sync_uuid(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3431b411b363SPhilipp Reisner { 343202918be2SPhilipp Reisner struct p_rs_uuid *p = &mdev->data.rbuf.rs_uuid; 3433b411b363SPhilipp Reisner 3434b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3435b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3436b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3437b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3438b411b363SPhilipp Reisner 3439b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3440b411b363SPhilipp Reisner 3441b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3442b411b363SPhilipp Reisner _not_ be rotated into the history */ 3443b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3444b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3445b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3446b411b363SPhilipp Reisner 3447b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3448b411b363SPhilipp Reisner 3449b411b363SPhilipp Reisner put_ldev(mdev); 3450b411b363SPhilipp Reisner } else 3451b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3452b411b363SPhilipp Reisner 3453b411b363SPhilipp Reisner return TRUE; 3454b411b363SPhilipp Reisner } 3455b411b363SPhilipp Reisner 3456b411b363SPhilipp Reisner enum receive_bitmap_ret { OK, DONE, FAILED }; 3457b411b363SPhilipp Reisner 3458b411b363SPhilipp Reisner static enum receive_bitmap_ret 345902918be2SPhilipp Reisner receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size, 3460b411b363SPhilipp Reisner unsigned long *buffer, struct bm_xfer_ctx *c) 3461b411b363SPhilipp Reisner { 3462b411b363SPhilipp Reisner unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset); 3463b411b363SPhilipp Reisner unsigned want = num_words * sizeof(long); 3464b411b363SPhilipp Reisner 346502918be2SPhilipp Reisner if (want != data_size) { 346602918be2SPhilipp Reisner dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size); 3467b411b363SPhilipp Reisner return FAILED; 3468b411b363SPhilipp Reisner } 3469b411b363SPhilipp Reisner if (want == 0) 3470b411b363SPhilipp Reisner return DONE; 3471b411b363SPhilipp Reisner if (drbd_recv(mdev, buffer, want) != want) 3472b411b363SPhilipp Reisner return FAILED; 3473b411b363SPhilipp Reisner 3474b411b363SPhilipp Reisner drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer); 3475b411b363SPhilipp Reisner 3476b411b363SPhilipp Reisner c->word_offset += num_words; 3477b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3478b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3479b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3480b411b363SPhilipp Reisner 3481b411b363SPhilipp Reisner return OK; 3482b411b363SPhilipp Reisner } 3483b411b363SPhilipp Reisner 3484b411b363SPhilipp Reisner static enum receive_bitmap_ret 3485b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3486b411b363SPhilipp Reisner struct p_compressed_bm *p, 3487b411b363SPhilipp Reisner struct bm_xfer_ctx *c) 3488b411b363SPhilipp Reisner { 3489b411b363SPhilipp Reisner struct bitstream bs; 3490b411b363SPhilipp Reisner u64 look_ahead; 3491b411b363SPhilipp Reisner u64 rl; 3492b411b363SPhilipp Reisner u64 tmp; 3493b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3494b411b363SPhilipp Reisner unsigned long e; 3495004352faSLars Ellenberg int len = be16_to_cpu(p->head.length) - (sizeof(*p) - sizeof(p->head)); 3496b411b363SPhilipp Reisner int toggle = DCBP_get_start(p); 3497b411b363SPhilipp Reisner int have; 3498b411b363SPhilipp Reisner int bits; 3499b411b363SPhilipp Reisner 3500b411b363SPhilipp Reisner bitstream_init(&bs, p->code, len, DCBP_get_pad_bits(p)); 3501b411b363SPhilipp Reisner 3502b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3503b411b363SPhilipp Reisner if (bits < 0) 3504b411b363SPhilipp Reisner return FAILED; 3505b411b363SPhilipp Reisner 3506b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3507b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3508b411b363SPhilipp Reisner if (bits <= 0) 3509b411b363SPhilipp Reisner return FAILED; 3510b411b363SPhilipp Reisner 3511b411b363SPhilipp Reisner if (toggle) { 3512b411b363SPhilipp Reisner e = s + rl -1; 3513b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3514b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 3515b411b363SPhilipp Reisner return FAILED; 3516b411b363SPhilipp Reisner } 3517b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3518b411b363SPhilipp Reisner } 3519b411b363SPhilipp Reisner 3520b411b363SPhilipp Reisner if (have < bits) { 3521b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3522b411b363SPhilipp Reisner have, bits, look_ahead, 3523b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3524b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 3525b411b363SPhilipp Reisner return FAILED; 3526b411b363SPhilipp Reisner } 3527b411b363SPhilipp Reisner look_ahead >>= bits; 3528b411b363SPhilipp Reisner have -= bits; 3529b411b363SPhilipp Reisner 3530b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3531b411b363SPhilipp Reisner if (bits < 0) 3532b411b363SPhilipp Reisner return FAILED; 3533b411b363SPhilipp Reisner look_ahead |= tmp << have; 3534b411b363SPhilipp Reisner have += bits; 3535b411b363SPhilipp Reisner } 3536b411b363SPhilipp Reisner 3537b411b363SPhilipp Reisner c->bit_offset = s; 3538b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3539b411b363SPhilipp Reisner 3540b411b363SPhilipp Reisner return (s == c->bm_bits) ? DONE : OK; 3541b411b363SPhilipp Reisner } 3542b411b363SPhilipp Reisner 3543b411b363SPhilipp Reisner static enum receive_bitmap_ret 3544b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3545b411b363SPhilipp Reisner struct p_compressed_bm *p, 3546b411b363SPhilipp Reisner struct bm_xfer_ctx *c) 3547b411b363SPhilipp Reisner { 3548b411b363SPhilipp Reisner if (DCBP_get_code(p) == RLE_VLI_Bits) 3549b411b363SPhilipp Reisner return recv_bm_rle_bits(mdev, p, c); 3550b411b363SPhilipp Reisner 3551b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3552b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3553b411b363SPhilipp Reisner * during all our tests. */ 3554b411b363SPhilipp Reisner 3555b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 3556b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 3557b411b363SPhilipp Reisner return FAILED; 3558b411b363SPhilipp Reisner } 3559b411b363SPhilipp Reisner 3560b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3561b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3562b411b363SPhilipp Reisner { 3563b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 35640b70a13dSPhilipp Reisner unsigned plain = sizeof(struct p_header80) * 3565b411b363SPhilipp Reisner ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1) 3566b411b363SPhilipp Reisner + c->bm_words * sizeof(long); 3567b411b363SPhilipp Reisner unsigned total = c->bytes[0] + c->bytes[1]; 3568b411b363SPhilipp Reisner unsigned r; 3569b411b363SPhilipp Reisner 3570b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3571b411b363SPhilipp Reisner if (total == 0) 3572b411b363SPhilipp Reisner return; 3573b411b363SPhilipp Reisner 3574b411b363SPhilipp Reisner /* don't report if not compressed */ 3575b411b363SPhilipp Reisner if (total >= plain) 3576b411b363SPhilipp Reisner return; 3577b411b363SPhilipp Reisner 3578b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3579b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3580b411b363SPhilipp Reisner : (1000 * total / plain); 3581b411b363SPhilipp Reisner 3582b411b363SPhilipp Reisner if (r > 1000) 3583b411b363SPhilipp Reisner r = 1000; 3584b411b363SPhilipp Reisner 3585b411b363SPhilipp Reisner r = 1000 - r; 3586b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3587b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3588b411b363SPhilipp Reisner direction, 3589b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3590b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3591b411b363SPhilipp Reisner total, r/10, r % 10); 3592b411b363SPhilipp Reisner } 3593b411b363SPhilipp Reisner 3594b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3595b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3596b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3597b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3598b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3599b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3600b411b363SPhilipp Reisner 3601b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 360202918be2SPhilipp Reisner static int receive_bitmap(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3603b411b363SPhilipp Reisner { 3604b411b363SPhilipp Reisner struct bm_xfer_ctx c; 3605b411b363SPhilipp Reisner void *buffer; 3606b411b363SPhilipp Reisner enum receive_bitmap_ret ret; 3607b411b363SPhilipp Reisner int ok = FALSE; 360802918be2SPhilipp Reisner struct p_header80 *h = &mdev->data.rbuf.header.h80; 3609b411b363SPhilipp Reisner 3610b411b363SPhilipp Reisner wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt)); 3611b411b363SPhilipp Reisner 3612b411b363SPhilipp Reisner drbd_bm_lock(mdev, "receive bitmap"); 3613b411b363SPhilipp Reisner 3614b411b363SPhilipp Reisner /* maybe we should use some per thread scratch page, 3615b411b363SPhilipp Reisner * and allocate that during initial device creation? */ 3616b411b363SPhilipp Reisner buffer = (unsigned long *) __get_free_page(GFP_NOIO); 3617b411b363SPhilipp Reisner if (!buffer) { 3618b411b363SPhilipp Reisner dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__); 3619b411b363SPhilipp Reisner goto out; 3620b411b363SPhilipp Reisner } 3621b411b363SPhilipp Reisner 3622b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3623b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3624b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3625b411b363SPhilipp Reisner }; 3626b411b363SPhilipp Reisner 3627b411b363SPhilipp Reisner do { 362802918be2SPhilipp Reisner if (cmd == P_BITMAP) { 362902918be2SPhilipp Reisner ret = receive_bitmap_plain(mdev, data_size, buffer, &c); 363002918be2SPhilipp Reisner } else if (cmd == P_COMPRESSED_BITMAP) { 3631b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3632b411b363SPhilipp Reisner * and the feature is enabled! */ 3633b411b363SPhilipp Reisner struct p_compressed_bm *p; 3634b411b363SPhilipp Reisner 363502918be2SPhilipp Reisner if (data_size > BM_PACKET_PAYLOAD_BYTES) { 3636b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 3637b411b363SPhilipp Reisner goto out; 3638b411b363SPhilipp Reisner } 3639b411b363SPhilipp Reisner /* use the page buff */ 3640b411b363SPhilipp Reisner p = buffer; 3641b411b363SPhilipp Reisner memcpy(p, h, sizeof(*h)); 364202918be2SPhilipp Reisner if (drbd_recv(mdev, p->head.payload, data_size) != data_size) 3643b411b363SPhilipp Reisner goto out; 3644004352faSLars Ellenberg if (data_size <= (sizeof(*p) - sizeof(p->head))) { 3645004352faSLars Ellenberg dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", data_size); 3646b411b363SPhilipp Reisner return FAILED; 3647b411b363SPhilipp Reisner } 3648b411b363SPhilipp Reisner ret = decode_bitmap_c(mdev, p, &c); 3649b411b363SPhilipp Reisner } else { 365002918be2SPhilipp Reisner dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", cmd); 3651b411b363SPhilipp Reisner goto out; 3652b411b363SPhilipp Reisner } 3653b411b363SPhilipp Reisner 365402918be2SPhilipp Reisner c.packets[cmd == P_BITMAP]++; 365502918be2SPhilipp Reisner c.bytes[cmd == P_BITMAP] += sizeof(struct p_header80) + data_size; 3656b411b363SPhilipp Reisner 3657b411b363SPhilipp Reisner if (ret != OK) 3658b411b363SPhilipp Reisner break; 3659b411b363SPhilipp Reisner 366002918be2SPhilipp Reisner if (!drbd_recv_header(mdev, &cmd, &data_size)) 3661b411b363SPhilipp Reisner goto out; 3662b411b363SPhilipp Reisner } while (ret == OK); 3663b411b363SPhilipp Reisner if (ret == FAILED) 3664b411b363SPhilipp Reisner goto out; 3665b411b363SPhilipp Reisner 3666b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3667b411b363SPhilipp Reisner 3668b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3669b411b363SPhilipp Reisner ok = !drbd_send_bitmap(mdev); 3670b411b363SPhilipp Reisner if (!ok) 3671b411b363SPhilipp Reisner goto out; 3672b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3673b411b363SPhilipp Reisner ok = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3674b411b363SPhilipp Reisner D_ASSERT(ok == SS_SUCCESS); 3675b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3676b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3677b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3678b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3679b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3680b411b363SPhilipp Reisner } 3681b411b363SPhilipp Reisner 3682b411b363SPhilipp Reisner ok = TRUE; 3683b411b363SPhilipp Reisner out: 3684b411b363SPhilipp Reisner drbd_bm_unlock(mdev); 3685b411b363SPhilipp Reisner if (ok && mdev->state.conn == C_WF_BITMAP_S) 3686b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 3687b411b363SPhilipp Reisner free_page((unsigned long) buffer); 3688b411b363SPhilipp Reisner return ok; 3689b411b363SPhilipp Reisner } 3690b411b363SPhilipp Reisner 369102918be2SPhilipp Reisner static int receive_skip(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3692b411b363SPhilipp Reisner { 3693b411b363SPhilipp Reisner /* TODO zero copy sink :) */ 3694b411b363SPhilipp Reisner static char sink[128]; 3695b411b363SPhilipp Reisner int size, want, r; 3696b411b363SPhilipp Reisner 3697b411b363SPhilipp Reisner dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n", 369802918be2SPhilipp Reisner cmd, data_size); 3699b411b363SPhilipp Reisner 370002918be2SPhilipp Reisner size = data_size; 3701b411b363SPhilipp Reisner while (size > 0) { 3702b411b363SPhilipp Reisner want = min_t(int, size, sizeof(sink)); 3703b411b363SPhilipp Reisner r = drbd_recv(mdev, sink, want); 3704b411b363SPhilipp Reisner ERR_IF(r <= 0) break; 3705b411b363SPhilipp Reisner size -= r; 3706b411b363SPhilipp Reisner } 3707b411b363SPhilipp Reisner return size == 0; 3708b411b363SPhilipp Reisner } 3709b411b363SPhilipp Reisner 371002918be2SPhilipp Reisner static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size) 3711b411b363SPhilipp Reisner { 3712b411b363SPhilipp Reisner if (mdev->state.disk >= D_INCONSISTENT) 3713b411b363SPhilipp Reisner drbd_kick_lo(mdev); 3714b411b363SPhilipp Reisner 3715b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3716b411b363SPhilipp Reisner * with the data requests being unplugged */ 3717b411b363SPhilipp Reisner drbd_tcp_quickack(mdev->data.socket); 3718b411b363SPhilipp Reisner 3719b411b363SPhilipp Reisner return TRUE; 3720b411b363SPhilipp Reisner } 3721b411b363SPhilipp Reisner 372202918be2SPhilipp Reisner typedef int (*drbd_cmd_handler_f)(struct drbd_conf *, enum drbd_packets cmd, unsigned int to_receive); 3723b411b363SPhilipp Reisner 372402918be2SPhilipp Reisner struct data_cmd { 372502918be2SPhilipp Reisner int expect_payload; 372602918be2SPhilipp Reisner size_t pkt_size; 372702918be2SPhilipp Reisner drbd_cmd_handler_f function; 3728b411b363SPhilipp Reisner }; 3729b411b363SPhilipp Reisner 373002918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 373102918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 373202918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 373302918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 373402918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 373502918be2SPhilipp Reisner [P_BITMAP] = { 1, sizeof(struct p_header80), receive_bitmap } , 373602918be2SPhilipp Reisner [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header80), receive_bitmap } , 373702918be2SPhilipp Reisner [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header80), receive_UnplugRemote }, 373802918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 373902918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 374002918be2SPhilipp Reisner [P_SYNC_PARAM] = { 1, sizeof(struct p_header80), receive_SyncParam }, 374102918be2SPhilipp Reisner [P_SYNC_PARAM89] = { 1, sizeof(struct p_header80), receive_SyncParam }, 374202918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 374302918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 374402918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 374502918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 374602918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 374702918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 374802918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 374902918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 375002918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 375102918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 375202918be2SPhilipp Reisner /* anything missing from this table is in 375302918be2SPhilipp Reisner * the asender_tbl, see get_asender_cmd */ 375402918be2SPhilipp Reisner [P_MAX_CMD] = { 0, 0, NULL }, 375502918be2SPhilipp Reisner }; 375602918be2SPhilipp Reisner 375702918be2SPhilipp Reisner /* All handler functions that expect a sub-header get that sub-heder in 375802918be2SPhilipp Reisner mdev->data.rbuf.header.head.payload. 375902918be2SPhilipp Reisner 376002918be2SPhilipp Reisner Usually in mdev->data.rbuf.header.head the callback can find the usual 376102918be2SPhilipp Reisner p_header, but they may not rely on that. Since there is also p_header95 ! 376202918be2SPhilipp Reisner */ 3763b411b363SPhilipp Reisner 3764b411b363SPhilipp Reisner static void drbdd(struct drbd_conf *mdev) 3765b411b363SPhilipp Reisner { 376602918be2SPhilipp Reisner union p_header *header = &mdev->data.rbuf.header; 376702918be2SPhilipp Reisner unsigned int packet_size; 376802918be2SPhilipp Reisner enum drbd_packets cmd; 376902918be2SPhilipp Reisner size_t shs; /* sub header size */ 377002918be2SPhilipp Reisner int rv; 3771b411b363SPhilipp Reisner 3772b411b363SPhilipp Reisner while (get_t_state(&mdev->receiver) == Running) { 3773b411b363SPhilipp Reisner drbd_thread_current_set_cpu(mdev); 377402918be2SPhilipp Reisner if (!drbd_recv_header(mdev, &cmd, &packet_size)) 377502918be2SPhilipp Reisner goto err_out; 377602918be2SPhilipp Reisner 377702918be2SPhilipp Reisner if (unlikely(cmd >= P_MAX_CMD || !drbd_cmd_handler[cmd].function)) { 377802918be2SPhilipp Reisner dev_err(DEV, "unknown packet type %d, l: %d!\n", cmd, packet_size); 377902918be2SPhilipp Reisner goto err_out; 37800b33a916SLars Ellenberg } 3781b411b363SPhilipp Reisner 378202918be2SPhilipp Reisner shs = drbd_cmd_handler[cmd].pkt_size - sizeof(union p_header); 378302918be2SPhilipp Reisner rv = drbd_recv(mdev, &header->h80.payload, shs); 378402918be2SPhilipp Reisner if (unlikely(rv != shs)) { 378502918be2SPhilipp Reisner dev_err(DEV, "short read while reading sub header: rv=%d\n", rv); 378602918be2SPhilipp Reisner goto err_out; 3787b411b363SPhilipp Reisner } 378802918be2SPhilipp Reisner 378902918be2SPhilipp Reisner if (packet_size - shs > 0 && !drbd_cmd_handler[cmd].expect_payload) { 379002918be2SPhilipp Reisner dev_err(DEV, "No payload expected %s l:%d\n", cmdname(cmd), packet_size); 379102918be2SPhilipp Reisner goto err_out; 379202918be2SPhilipp Reisner } 379302918be2SPhilipp Reisner 379402918be2SPhilipp Reisner rv = drbd_cmd_handler[cmd].function(mdev, cmd, packet_size - shs); 379502918be2SPhilipp Reisner 379602918be2SPhilipp Reisner if (unlikely(!rv)) { 3797b411b363SPhilipp Reisner dev_err(DEV, "error receiving %s, l: %d!\n", 379802918be2SPhilipp Reisner cmdname(cmd), packet_size); 379902918be2SPhilipp Reisner goto err_out; 3800b411b363SPhilipp Reisner } 3801b411b363SPhilipp Reisner } 380202918be2SPhilipp Reisner 380302918be2SPhilipp Reisner if (0) { 380402918be2SPhilipp Reisner err_out: 380502918be2SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 380602918be2SPhilipp Reisner } 3807856c50c7SLars Ellenberg /* If we leave here, we probably want to update at least the 3808856c50c7SLars Ellenberg * "Connected" indicator on stable storage. Do so explicitly here. */ 3809856c50c7SLars Ellenberg drbd_md_sync(mdev); 3810b411b363SPhilipp Reisner } 3811b411b363SPhilipp Reisner 3812b411b363SPhilipp Reisner void drbd_flush_workqueue(struct drbd_conf *mdev) 3813b411b363SPhilipp Reisner { 3814b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 3815b411b363SPhilipp Reisner 3816b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 3817b411b363SPhilipp Reisner init_completion(&barr.done); 3818b411b363SPhilipp Reisner drbd_queue_work(&mdev->data.work, &barr.w); 3819b411b363SPhilipp Reisner wait_for_completion(&barr.done); 3820b411b363SPhilipp Reisner } 3821b411b363SPhilipp Reisner 3822f70b3511SPhilipp Reisner void drbd_free_tl_hash(struct drbd_conf *mdev) 3823f70b3511SPhilipp Reisner { 3824f70b3511SPhilipp Reisner struct hlist_head *h; 3825f70b3511SPhilipp Reisner 3826f70b3511SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3827f70b3511SPhilipp Reisner 3828f70b3511SPhilipp Reisner if (!mdev->tl_hash || mdev->state.conn != C_STANDALONE) { 3829f70b3511SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3830f70b3511SPhilipp Reisner return; 3831f70b3511SPhilipp Reisner } 3832f70b3511SPhilipp Reisner /* paranoia code */ 3833f70b3511SPhilipp Reisner for (h = mdev->ee_hash; h < mdev->ee_hash + mdev->ee_hash_s; h++) 3834f70b3511SPhilipp Reisner if (h->first) 3835f70b3511SPhilipp Reisner dev_err(DEV, "ASSERT FAILED ee_hash[%u].first == %p, expected NULL\n", 3836f70b3511SPhilipp Reisner (int)(h - mdev->ee_hash), h->first); 3837f70b3511SPhilipp Reisner kfree(mdev->ee_hash); 3838f70b3511SPhilipp Reisner mdev->ee_hash = NULL; 3839f70b3511SPhilipp Reisner mdev->ee_hash_s = 0; 3840f70b3511SPhilipp Reisner 3841f70b3511SPhilipp Reisner /* paranoia code */ 3842f70b3511SPhilipp Reisner for (h = mdev->tl_hash; h < mdev->tl_hash + mdev->tl_hash_s; h++) 3843f70b3511SPhilipp Reisner if (h->first) 3844f70b3511SPhilipp Reisner dev_err(DEV, "ASSERT FAILED tl_hash[%u] == %p, expected NULL\n", 3845f70b3511SPhilipp Reisner (int)(h - mdev->tl_hash), h->first); 3846f70b3511SPhilipp Reisner kfree(mdev->tl_hash); 3847f70b3511SPhilipp Reisner mdev->tl_hash = NULL; 3848f70b3511SPhilipp Reisner mdev->tl_hash_s = 0; 3849f70b3511SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3850f70b3511SPhilipp Reisner } 3851f70b3511SPhilipp Reisner 3852b411b363SPhilipp Reisner static void drbd_disconnect(struct drbd_conf *mdev) 3853b411b363SPhilipp Reisner { 3854b411b363SPhilipp Reisner enum drbd_fencing_p fp; 3855b411b363SPhilipp Reisner union drbd_state os, ns; 3856b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 3857b411b363SPhilipp Reisner unsigned int i; 3858b411b363SPhilipp Reisner 3859b411b363SPhilipp Reisner if (mdev->state.conn == C_STANDALONE) 3860b411b363SPhilipp Reisner return; 3861b411b363SPhilipp Reisner if (mdev->state.conn >= C_WF_CONNECTION) 3862b411b363SPhilipp Reisner dev_err(DEV, "ASSERT FAILED cstate = %s, expected < WFConnection\n", 3863b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3864b411b363SPhilipp Reisner 3865b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 3866b411b363SPhilipp Reisner drbd_thread_stop(&mdev->asender); 3867b411b363SPhilipp Reisner drbd_free_sock(mdev); 3868b411b363SPhilipp Reisner 386985719573SPhilipp Reisner /* wait for current activity to cease. */ 3870b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3871b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 3872b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 3873b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 3874b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3875b411b363SPhilipp Reisner 3876b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 3877b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 3878b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 3879b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 3880b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 3881b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 3882b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 3883b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 3884b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 3885b411b363SPhilipp Reisner * on the fly. */ 3886b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 3887b411b363SPhilipp Reisner mdev->rs_total = 0; 3888b411b363SPhilipp Reisner mdev->rs_failed = 0; 3889b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 3890b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 3891b411b363SPhilipp Reisner 3892b411b363SPhilipp Reisner /* make sure syncer is stopped and w_resume_next_sg queued */ 3893b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 3894b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 3895b411b363SPhilipp Reisner 3896b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 3897b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 3898b411b363SPhilipp Reisner * to be "canceled" */ 3899b411b363SPhilipp Reisner drbd_flush_workqueue(mdev); 3900b411b363SPhilipp Reisner 3901b411b363SPhilipp Reisner /* This also does reclaim_net_ee(). If we do this too early, we might 3902b411b363SPhilipp Reisner * miss some resync ee and pages.*/ 3903b411b363SPhilipp Reisner drbd_process_done_ee(mdev); 3904b411b363SPhilipp Reisner 3905b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3906b411b363SPhilipp Reisner mdev->p_uuid = NULL; 3907b411b363SPhilipp Reisner 3908fb22c402SPhilipp Reisner if (!is_susp(mdev->state)) 3909b411b363SPhilipp Reisner tl_clear(mdev); 3910b411b363SPhilipp Reisner 3911b411b363SPhilipp Reisner dev_info(DEV, "Connection closed\n"); 3912b411b363SPhilipp Reisner 3913b411b363SPhilipp Reisner drbd_md_sync(mdev); 3914b411b363SPhilipp Reisner 3915b411b363SPhilipp Reisner fp = FP_DONT_CARE; 3916b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3917b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 3918b411b363SPhilipp Reisner put_ldev(mdev); 3919b411b363SPhilipp Reisner } 3920b411b363SPhilipp Reisner 392187f7be4cSPhilipp Reisner if (mdev->state.role == R_PRIMARY && fp >= FP_RESOURCE && mdev->state.pdsk >= D_UNKNOWN) 392287f7be4cSPhilipp Reisner drbd_try_outdate_peer_async(mdev); 3923b411b363SPhilipp Reisner 3924b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3925b411b363SPhilipp Reisner os = mdev->state; 3926b411b363SPhilipp Reisner if (os.conn >= C_UNCONNECTED) { 3927b411b363SPhilipp Reisner /* Do not restart in case we are C_DISCONNECTING */ 3928b411b363SPhilipp Reisner ns = os; 3929b411b363SPhilipp Reisner ns.conn = C_UNCONNECTED; 3930b411b363SPhilipp Reisner rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 3931b411b363SPhilipp Reisner } 3932b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3933b411b363SPhilipp Reisner 3934b411b363SPhilipp Reisner if (os.conn == C_DISCONNECTING) { 393584dfb9f5SPhilipp Reisner wait_event(mdev->net_cnt_wait, atomic_read(&mdev->net_cnt) == 0); 3936b411b363SPhilipp Reisner 3937fb22c402SPhilipp Reisner if (!is_susp(mdev->state)) { 3938b411b363SPhilipp Reisner /* we must not free the tl_hash 3939b411b363SPhilipp Reisner * while application io is still on the fly */ 3940f70b3511SPhilipp Reisner wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt)); 3941f70b3511SPhilipp Reisner drbd_free_tl_hash(mdev); 3942f70b3511SPhilipp Reisner } 3943b411b363SPhilipp Reisner 3944b411b363SPhilipp Reisner crypto_free_hash(mdev->cram_hmac_tfm); 3945b411b363SPhilipp Reisner mdev->cram_hmac_tfm = NULL; 3946b411b363SPhilipp Reisner 3947b411b363SPhilipp Reisner kfree(mdev->net_conf); 3948b411b363SPhilipp Reisner mdev->net_conf = NULL; 3949b411b363SPhilipp Reisner drbd_request_state(mdev, NS(conn, C_STANDALONE)); 3950b411b363SPhilipp Reisner } 3951b411b363SPhilipp Reisner 3952b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 3953b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 3954b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 3955b411b363SPhilipp Reisner * 3956b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 3957b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 3958b411b363SPhilipp Reisner */ 3959b411b363SPhilipp Reisner i = drbd_release_ee(mdev, &mdev->net_ee); 3960b411b363SPhilipp Reisner if (i) 3961b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 3962435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 3963435f0740SLars Ellenberg if (i) 3964435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 3965b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 3966b411b363SPhilipp Reisner if (i) 396745bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 3968b411b363SPhilipp Reisner 3969b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 3970b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 3971b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 3972b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 3973b411b363SPhilipp Reisner 3974b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 3975b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 3976b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 3977b411b363SPhilipp Reisner } 3978b411b363SPhilipp Reisner 3979b411b363SPhilipp Reisner /* 3980b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 3981b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 3982b411b363SPhilipp Reisner * 3983b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 3984b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 3985b411b363SPhilipp Reisner * 3986b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 3987b411b363SPhilipp Reisner */ 3988b411b363SPhilipp Reisner static int drbd_send_handshake(struct drbd_conf *mdev) 3989b411b363SPhilipp Reisner { 3990b411b363SPhilipp Reisner /* ASSERT current == mdev->receiver ... */ 3991b411b363SPhilipp Reisner struct p_handshake *p = &mdev->data.sbuf.handshake; 3992b411b363SPhilipp Reisner int ok; 3993b411b363SPhilipp Reisner 3994b411b363SPhilipp Reisner if (mutex_lock_interruptible(&mdev->data.mutex)) { 3995b411b363SPhilipp Reisner dev_err(DEV, "interrupted during initial handshake\n"); 3996b411b363SPhilipp Reisner return 0; /* interrupted. not ok. */ 3997b411b363SPhilipp Reisner } 3998b411b363SPhilipp Reisner 3999b411b363SPhilipp Reisner if (mdev->data.socket == NULL) { 4000b411b363SPhilipp Reisner mutex_unlock(&mdev->data.mutex); 4001b411b363SPhilipp Reisner return 0; 4002b411b363SPhilipp Reisner } 4003b411b363SPhilipp Reisner 4004b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4005b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4006b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 4007b411b363SPhilipp Reisner ok = _drbd_send_cmd( mdev, mdev->data.socket, P_HAND_SHAKE, 40080b70a13dSPhilipp Reisner (struct p_header80 *)p, sizeof(*p), 0 ); 4009b411b363SPhilipp Reisner mutex_unlock(&mdev->data.mutex); 4010b411b363SPhilipp Reisner return ok; 4011b411b363SPhilipp Reisner } 4012b411b363SPhilipp Reisner 4013b411b363SPhilipp Reisner /* 4014b411b363SPhilipp Reisner * return values: 4015b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4016b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4017b411b363SPhilipp Reisner * -1 peer talks different language, 4018b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4019b411b363SPhilipp Reisner */ 4020b411b363SPhilipp Reisner static int drbd_do_handshake(struct drbd_conf *mdev) 4021b411b363SPhilipp Reisner { 4022b411b363SPhilipp Reisner /* ASSERT current == mdev->receiver ... */ 4023b411b363SPhilipp Reisner struct p_handshake *p = &mdev->data.rbuf.handshake; 402402918be2SPhilipp Reisner const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80); 402502918be2SPhilipp Reisner unsigned int length; 402602918be2SPhilipp Reisner enum drbd_packets cmd; 4027b411b363SPhilipp Reisner int rv; 4028b411b363SPhilipp Reisner 4029b411b363SPhilipp Reisner rv = drbd_send_handshake(mdev); 4030b411b363SPhilipp Reisner if (!rv) 4031b411b363SPhilipp Reisner return 0; 4032b411b363SPhilipp Reisner 403302918be2SPhilipp Reisner rv = drbd_recv_header(mdev, &cmd, &length); 4034b411b363SPhilipp Reisner if (!rv) 4035b411b363SPhilipp Reisner return 0; 4036b411b363SPhilipp Reisner 403702918be2SPhilipp Reisner if (cmd != P_HAND_SHAKE) { 4038b411b363SPhilipp Reisner dev_err(DEV, "expected HandShake packet, received: %s (0x%04x)\n", 403902918be2SPhilipp Reisner cmdname(cmd), cmd); 4040b411b363SPhilipp Reisner return -1; 4041b411b363SPhilipp Reisner } 4042b411b363SPhilipp Reisner 404302918be2SPhilipp Reisner if (length != expect) { 4044b411b363SPhilipp Reisner dev_err(DEV, "expected HandShake length: %u, received: %u\n", 404502918be2SPhilipp Reisner expect, length); 4046b411b363SPhilipp Reisner return -1; 4047b411b363SPhilipp Reisner } 4048b411b363SPhilipp Reisner 4049b411b363SPhilipp Reisner rv = drbd_recv(mdev, &p->head.payload, expect); 4050b411b363SPhilipp Reisner 4051b411b363SPhilipp Reisner if (rv != expect) { 4052b411b363SPhilipp Reisner dev_err(DEV, "short read receiving handshake packet: l=%u\n", rv); 4053b411b363SPhilipp Reisner return 0; 4054b411b363SPhilipp Reisner } 4055b411b363SPhilipp Reisner 4056b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4057b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4058b411b363SPhilipp Reisner if (p->protocol_max == 0) 4059b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4060b411b363SPhilipp Reisner 4061b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4062b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4063b411b363SPhilipp Reisner goto incompat; 4064b411b363SPhilipp Reisner 4065b411b363SPhilipp Reisner mdev->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4066b411b363SPhilipp Reisner 4067b411b363SPhilipp Reisner dev_info(DEV, "Handshake successful: " 4068b411b363SPhilipp Reisner "Agreed network protocol version %d\n", mdev->agreed_pro_version); 4069b411b363SPhilipp Reisner 4070b411b363SPhilipp Reisner return 1; 4071b411b363SPhilipp Reisner 4072b411b363SPhilipp Reisner incompat: 4073b411b363SPhilipp Reisner dev_err(DEV, "incompatible DRBD dialects: " 4074b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4075b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4076b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4077b411b363SPhilipp Reisner return -1; 4078b411b363SPhilipp Reisner } 4079b411b363SPhilipp Reisner 4080b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 4081b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev) 4082b411b363SPhilipp Reisner { 4083b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4084b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4085b10d96cbSJohannes Thoma return -1; 4086b411b363SPhilipp Reisner } 4087b411b363SPhilipp Reisner #else 4088b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4089b10d96cbSJohannes Thoma 4090b10d96cbSJohannes Thoma /* Return value: 4091b10d96cbSJohannes Thoma 1 - auth succeeded, 4092b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4093b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4094b10d96cbSJohannes Thoma */ 4095b10d96cbSJohannes Thoma 4096b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev) 4097b411b363SPhilipp Reisner { 4098b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4099b411b363SPhilipp Reisner struct scatterlist sg; 4100b411b363SPhilipp Reisner char *response = NULL; 4101b411b363SPhilipp Reisner char *right_response = NULL; 4102b411b363SPhilipp Reisner char *peers_ch = NULL; 4103b411b363SPhilipp Reisner unsigned int key_len = strlen(mdev->net_conf->shared_secret); 4104b411b363SPhilipp Reisner unsigned int resp_size; 4105b411b363SPhilipp Reisner struct hash_desc desc; 410602918be2SPhilipp Reisner enum drbd_packets cmd; 410702918be2SPhilipp Reisner unsigned int length; 4108b411b363SPhilipp Reisner int rv; 4109b411b363SPhilipp Reisner 4110b411b363SPhilipp Reisner desc.tfm = mdev->cram_hmac_tfm; 4111b411b363SPhilipp Reisner desc.flags = 0; 4112b411b363SPhilipp Reisner 4113b411b363SPhilipp Reisner rv = crypto_hash_setkey(mdev->cram_hmac_tfm, 4114b411b363SPhilipp Reisner (u8 *)mdev->net_conf->shared_secret, key_len); 4115b411b363SPhilipp Reisner if (rv) { 4116b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_setkey() failed with %d\n", rv); 4117b10d96cbSJohannes Thoma rv = -1; 4118b411b363SPhilipp Reisner goto fail; 4119b411b363SPhilipp Reisner } 4120b411b363SPhilipp Reisner 4121b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4122b411b363SPhilipp Reisner 4123b411b363SPhilipp Reisner rv = drbd_send_cmd2(mdev, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN); 4124b411b363SPhilipp Reisner if (!rv) 4125b411b363SPhilipp Reisner goto fail; 4126b411b363SPhilipp Reisner 412702918be2SPhilipp Reisner rv = drbd_recv_header(mdev, &cmd, &length); 4128b411b363SPhilipp Reisner if (!rv) 4129b411b363SPhilipp Reisner goto fail; 4130b411b363SPhilipp Reisner 413102918be2SPhilipp Reisner if (cmd != P_AUTH_CHALLENGE) { 4132b411b363SPhilipp Reisner dev_err(DEV, "expected AuthChallenge packet, received: %s (0x%04x)\n", 413302918be2SPhilipp Reisner cmdname(cmd), cmd); 4134b411b363SPhilipp Reisner rv = 0; 4135b411b363SPhilipp Reisner goto fail; 4136b411b363SPhilipp Reisner } 4137b411b363SPhilipp Reisner 413802918be2SPhilipp Reisner if (length > CHALLENGE_LEN * 2) { 4139b411b363SPhilipp Reisner dev_err(DEV, "expected AuthChallenge payload too big.\n"); 4140b10d96cbSJohannes Thoma rv = -1; 4141b411b363SPhilipp Reisner goto fail; 4142b411b363SPhilipp Reisner } 4143b411b363SPhilipp Reisner 414402918be2SPhilipp Reisner peers_ch = kmalloc(length, GFP_NOIO); 4145b411b363SPhilipp Reisner if (peers_ch == NULL) { 4146b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of peers_ch failed\n"); 4147b10d96cbSJohannes Thoma rv = -1; 4148b411b363SPhilipp Reisner goto fail; 4149b411b363SPhilipp Reisner } 4150b411b363SPhilipp Reisner 415102918be2SPhilipp Reisner rv = drbd_recv(mdev, peers_ch, length); 4152b411b363SPhilipp Reisner 415302918be2SPhilipp Reisner if (rv != length) { 4154b411b363SPhilipp Reisner dev_err(DEV, "short read AuthChallenge: l=%u\n", rv); 4155b411b363SPhilipp Reisner rv = 0; 4156b411b363SPhilipp Reisner goto fail; 4157b411b363SPhilipp Reisner } 4158b411b363SPhilipp Reisner 4159b411b363SPhilipp Reisner resp_size = crypto_hash_digestsize(mdev->cram_hmac_tfm); 4160b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4161b411b363SPhilipp Reisner if (response == NULL) { 4162b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of response failed\n"); 4163b10d96cbSJohannes Thoma rv = -1; 4164b411b363SPhilipp Reisner goto fail; 4165b411b363SPhilipp Reisner } 4166b411b363SPhilipp Reisner 4167b411b363SPhilipp Reisner sg_init_table(&sg, 1); 416802918be2SPhilipp Reisner sg_set_buf(&sg, peers_ch, length); 4169b411b363SPhilipp Reisner 4170b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4171b411b363SPhilipp Reisner if (rv) { 4172b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv); 4173b10d96cbSJohannes Thoma rv = -1; 4174b411b363SPhilipp Reisner goto fail; 4175b411b363SPhilipp Reisner } 4176b411b363SPhilipp Reisner 4177b411b363SPhilipp Reisner rv = drbd_send_cmd2(mdev, P_AUTH_RESPONSE, response, resp_size); 4178b411b363SPhilipp Reisner if (!rv) 4179b411b363SPhilipp Reisner goto fail; 4180b411b363SPhilipp Reisner 418102918be2SPhilipp Reisner rv = drbd_recv_header(mdev, &cmd, &length); 4182b411b363SPhilipp Reisner if (!rv) 4183b411b363SPhilipp Reisner goto fail; 4184b411b363SPhilipp Reisner 418502918be2SPhilipp Reisner if (cmd != P_AUTH_RESPONSE) { 4186b411b363SPhilipp Reisner dev_err(DEV, "expected AuthResponse packet, received: %s (0x%04x)\n", 418702918be2SPhilipp Reisner cmdname(cmd), cmd); 4188b411b363SPhilipp Reisner rv = 0; 4189b411b363SPhilipp Reisner goto fail; 4190b411b363SPhilipp Reisner } 4191b411b363SPhilipp Reisner 419202918be2SPhilipp Reisner if (length != resp_size) { 4193b411b363SPhilipp Reisner dev_err(DEV, "expected AuthResponse payload of wrong size\n"); 4194b411b363SPhilipp Reisner rv = 0; 4195b411b363SPhilipp Reisner goto fail; 4196b411b363SPhilipp Reisner } 4197b411b363SPhilipp Reisner 4198b411b363SPhilipp Reisner rv = drbd_recv(mdev, response , resp_size); 4199b411b363SPhilipp Reisner 4200b411b363SPhilipp Reisner if (rv != resp_size) { 4201b411b363SPhilipp Reisner dev_err(DEV, "short read receiving AuthResponse: l=%u\n", rv); 4202b411b363SPhilipp Reisner rv = 0; 4203b411b363SPhilipp Reisner goto fail; 4204b411b363SPhilipp Reisner } 4205b411b363SPhilipp Reisner 4206b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 42072d1ee87dSJulia Lawall if (right_response == NULL) { 4208b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of right_response failed\n"); 4209b10d96cbSJohannes Thoma rv = -1; 4210b411b363SPhilipp Reisner goto fail; 4211b411b363SPhilipp Reisner } 4212b411b363SPhilipp Reisner 4213b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4214b411b363SPhilipp Reisner 4215b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4216b411b363SPhilipp Reisner if (rv) { 4217b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv); 4218b10d96cbSJohannes Thoma rv = -1; 4219b411b363SPhilipp Reisner goto fail; 4220b411b363SPhilipp Reisner } 4221b411b363SPhilipp Reisner 4222b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4223b411b363SPhilipp Reisner 4224b411b363SPhilipp Reisner if (rv) 4225b411b363SPhilipp Reisner dev_info(DEV, "Peer authenticated using %d bytes of '%s' HMAC\n", 4226b411b363SPhilipp Reisner resp_size, mdev->net_conf->cram_hmac_alg); 4227b10d96cbSJohannes Thoma else 4228b10d96cbSJohannes Thoma rv = -1; 4229b411b363SPhilipp Reisner 4230b411b363SPhilipp Reisner fail: 4231b411b363SPhilipp Reisner kfree(peers_ch); 4232b411b363SPhilipp Reisner kfree(response); 4233b411b363SPhilipp Reisner kfree(right_response); 4234b411b363SPhilipp Reisner 4235b411b363SPhilipp Reisner return rv; 4236b411b363SPhilipp Reisner } 4237b411b363SPhilipp Reisner #endif 4238b411b363SPhilipp Reisner 4239b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4240b411b363SPhilipp Reisner { 4241b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 4242b411b363SPhilipp Reisner unsigned int minor = mdev_to_minor(mdev); 4243b411b363SPhilipp Reisner int h; 4244b411b363SPhilipp Reisner 4245b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_receiver", minor); 4246b411b363SPhilipp Reisner 4247b411b363SPhilipp Reisner dev_info(DEV, "receiver (re)started\n"); 4248b411b363SPhilipp Reisner 4249b411b363SPhilipp Reisner do { 4250b411b363SPhilipp Reisner h = drbd_connect(mdev); 4251b411b363SPhilipp Reisner if (h == 0) { 4252b411b363SPhilipp Reisner drbd_disconnect(mdev); 4253b411b363SPhilipp Reisner __set_current_state(TASK_INTERRUPTIBLE); 4254b411b363SPhilipp Reisner schedule_timeout(HZ); 4255b411b363SPhilipp Reisner } 4256b411b363SPhilipp Reisner if (h == -1) { 4257b411b363SPhilipp Reisner dev_warn(DEV, "Discarding network configuration.\n"); 4258b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 4259b411b363SPhilipp Reisner } 4260b411b363SPhilipp Reisner } while (h == 0); 4261b411b363SPhilipp Reisner 4262b411b363SPhilipp Reisner if (h > 0) { 4263b411b363SPhilipp Reisner if (get_net_conf(mdev)) { 4264b411b363SPhilipp Reisner drbdd(mdev); 4265b411b363SPhilipp Reisner put_net_conf(mdev); 4266b411b363SPhilipp Reisner } 4267b411b363SPhilipp Reisner } 4268b411b363SPhilipp Reisner 4269b411b363SPhilipp Reisner drbd_disconnect(mdev); 4270b411b363SPhilipp Reisner 4271b411b363SPhilipp Reisner dev_info(DEV, "receiver terminated\n"); 4272b411b363SPhilipp Reisner return 0; 4273b411b363SPhilipp Reisner } 4274b411b363SPhilipp Reisner 4275b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4276b411b363SPhilipp Reisner 42770b70a13dSPhilipp Reisner static int got_RqSReply(struct drbd_conf *mdev, struct p_header80 *h) 4278b411b363SPhilipp Reisner { 4279b411b363SPhilipp Reisner struct p_req_state_reply *p = (struct p_req_state_reply *)h; 4280b411b363SPhilipp Reisner 4281b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4282b411b363SPhilipp Reisner 4283b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4284b411b363SPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4285b411b363SPhilipp Reisner } else { 4286b411b363SPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4287b411b363SPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4288b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4289b411b363SPhilipp Reisner } 4290b411b363SPhilipp Reisner wake_up(&mdev->state_wait); 4291b411b363SPhilipp Reisner 4292b411b363SPhilipp Reisner return TRUE; 4293b411b363SPhilipp Reisner } 4294b411b363SPhilipp Reisner 42950b70a13dSPhilipp Reisner static int got_Ping(struct drbd_conf *mdev, struct p_header80 *h) 4296b411b363SPhilipp Reisner { 4297b411b363SPhilipp Reisner return drbd_send_ping_ack(mdev); 4298b411b363SPhilipp Reisner 4299b411b363SPhilipp Reisner } 4300b411b363SPhilipp Reisner 43010b70a13dSPhilipp Reisner static int got_PingAck(struct drbd_conf *mdev, struct p_header80 *h) 4302b411b363SPhilipp Reisner { 4303b411b363SPhilipp Reisner /* restore idle timeout */ 4304b411b363SPhilipp Reisner mdev->meta.socket->sk->sk_rcvtimeo = mdev->net_conf->ping_int*HZ; 4305309d1608SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &mdev->flags)) 4306309d1608SPhilipp Reisner wake_up(&mdev->misc_wait); 4307b411b363SPhilipp Reisner 4308b411b363SPhilipp Reisner return TRUE; 4309b411b363SPhilipp Reisner } 4310b411b363SPhilipp Reisner 43110b70a13dSPhilipp Reisner static int got_IsInSync(struct drbd_conf *mdev, struct p_header80 *h) 4312b411b363SPhilipp Reisner { 4313b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4314b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4315b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4316b411b363SPhilipp Reisner 4317b411b363SPhilipp Reisner D_ASSERT(mdev->agreed_pro_version >= 89); 4318b411b363SPhilipp Reisner 4319b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4320b411b363SPhilipp Reisner 43211d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4322b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4323b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4324b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4325b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 43261d53f09eSLars Ellenberg put_ldev(mdev); 43271d53f09eSLars Ellenberg } 4328b411b363SPhilipp Reisner dec_rs_pending(mdev); 4329778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4330b411b363SPhilipp Reisner 4331b411b363SPhilipp Reisner return TRUE; 4332b411b363SPhilipp Reisner } 4333b411b363SPhilipp Reisner 4334b411b363SPhilipp Reisner /* when we receive the ACK for a write request, 4335b411b363SPhilipp Reisner * verify that we actually know about it */ 4336b411b363SPhilipp Reisner static struct drbd_request *_ack_id_to_req(struct drbd_conf *mdev, 4337b411b363SPhilipp Reisner u64 id, sector_t sector) 4338b411b363SPhilipp Reisner { 4339b411b363SPhilipp Reisner struct hlist_head *slot = tl_hash_slot(mdev, sector); 4340b411b363SPhilipp Reisner struct hlist_node *n; 4341b411b363SPhilipp Reisner struct drbd_request *req; 4342b411b363SPhilipp Reisner 4343b411b363SPhilipp Reisner hlist_for_each_entry(req, n, slot, colision) { 4344b411b363SPhilipp Reisner if ((unsigned long)req == (unsigned long)id) { 4345b411b363SPhilipp Reisner if (req->sector != sector) { 4346b411b363SPhilipp Reisner dev_err(DEV, "_ack_id_to_req: found req %p but it has " 4347b411b363SPhilipp Reisner "wrong sector (%llus versus %llus)\n", req, 4348b411b363SPhilipp Reisner (unsigned long long)req->sector, 4349b411b363SPhilipp Reisner (unsigned long long)sector); 4350b411b363SPhilipp Reisner break; 4351b411b363SPhilipp Reisner } 4352b411b363SPhilipp Reisner return req; 4353b411b363SPhilipp Reisner } 4354b411b363SPhilipp Reisner } 4355b411b363SPhilipp Reisner dev_err(DEV, "_ack_id_to_req: failed to find req %p, sector %llus in list\n", 4356b411b363SPhilipp Reisner (void *)(unsigned long)id, (unsigned long long)sector); 4357b411b363SPhilipp Reisner return NULL; 4358b411b363SPhilipp Reisner } 4359b411b363SPhilipp Reisner 4360b411b363SPhilipp Reisner typedef struct drbd_request *(req_validator_fn) 4361b411b363SPhilipp Reisner (struct drbd_conf *mdev, u64 id, sector_t sector); 4362b411b363SPhilipp Reisner 4363b411b363SPhilipp Reisner static int validate_req_change_req_state(struct drbd_conf *mdev, 4364b411b363SPhilipp Reisner u64 id, sector_t sector, req_validator_fn validator, 4365b411b363SPhilipp Reisner const char *func, enum drbd_req_event what) 4366b411b363SPhilipp Reisner { 4367b411b363SPhilipp Reisner struct drbd_request *req; 4368b411b363SPhilipp Reisner struct bio_and_error m; 4369b411b363SPhilipp Reisner 4370b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 4371b411b363SPhilipp Reisner req = validator(mdev, id, sector); 4372b411b363SPhilipp Reisner if (unlikely(!req)) { 4373b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 4374b411b363SPhilipp Reisner dev_err(DEV, "%s: got a corrupt block_id/sector pair\n", func); 4375b411b363SPhilipp Reisner return FALSE; 4376b411b363SPhilipp Reisner } 4377b411b363SPhilipp Reisner __req_mod(req, what, &m); 4378b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 4379b411b363SPhilipp Reisner 4380b411b363SPhilipp Reisner if (m.bio) 4381b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 4382b411b363SPhilipp Reisner return TRUE; 4383b411b363SPhilipp Reisner } 4384b411b363SPhilipp Reisner 43850b70a13dSPhilipp Reisner static int got_BlockAck(struct drbd_conf *mdev, struct p_header80 *h) 4386b411b363SPhilipp Reisner { 4387b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4388b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4389b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4390b411b363SPhilipp Reisner enum drbd_req_event what; 4391b411b363SPhilipp Reisner 4392b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4393b411b363SPhilipp Reisner 4394b411b363SPhilipp Reisner if (is_syncer_block_id(p->block_id)) { 4395b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4396b411b363SPhilipp Reisner dec_rs_pending(mdev); 4397b411b363SPhilipp Reisner return TRUE; 4398b411b363SPhilipp Reisner } 4399b411b363SPhilipp Reisner switch (be16_to_cpu(h->command)) { 4400b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 4401b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 4402b411b363SPhilipp Reisner what = write_acked_by_peer_and_sis; 4403b411b363SPhilipp Reisner break; 4404b411b363SPhilipp Reisner case P_WRITE_ACK: 4405b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 4406b411b363SPhilipp Reisner what = write_acked_by_peer; 4407b411b363SPhilipp Reisner break; 4408b411b363SPhilipp Reisner case P_RECV_ACK: 4409b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_B); 4410b411b363SPhilipp Reisner what = recv_acked_by_peer; 4411b411b363SPhilipp Reisner break; 4412b411b363SPhilipp Reisner case P_DISCARD_ACK: 4413b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 4414b411b363SPhilipp Reisner what = conflict_discarded_by_peer; 4415b411b363SPhilipp Reisner break; 4416b411b363SPhilipp Reisner default: 4417b411b363SPhilipp Reisner D_ASSERT(0); 4418b411b363SPhilipp Reisner return FALSE; 4419b411b363SPhilipp Reisner } 4420b411b363SPhilipp Reisner 4421b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4422b411b363SPhilipp Reisner _ack_id_to_req, __func__ , what); 4423b411b363SPhilipp Reisner } 4424b411b363SPhilipp Reisner 44250b70a13dSPhilipp Reisner static int got_NegAck(struct drbd_conf *mdev, struct p_header80 *h) 4426b411b363SPhilipp Reisner { 4427b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4428b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4429b411b363SPhilipp Reisner 4430b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 4431b411b363SPhilipp Reisner dev_warn(DEV, "Got NegAck packet. Peer is in troubles?\n"); 4432b411b363SPhilipp Reisner 4433b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4434b411b363SPhilipp Reisner 4435b411b363SPhilipp Reisner if (is_syncer_block_id(p->block_id)) { 4436b411b363SPhilipp Reisner int size = be32_to_cpu(p->blksize); 4437b411b363SPhilipp Reisner dec_rs_pending(mdev); 4438b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4439b411b363SPhilipp Reisner return TRUE; 4440b411b363SPhilipp Reisner } 4441b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4442b411b363SPhilipp Reisner _ack_id_to_req, __func__ , neg_acked); 4443b411b363SPhilipp Reisner } 4444b411b363SPhilipp Reisner 44450b70a13dSPhilipp Reisner static int got_NegDReply(struct drbd_conf *mdev, struct p_header80 *h) 4446b411b363SPhilipp Reisner { 4447b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4448b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4449b411b363SPhilipp Reisner 4450b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4451b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4452b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4453b411b363SPhilipp Reisner 4454b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4455b411b363SPhilipp Reisner _ar_id_to_req, __func__ , neg_acked); 4456b411b363SPhilipp Reisner } 4457b411b363SPhilipp Reisner 44580b70a13dSPhilipp Reisner static int got_NegRSDReply(struct drbd_conf *mdev, struct p_header80 *h) 4459b411b363SPhilipp Reisner { 4460b411b363SPhilipp Reisner sector_t sector; 4461b411b363SPhilipp Reisner int size; 4462b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4463b411b363SPhilipp Reisner 4464b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4465b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4466b411b363SPhilipp Reisner 4467b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4468b411b363SPhilipp Reisner 4469b411b363SPhilipp Reisner dec_rs_pending(mdev); 4470b411b363SPhilipp Reisner 4471b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4472b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4473b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4474b411b363SPhilipp Reisner put_ldev(mdev); 4475b411b363SPhilipp Reisner } 4476b411b363SPhilipp Reisner 4477b411b363SPhilipp Reisner return TRUE; 4478b411b363SPhilipp Reisner } 4479b411b363SPhilipp Reisner 44800b70a13dSPhilipp Reisner static int got_BarrierAck(struct drbd_conf *mdev, struct p_header80 *h) 4481b411b363SPhilipp Reisner { 4482b411b363SPhilipp Reisner struct p_barrier_ack *p = (struct p_barrier_ack *)h; 4483b411b363SPhilipp Reisner 4484b411b363SPhilipp Reisner tl_release(mdev, p->barrier, be32_to_cpu(p->set_size)); 4485b411b363SPhilipp Reisner 4486b411b363SPhilipp Reisner return TRUE; 4487b411b363SPhilipp Reisner } 4488b411b363SPhilipp Reisner 44890b70a13dSPhilipp Reisner static int got_OVResult(struct drbd_conf *mdev, struct p_header80 *h) 4490b411b363SPhilipp Reisner { 4491b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4492b411b363SPhilipp Reisner struct drbd_work *w; 4493b411b363SPhilipp Reisner sector_t sector; 4494b411b363SPhilipp Reisner int size; 4495b411b363SPhilipp Reisner 4496b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4497b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4498b411b363SPhilipp Reisner 4499b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4500b411b363SPhilipp Reisner 4501b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 4502b411b363SPhilipp Reisner drbd_ov_oos_found(mdev, sector, size); 4503b411b363SPhilipp Reisner else 4504b411b363SPhilipp Reisner ov_oos_print(mdev); 4505b411b363SPhilipp Reisner 45061d53f09eSLars Ellenberg if (!get_ldev(mdev)) 45071d53f09eSLars Ellenberg return TRUE; 45081d53f09eSLars Ellenberg 4509b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4510b411b363SPhilipp Reisner dec_rs_pending(mdev); 4511b411b363SPhilipp Reisner 4512b411b363SPhilipp Reisner if (--mdev->ov_left == 0) { 4513b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4514b411b363SPhilipp Reisner if (w) { 4515b411b363SPhilipp Reisner w->cb = w_ov_finished; 4516b411b363SPhilipp Reisner drbd_queue_work_front(&mdev->data.work, w); 4517b411b363SPhilipp Reisner } else { 4518b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 4519b411b363SPhilipp Reisner ov_oos_print(mdev); 4520b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4521b411b363SPhilipp Reisner } 4522b411b363SPhilipp Reisner } 45231d53f09eSLars Ellenberg put_ldev(mdev); 4524b411b363SPhilipp Reisner return TRUE; 4525b411b363SPhilipp Reisner } 4526b411b363SPhilipp Reisner 452702918be2SPhilipp Reisner static int got_skip(struct drbd_conf *mdev, struct p_header80 *h) 45280ced55a3SPhilipp Reisner { 45290ced55a3SPhilipp Reisner return TRUE; 45300ced55a3SPhilipp Reisner } 45310ced55a3SPhilipp Reisner 4532b411b363SPhilipp Reisner struct asender_cmd { 4533b411b363SPhilipp Reisner size_t pkt_size; 45340b70a13dSPhilipp Reisner int (*process)(struct drbd_conf *mdev, struct p_header80 *h); 4535b411b363SPhilipp Reisner }; 4536b411b363SPhilipp Reisner 4537b411b363SPhilipp Reisner static struct asender_cmd *get_asender_cmd(int cmd) 4538b411b363SPhilipp Reisner { 4539b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 4540b411b363SPhilipp Reisner /* anything missing from this table is in 4541b411b363SPhilipp Reisner * the drbd_cmd_handler (drbd_default_handler) table, 4542b411b363SPhilipp Reisner * see the beginning of drbdd() */ 45430b70a13dSPhilipp Reisner [P_PING] = { sizeof(struct p_header80), got_Ping }, 45440b70a13dSPhilipp Reisner [P_PING_ACK] = { sizeof(struct p_header80), got_PingAck }, 4545b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4546b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4547b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4548b411b363SPhilipp Reisner [P_DISCARD_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4549b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 4550b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 4551b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply}, 4552b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 4553b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 4554b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 4555b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 455602918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 4557b411b363SPhilipp Reisner [P_MAX_CMD] = { 0, NULL }, 4558b411b363SPhilipp Reisner }; 4559b411b363SPhilipp Reisner if (cmd > P_MAX_CMD || asender_tbl[cmd].process == NULL) 4560b411b363SPhilipp Reisner return NULL; 4561b411b363SPhilipp Reisner return &asender_tbl[cmd]; 4562b411b363SPhilipp Reisner } 4563b411b363SPhilipp Reisner 4564b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4565b411b363SPhilipp Reisner { 4566b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 456702918be2SPhilipp Reisner struct p_header80 *h = &mdev->meta.rbuf.header.h80; 4568b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 4569b411b363SPhilipp Reisner 4570b411b363SPhilipp Reisner int rv, len; 4571b411b363SPhilipp Reisner void *buf = h; 4572b411b363SPhilipp Reisner int received = 0; 45730b70a13dSPhilipp Reisner int expect = sizeof(struct p_header80); 4574b411b363SPhilipp Reisner int empty; 4575b411b363SPhilipp Reisner 4576b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_asender", mdev_to_minor(mdev)); 4577b411b363SPhilipp Reisner 4578b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4579b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4580b411b363SPhilipp Reisner 4581b411b363SPhilipp Reisner while (get_t_state(thi) == Running) { 4582b411b363SPhilipp Reisner drbd_thread_current_set_cpu(mdev); 4583b411b363SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &mdev->flags)) { 4584b411b363SPhilipp Reisner ERR_IF(!drbd_send_ping(mdev)) goto reconnect; 4585b411b363SPhilipp Reisner mdev->meta.socket->sk->sk_rcvtimeo = 4586b411b363SPhilipp Reisner mdev->net_conf->ping_timeo*HZ/10; 4587b411b363SPhilipp Reisner } 4588b411b363SPhilipp Reisner 4589b411b363SPhilipp Reisner /* conditionally cork; 4590b411b363SPhilipp Reisner * it may hurt latency if we cork without much to send */ 4591b411b363SPhilipp Reisner if (!mdev->net_conf->no_cork && 4592b411b363SPhilipp Reisner 3 < atomic_read(&mdev->unacked_cnt)) 4593b411b363SPhilipp Reisner drbd_tcp_cork(mdev->meta.socket); 4594b411b363SPhilipp Reisner while (1) { 4595b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4596b411b363SPhilipp Reisner flush_signals(current); 45970f8488e1SLars Ellenberg if (!drbd_process_done_ee(mdev)) 4598b411b363SPhilipp Reisner goto reconnect; 4599b411b363SPhilipp Reisner /* to avoid race with newly queued ACKs */ 4600b411b363SPhilipp Reisner set_bit(SIGNAL_ASENDER, &mdev->flags); 4601b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 4602b411b363SPhilipp Reisner empty = list_empty(&mdev->done_ee); 4603b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 4604b411b363SPhilipp Reisner /* new ack may have been queued right here, 4605b411b363SPhilipp Reisner * but then there is also a signal pending, 4606b411b363SPhilipp Reisner * and we start over... */ 4607b411b363SPhilipp Reisner if (empty) 4608b411b363SPhilipp Reisner break; 4609b411b363SPhilipp Reisner } 4610b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 4611b411b363SPhilipp Reisner if (!mdev->net_conf->no_cork) 4612b411b363SPhilipp Reisner drbd_tcp_uncork(mdev->meta.socket); 4613b411b363SPhilipp Reisner 4614b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4615b411b363SPhilipp Reisner if (signal_pending(current)) 4616b411b363SPhilipp Reisner continue; 4617b411b363SPhilipp Reisner 4618b411b363SPhilipp Reisner rv = drbd_recv_short(mdev, mdev->meta.socket, 4619b411b363SPhilipp Reisner buf, expect-received, 0); 4620b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4621b411b363SPhilipp Reisner 4622b411b363SPhilipp Reisner flush_signals(current); 4623b411b363SPhilipp Reisner 4624b411b363SPhilipp Reisner /* Note: 4625b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4626b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4627b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4628b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4629b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4630b411b363SPhilipp Reisner * rv == expected: full header or command 4631b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4632b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4633b411b363SPhilipp Reisner */ 4634b411b363SPhilipp Reisner if (likely(rv > 0)) { 4635b411b363SPhilipp Reisner received += rv; 4636b411b363SPhilipp Reisner buf += rv; 4637b411b363SPhilipp Reisner } else if (rv == 0) { 4638b411b363SPhilipp Reisner dev_err(DEV, "meta connection shut down by peer.\n"); 4639b411b363SPhilipp Reisner goto reconnect; 4640b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4641b411b363SPhilipp Reisner if (mdev->meta.socket->sk->sk_rcvtimeo == 4642b411b363SPhilipp Reisner mdev->net_conf->ping_timeo*HZ/10) { 4643b411b363SPhilipp Reisner dev_err(DEV, "PingAck did not arrive in time.\n"); 4644b411b363SPhilipp Reisner goto reconnect; 4645b411b363SPhilipp Reisner } 4646b411b363SPhilipp Reisner set_bit(SEND_PING, &mdev->flags); 4647b411b363SPhilipp Reisner continue; 4648b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4649b411b363SPhilipp Reisner continue; 4650b411b363SPhilipp Reisner } else { 4651b411b363SPhilipp Reisner dev_err(DEV, "sock_recvmsg returned %d\n", rv); 4652b411b363SPhilipp Reisner goto reconnect; 4653b411b363SPhilipp Reisner } 4654b411b363SPhilipp Reisner 4655b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 4656b411b363SPhilipp Reisner if (unlikely(h->magic != BE_DRBD_MAGIC)) { 4657004352faSLars Ellenberg dev_err(DEV, "magic?? on meta m: 0x%08x c: %d l: %d\n", 4658004352faSLars Ellenberg be32_to_cpu(h->magic), 4659004352faSLars Ellenberg be16_to_cpu(h->command), 4660004352faSLars Ellenberg be16_to_cpu(h->length)); 4661b411b363SPhilipp Reisner goto reconnect; 4662b411b363SPhilipp Reisner } 4663b411b363SPhilipp Reisner cmd = get_asender_cmd(be16_to_cpu(h->command)); 4664b411b363SPhilipp Reisner len = be16_to_cpu(h->length); 4665b411b363SPhilipp Reisner if (unlikely(cmd == NULL)) { 4666004352faSLars Ellenberg dev_err(DEV, "unknown command?? on meta m: 0x%08x c: %d l: %d\n", 4667004352faSLars Ellenberg be32_to_cpu(h->magic), 4668004352faSLars Ellenberg be16_to_cpu(h->command), 4669004352faSLars Ellenberg be16_to_cpu(h->length)); 4670b411b363SPhilipp Reisner goto disconnect; 4671b411b363SPhilipp Reisner } 4672b411b363SPhilipp Reisner expect = cmd->pkt_size; 46730b70a13dSPhilipp Reisner ERR_IF(len != expect-sizeof(struct p_header80)) 4674b411b363SPhilipp Reisner goto reconnect; 4675b411b363SPhilipp Reisner } 4676b411b363SPhilipp Reisner if (received == expect) { 4677b411b363SPhilipp Reisner D_ASSERT(cmd != NULL); 4678b411b363SPhilipp Reisner if (!cmd->process(mdev, h)) 4679b411b363SPhilipp Reisner goto reconnect; 4680b411b363SPhilipp Reisner 4681b411b363SPhilipp Reisner buf = h; 4682b411b363SPhilipp Reisner received = 0; 46830b70a13dSPhilipp Reisner expect = sizeof(struct p_header80); 4684b411b363SPhilipp Reisner cmd = NULL; 4685b411b363SPhilipp Reisner } 4686b411b363SPhilipp Reisner } 4687b411b363SPhilipp Reisner 4688b411b363SPhilipp Reisner if (0) { 4689b411b363SPhilipp Reisner reconnect: 4690b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_NETWORK_FAILURE)); 4691856c50c7SLars Ellenberg drbd_md_sync(mdev); 4692b411b363SPhilipp Reisner } 4693b411b363SPhilipp Reisner if (0) { 4694b411b363SPhilipp Reisner disconnect: 4695b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 4696856c50c7SLars Ellenberg drbd_md_sync(mdev); 4697b411b363SPhilipp Reisner } 4698b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4699b411b363SPhilipp Reisner 4700b411b363SPhilipp Reisner D_ASSERT(mdev->state.conn < C_CONNECTED); 4701b411b363SPhilipp Reisner dev_info(DEV, "asender terminated\n"); 4702b411b363SPhilipp Reisner 4703b411b363SPhilipp Reisner return 0; 4704b411b363SPhilipp Reisner } 4705