1b411b363SPhilipp Reisner /* 2b411b363SPhilipp Reisner drbd_receiver.c 3b411b363SPhilipp Reisner 4b411b363SPhilipp Reisner This file is part of DRBD by Philipp Reisner and Lars Ellenberg. 5b411b363SPhilipp Reisner 6b411b363SPhilipp Reisner Copyright (C) 2001-2008, LINBIT Information Technologies GmbH. 7b411b363SPhilipp Reisner Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>. 8b411b363SPhilipp Reisner Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>. 9b411b363SPhilipp Reisner 10b411b363SPhilipp Reisner drbd is free software; you can redistribute it and/or modify 11b411b363SPhilipp Reisner it under the terms of the GNU General Public License as published by 12b411b363SPhilipp Reisner the Free Software Foundation; either version 2, or (at your option) 13b411b363SPhilipp Reisner any later version. 14b411b363SPhilipp Reisner 15b411b363SPhilipp Reisner drbd is distributed in the hope that it will be useful, 16b411b363SPhilipp Reisner but WITHOUT ANY WARRANTY; without even the implied warranty of 17b411b363SPhilipp Reisner MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18b411b363SPhilipp Reisner GNU General Public License for more details. 19b411b363SPhilipp Reisner 20b411b363SPhilipp Reisner You should have received a copy of the GNU General Public License 21b411b363SPhilipp Reisner along with drbd; see the file COPYING. If not, write to 22b411b363SPhilipp Reisner the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 23b411b363SPhilipp Reisner */ 24b411b363SPhilipp Reisner 25b411b363SPhilipp Reisner 26b411b363SPhilipp Reisner #include <linux/module.h> 27b411b363SPhilipp Reisner 28b411b363SPhilipp Reisner #include <asm/uaccess.h> 29b411b363SPhilipp Reisner #include <net/sock.h> 30b411b363SPhilipp Reisner 31b411b363SPhilipp Reisner #include <linux/drbd.h> 32b411b363SPhilipp Reisner #include <linux/fs.h> 33b411b363SPhilipp Reisner #include <linux/file.h> 34b411b363SPhilipp Reisner #include <linux/in.h> 35b411b363SPhilipp Reisner #include <linux/mm.h> 36b411b363SPhilipp Reisner #include <linux/memcontrol.h> 37b411b363SPhilipp Reisner #include <linux/mm_inline.h> 38b411b363SPhilipp Reisner #include <linux/slab.h> 39b411b363SPhilipp Reisner #include <linux/pkt_sched.h> 40b411b363SPhilipp Reisner #define __KERNEL_SYSCALLS__ 41b411b363SPhilipp Reisner #include <linux/unistd.h> 42b411b363SPhilipp Reisner #include <linux/vmalloc.h> 43b411b363SPhilipp Reisner #include <linux/random.h> 44b411b363SPhilipp Reisner #include <linux/string.h> 45b411b363SPhilipp Reisner #include <linux/scatterlist.h> 46b411b363SPhilipp Reisner #include "drbd_int.h" 47b411b363SPhilipp Reisner #include "drbd_req.h" 48b411b363SPhilipp Reisner 49b411b363SPhilipp Reisner #include "drbd_vli.h" 50b411b363SPhilipp Reisner 5177351055SPhilipp Reisner struct packet_info { 5277351055SPhilipp Reisner enum drbd_packet cmd; 5377351055SPhilipp Reisner int size; 5477351055SPhilipp Reisner int vnr; 5577351055SPhilipp Reisner }; 5677351055SPhilipp Reisner 57b411b363SPhilipp Reisner enum finish_epoch { 58b411b363SPhilipp Reisner FE_STILL_LIVE, 59b411b363SPhilipp Reisner FE_DESTROYED, 60b411b363SPhilipp Reisner FE_RECYCLED, 61b411b363SPhilipp Reisner }; 62b411b363SPhilipp Reisner 6365d11ed6SPhilipp Reisner static int drbd_do_handshake(struct drbd_tconn *tconn); 6413e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn); 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 70b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 71b411b363SPhilipp Reisner 7245bb912bSLars Ellenberg /* 7345bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 7445bb912bSLars Ellenberg * page->private being our "next" pointer. 7545bb912bSLars Ellenberg */ 7645bb912bSLars Ellenberg 7745bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 7845bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 7945bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8045bb912bSLars Ellenberg */ 8145bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8245bb912bSLars Ellenberg { 8345bb912bSLars Ellenberg struct page *page; 8445bb912bSLars Ellenberg struct page *tmp; 8545bb912bSLars Ellenberg 8645bb912bSLars Ellenberg BUG_ON(!n); 8745bb912bSLars Ellenberg BUG_ON(!head); 8845bb912bSLars Ellenberg 8945bb912bSLars Ellenberg page = *head; 9023ce4227SPhilipp Reisner 9123ce4227SPhilipp Reisner if (!page) 9223ce4227SPhilipp Reisner return NULL; 9323ce4227SPhilipp Reisner 9445bb912bSLars Ellenberg while (page) { 9545bb912bSLars Ellenberg tmp = page_chain_next(page); 9645bb912bSLars Ellenberg if (--n == 0) 9745bb912bSLars Ellenberg break; /* found sufficient pages */ 9845bb912bSLars Ellenberg if (tmp == NULL) 9945bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10045bb912bSLars Ellenberg return NULL; 10145bb912bSLars Ellenberg page = tmp; 10245bb912bSLars Ellenberg } 10345bb912bSLars Ellenberg 10445bb912bSLars Ellenberg /* add end of list marker for the returned list */ 10545bb912bSLars Ellenberg set_page_private(page, 0); 10645bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 10745bb912bSLars Ellenberg page = *head; 10845bb912bSLars Ellenberg *head = tmp; 10945bb912bSLars Ellenberg return page; 11045bb912bSLars Ellenberg } 11145bb912bSLars Ellenberg 11245bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11345bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 11445bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 11545bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 11645bb912bSLars Ellenberg { 11745bb912bSLars Ellenberg struct page *tmp; 11845bb912bSLars Ellenberg int i = 1; 11945bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12045bb912bSLars Ellenberg ++i, page = tmp; 12145bb912bSLars Ellenberg if (len) 12245bb912bSLars Ellenberg *len = i; 12345bb912bSLars Ellenberg return page; 12445bb912bSLars Ellenberg } 12545bb912bSLars Ellenberg 12645bb912bSLars Ellenberg static int page_chain_free(struct page *page) 12745bb912bSLars Ellenberg { 12845bb912bSLars Ellenberg struct page *tmp; 12945bb912bSLars Ellenberg int i = 0; 13045bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13145bb912bSLars Ellenberg put_page(page); 13245bb912bSLars Ellenberg ++i; 13345bb912bSLars Ellenberg } 13445bb912bSLars Ellenberg return i; 13545bb912bSLars Ellenberg } 13645bb912bSLars Ellenberg 13745bb912bSLars Ellenberg static void page_chain_add(struct page **head, 13845bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 13945bb912bSLars Ellenberg { 14045bb912bSLars Ellenberg #if 1 14145bb912bSLars Ellenberg struct page *tmp; 14245bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14345bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 14445bb912bSLars Ellenberg #endif 14545bb912bSLars Ellenberg 14645bb912bSLars Ellenberg /* add chain to head */ 14745bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 14845bb912bSLars Ellenberg *head = chain_first; 14945bb912bSLars Ellenberg } 15045bb912bSLars Ellenberg 15145bb912bSLars Ellenberg static struct page *drbd_pp_first_pages_or_try_alloc(struct drbd_conf *mdev, int number) 152b411b363SPhilipp Reisner { 153b411b363SPhilipp Reisner struct page *page = NULL; 15445bb912bSLars Ellenberg struct page *tmp = NULL; 15545bb912bSLars Ellenberg int i = 0; 156b411b363SPhilipp Reisner 157b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 158b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 15945bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 160b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16145bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16245bb912bSLars Ellenberg if (page) 16345bb912bSLars Ellenberg drbd_pp_vacant -= number; 164b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 16545bb912bSLars Ellenberg if (page) 16645bb912bSLars Ellenberg return page; 167b411b363SPhilipp Reisner } 16845bb912bSLars Ellenberg 169b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 170b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 171b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17245bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17345bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 17445bb912bSLars Ellenberg if (!tmp) 17545bb912bSLars Ellenberg break; 17645bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 17745bb912bSLars Ellenberg page = tmp; 17845bb912bSLars Ellenberg } 17945bb912bSLars Ellenberg 18045bb912bSLars Ellenberg if (i == number) 181b411b363SPhilipp Reisner return page; 18245bb912bSLars Ellenberg 18345bb912bSLars Ellenberg /* Not enough pages immediately available this time. 18445bb912bSLars Ellenberg * No need to jump around here, drbd_pp_alloc will retry this 18545bb912bSLars Ellenberg * function "soon". */ 18645bb912bSLars Ellenberg if (page) { 18745bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 18845bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 18945bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19045bb912bSLars Ellenberg drbd_pp_vacant += i; 19145bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19245bb912bSLars Ellenberg } 19345bb912bSLars Ellenberg return NULL; 194b411b363SPhilipp Reisner } 195b411b363SPhilipp Reisner 196b411b363SPhilipp Reisner static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed) 197b411b363SPhilipp Reisner { 198db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 199b411b363SPhilipp Reisner struct list_head *le, *tle; 200b411b363SPhilipp Reisner 201b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 202b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 203b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 204b411b363SPhilipp Reisner stop to examine the list... */ 205b411b363SPhilipp Reisner 206b411b363SPhilipp Reisner list_for_each_safe(le, tle, &mdev->net_ee) { 207db830c46SAndreas Gruenbacher peer_req = list_entry(le, struct drbd_peer_request, w.list); 208db830c46SAndreas Gruenbacher if (drbd_ee_has_active_page(peer_req)) 209b411b363SPhilipp Reisner break; 210b411b363SPhilipp Reisner list_move(le, to_be_freed); 211b411b363SPhilipp Reisner } 212b411b363SPhilipp Reisner } 213b411b363SPhilipp Reisner 214b411b363SPhilipp Reisner static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev) 215b411b363SPhilipp Reisner { 216b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 217db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 218b411b363SPhilipp Reisner 21987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 220b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 22187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 222b411b363SPhilipp Reisner 223db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 224db830c46SAndreas Gruenbacher drbd_free_net_ee(mdev, peer_req); 225b411b363SPhilipp Reisner } 226b411b363SPhilipp Reisner 227b411b363SPhilipp Reisner /** 22845bb912bSLars Ellenberg * drbd_pp_alloc() - Returns @number pages, retries forever (or until signalled) 229b411b363SPhilipp Reisner * @mdev: DRBD device. 23045bb912bSLars Ellenberg * @number: number of pages requested 23145bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 232b411b363SPhilipp Reisner * 23345bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 23445bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 23545bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 23645bb912bSLars Ellenberg * 23745bb912bSLars Ellenberg * Returns a page chain linked via page->private. 238b411b363SPhilipp Reisner */ 23945bb912bSLars Ellenberg static struct page *drbd_pp_alloc(struct drbd_conf *mdev, unsigned number, bool retry) 240b411b363SPhilipp Reisner { 241b411b363SPhilipp Reisner struct page *page = NULL; 242b411b363SPhilipp Reisner DEFINE_WAIT(wait); 243b411b363SPhilipp Reisner 24445bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 24545bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 24689e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) 24745bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 248b411b363SPhilipp Reisner 24945bb912bSLars Ellenberg while (page == NULL) { 250b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 251b411b363SPhilipp Reisner 252b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 253b411b363SPhilipp Reisner 25489e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) { 25545bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 256b411b363SPhilipp Reisner if (page) 257b411b363SPhilipp Reisner break; 258b411b363SPhilipp Reisner } 259b411b363SPhilipp Reisner 260b411b363SPhilipp Reisner if (!retry) 261b411b363SPhilipp Reisner break; 262b411b363SPhilipp Reisner 263b411b363SPhilipp Reisner if (signal_pending(current)) { 264b411b363SPhilipp Reisner dev_warn(DEV, "drbd_pp_alloc interrupted!\n"); 265b411b363SPhilipp Reisner break; 266b411b363SPhilipp Reisner } 267b411b363SPhilipp Reisner 268b411b363SPhilipp Reisner schedule(); 269b411b363SPhilipp Reisner } 270b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 271b411b363SPhilipp Reisner 27245bb912bSLars Ellenberg if (page) 27345bb912bSLars Ellenberg atomic_add(number, &mdev->pp_in_use); 274b411b363SPhilipp Reisner return page; 275b411b363SPhilipp Reisner } 276b411b363SPhilipp Reisner 277b411b363SPhilipp Reisner /* Must not be used from irq, as that may deadlock: see drbd_pp_alloc. 27887eeee41SPhilipp Reisner * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock); 27945bb912bSLars Ellenberg * Either links the page chain back to the global pool, 28045bb912bSLars Ellenberg * or returns all pages to the system. */ 281435f0740SLars Ellenberg static void drbd_pp_free(struct drbd_conf *mdev, struct page *page, int is_net) 282b411b363SPhilipp Reisner { 283435f0740SLars Ellenberg atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use; 284b411b363SPhilipp Reisner int i; 285435f0740SLars Ellenberg 2861816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE)*minor_count) 28745bb912bSLars Ellenberg i = page_chain_free(page); 28845bb912bSLars Ellenberg else { 28945bb912bSLars Ellenberg struct page *tmp; 29045bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 291b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 29245bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 29345bb912bSLars Ellenberg drbd_pp_vacant += i; 294b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 295b411b363SPhilipp Reisner } 296435f0740SLars Ellenberg i = atomic_sub_return(i, a); 29745bb912bSLars Ellenberg if (i < 0) 298435f0740SLars Ellenberg dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n", 299435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 300b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 301b411b363SPhilipp Reisner } 302b411b363SPhilipp Reisner 303b411b363SPhilipp Reisner /* 304b411b363SPhilipp Reisner You need to hold the req_lock: 305b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 306b411b363SPhilipp Reisner 307b411b363SPhilipp Reisner You must not have the req_lock: 308b411b363SPhilipp Reisner drbd_free_ee() 309b411b363SPhilipp Reisner drbd_alloc_ee() 310b411b363SPhilipp Reisner drbd_init_ee() 311b411b363SPhilipp Reisner drbd_release_ee() 312b411b363SPhilipp Reisner drbd_ee_fix_bhs() 313b411b363SPhilipp Reisner drbd_process_done_ee() 314b411b363SPhilipp Reisner drbd_clear_done_ee() 315b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 316b411b363SPhilipp Reisner */ 317b411b363SPhilipp Reisner 318f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 319f6ffca9fSAndreas Gruenbacher drbd_alloc_ee(struct drbd_conf *mdev, u64 id, sector_t sector, 320f6ffca9fSAndreas Gruenbacher unsigned int data_size, gfp_t gfp_mask) __must_hold(local) 321b411b363SPhilipp Reisner { 322db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 323b411b363SPhilipp Reisner struct page *page; 32445bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 325b411b363SPhilipp Reisner 3260cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE)) 327b411b363SPhilipp Reisner return NULL; 328b411b363SPhilipp Reisner 329db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 330db830c46SAndreas Gruenbacher if (!peer_req) { 331b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 332b411b363SPhilipp Reisner dev_err(DEV, "alloc_ee: Allocation of an EE failed\n"); 333b411b363SPhilipp Reisner return NULL; 334b411b363SPhilipp Reisner } 335b411b363SPhilipp Reisner 33645bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT)); 33745bb912bSLars Ellenberg if (!page) 33845bb912bSLars Ellenberg goto fail; 339b411b363SPhilipp Reisner 340db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 341db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 342db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 343db830c46SAndreas Gruenbacher peer_req->i.local = false; 344db830c46SAndreas Gruenbacher peer_req->i.waiting = false; 34553840641SAndreas Gruenbacher 346db830c46SAndreas Gruenbacher peer_req->epoch = NULL; 347db830c46SAndreas Gruenbacher peer_req->mdev = mdev; 348db830c46SAndreas Gruenbacher peer_req->pages = page; 349db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, 0); 350db830c46SAndreas Gruenbacher peer_req->flags = 0; 3519a8e7753SAndreas Gruenbacher /* 3529a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3539a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3549a8e7753SAndreas Gruenbacher */ 355db830c46SAndreas Gruenbacher peer_req->block_id = id; 356b411b363SPhilipp Reisner 357db830c46SAndreas Gruenbacher return peer_req; 358b411b363SPhilipp Reisner 35945bb912bSLars Ellenberg fail: 360db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 361b411b363SPhilipp Reisner return NULL; 362b411b363SPhilipp Reisner } 363b411b363SPhilipp Reisner 364db830c46SAndreas Gruenbacher void drbd_free_some_ee(struct drbd_conf *mdev, struct drbd_peer_request *peer_req, 365f6ffca9fSAndreas Gruenbacher int is_net) 366b411b363SPhilipp Reisner { 367db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 368db830c46SAndreas Gruenbacher kfree(peer_req->digest); 369db830c46SAndreas Gruenbacher drbd_pp_free(mdev, peer_req->pages, is_net); 370db830c46SAndreas Gruenbacher D_ASSERT(atomic_read(&peer_req->pending_bios) == 0); 371db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 372db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 373b411b363SPhilipp Reisner } 374b411b363SPhilipp Reisner 375b411b363SPhilipp Reisner int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list) 376b411b363SPhilipp Reisner { 377b411b363SPhilipp Reisner LIST_HEAD(work_list); 378db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 379b411b363SPhilipp Reisner int count = 0; 380435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 381b411b363SPhilipp Reisner 38287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 383b411b363SPhilipp Reisner list_splice_init(list, &work_list); 38487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 385b411b363SPhilipp Reisner 386db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 387db830c46SAndreas Gruenbacher drbd_free_some_ee(mdev, peer_req, is_net); 388b411b363SPhilipp Reisner count++; 389b411b363SPhilipp Reisner } 390b411b363SPhilipp Reisner return count; 391b411b363SPhilipp Reisner } 392b411b363SPhilipp Reisner 393b411b363SPhilipp Reisner 394b411b363SPhilipp Reisner /* 395b411b363SPhilipp Reisner * This function is called from _asender only_ 3968554df1cSAndreas Gruenbacher * but see also comments in _req_mod(,BARRIER_ACKED) 397b411b363SPhilipp Reisner * and receive_Barrier. 398b411b363SPhilipp Reisner * 399b411b363SPhilipp Reisner * Move entries from net_ee to done_ee, if ready. 400b411b363SPhilipp Reisner * Grab done_ee, call all callbacks, free the entries. 401b411b363SPhilipp Reisner * The callbacks typically send out ACKs. 402b411b363SPhilipp Reisner */ 403b411b363SPhilipp Reisner static int drbd_process_done_ee(struct drbd_conf *mdev) 404b411b363SPhilipp Reisner { 405b411b363SPhilipp Reisner LIST_HEAD(work_list); 406b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 407db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 408b411b363SPhilipp Reisner int ok = (mdev->state.conn >= C_WF_REPORT_PARAMS); 409b411b363SPhilipp Reisner 41087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 411b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 412b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 41387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 414b411b363SPhilipp Reisner 415db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 416db830c46SAndreas Gruenbacher drbd_free_net_ee(mdev, peer_req); 417b411b363SPhilipp Reisner 418b411b363SPhilipp Reisner /* possible callbacks here: 419b411b363SPhilipp Reisner * e_end_block, and e_end_resync_block, e_send_discard_ack. 420b411b363SPhilipp Reisner * all ignore the last argument. 421b411b363SPhilipp Reisner */ 422db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 423b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 424db830c46SAndreas Gruenbacher ok = peer_req->w.cb(mdev, &peer_req->w, !ok) && ok; 425db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 426b411b363SPhilipp Reisner } 427b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 428b411b363SPhilipp Reisner 429b411b363SPhilipp Reisner return ok; 430b411b363SPhilipp Reisner } 431b411b363SPhilipp Reisner 432b411b363SPhilipp Reisner void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 433b411b363SPhilipp Reisner { 434b411b363SPhilipp Reisner DEFINE_WAIT(wait); 435b411b363SPhilipp Reisner 436b411b363SPhilipp Reisner /* avoids spin_lock/unlock 437b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 438b411b363SPhilipp Reisner while (!list_empty(head)) { 439b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 44087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4417eaceaccSJens Axboe io_schedule(); 442b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 44387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 444b411b363SPhilipp Reisner } 445b411b363SPhilipp Reisner } 446b411b363SPhilipp Reisner 447b411b363SPhilipp Reisner void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 448b411b363SPhilipp Reisner { 44987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 450b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 45187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 452b411b363SPhilipp Reisner } 453b411b363SPhilipp Reisner 454b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 455b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 4567653620dSPhilipp Reisner static int drbd_accept(const char **what, struct socket *sock, struct socket **newsock) 457b411b363SPhilipp Reisner { 458b411b363SPhilipp Reisner struct sock *sk = sock->sk; 459b411b363SPhilipp Reisner int err = 0; 460b411b363SPhilipp Reisner 461b411b363SPhilipp Reisner *what = "listen"; 462b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 463b411b363SPhilipp Reisner if (err < 0) 464b411b363SPhilipp Reisner goto out; 465b411b363SPhilipp Reisner 466b411b363SPhilipp Reisner *what = "sock_create_lite"; 467b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 468b411b363SPhilipp Reisner newsock); 469b411b363SPhilipp Reisner if (err < 0) 470b411b363SPhilipp Reisner goto out; 471b411b363SPhilipp Reisner 472b411b363SPhilipp Reisner *what = "accept"; 473b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 474b411b363SPhilipp Reisner if (err < 0) { 475b411b363SPhilipp Reisner sock_release(*newsock); 476b411b363SPhilipp Reisner *newsock = NULL; 477b411b363SPhilipp Reisner goto out; 478b411b363SPhilipp Reisner } 479b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 480b411b363SPhilipp Reisner 481b411b363SPhilipp Reisner out: 482b411b363SPhilipp Reisner return err; 483b411b363SPhilipp Reisner } 484b411b363SPhilipp Reisner 485dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 486b411b363SPhilipp Reisner { 487b411b363SPhilipp Reisner mm_segment_t oldfs; 488b411b363SPhilipp Reisner struct kvec iov = { 489b411b363SPhilipp Reisner .iov_base = buf, 490b411b363SPhilipp Reisner .iov_len = size, 491b411b363SPhilipp Reisner }; 492b411b363SPhilipp Reisner struct msghdr msg = { 493b411b363SPhilipp Reisner .msg_iovlen = 1, 494b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 495b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 496b411b363SPhilipp Reisner }; 497b411b363SPhilipp Reisner int rv; 498b411b363SPhilipp Reisner 499b411b363SPhilipp Reisner oldfs = get_fs(); 500b411b363SPhilipp Reisner set_fs(KERNEL_DS); 501b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 502b411b363SPhilipp Reisner set_fs(oldfs); 503b411b363SPhilipp Reisner 504b411b363SPhilipp Reisner return rv; 505b411b363SPhilipp Reisner } 506b411b363SPhilipp Reisner 507de0ff338SPhilipp Reisner static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size) 508b411b363SPhilipp Reisner { 509b411b363SPhilipp Reisner mm_segment_t oldfs; 510b411b363SPhilipp Reisner struct kvec iov = { 511b411b363SPhilipp Reisner .iov_base = buf, 512b411b363SPhilipp Reisner .iov_len = size, 513b411b363SPhilipp Reisner }; 514b411b363SPhilipp Reisner struct msghdr msg = { 515b411b363SPhilipp Reisner .msg_iovlen = 1, 516b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 517b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 518b411b363SPhilipp Reisner }; 519b411b363SPhilipp Reisner int rv; 520b411b363SPhilipp Reisner 521b411b363SPhilipp Reisner oldfs = get_fs(); 522b411b363SPhilipp Reisner set_fs(KERNEL_DS); 523b411b363SPhilipp Reisner 524b411b363SPhilipp Reisner for (;;) { 525de0ff338SPhilipp Reisner rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags); 526b411b363SPhilipp Reisner if (rv == size) 527b411b363SPhilipp Reisner break; 528b411b363SPhilipp Reisner 529b411b363SPhilipp Reisner /* Note: 530b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 531b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 532b411b363SPhilipp Reisner */ 533b411b363SPhilipp Reisner 534b411b363SPhilipp Reisner if (rv < 0) { 535b411b363SPhilipp Reisner if (rv == -ECONNRESET) 536de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 537b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 538de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 539b411b363SPhilipp Reisner break; 540b411b363SPhilipp Reisner } else if (rv == 0) { 541de0ff338SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 542b411b363SPhilipp Reisner break; 543b411b363SPhilipp Reisner } else { 544b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 545b411b363SPhilipp Reisner * after we read a partial message 546b411b363SPhilipp Reisner */ 547b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 548b411b363SPhilipp Reisner break; 549b411b363SPhilipp Reisner } 550b411b363SPhilipp Reisner }; 551b411b363SPhilipp Reisner 552b411b363SPhilipp Reisner set_fs(oldfs); 553b411b363SPhilipp Reisner 554b411b363SPhilipp Reisner if (rv != size) 555de0ff338SPhilipp Reisner drbd_force_state(tconn->volume0, NS(conn, C_BROKEN_PIPE)); 556b411b363SPhilipp Reisner 557b411b363SPhilipp Reisner return rv; 558b411b363SPhilipp Reisner } 559b411b363SPhilipp Reisner 5605dbf1673SLars Ellenberg /* quoting tcp(7): 5615dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5625dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5635dbf1673SLars Ellenberg * This is our wrapper to do so. 5645dbf1673SLars Ellenberg */ 5655dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5665dbf1673SLars Ellenberg unsigned int rcv) 5675dbf1673SLars Ellenberg { 5685dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5695dbf1673SLars Ellenberg if (snd) { 5705dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5715dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5725dbf1673SLars Ellenberg } 5735dbf1673SLars Ellenberg if (rcv) { 5745dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5755dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5765dbf1673SLars Ellenberg } 5775dbf1673SLars Ellenberg } 5785dbf1673SLars Ellenberg 579eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 580b411b363SPhilipp Reisner { 581b411b363SPhilipp Reisner const char *what; 582b411b363SPhilipp Reisner struct socket *sock; 583b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 584b411b363SPhilipp Reisner int err; 585b411b363SPhilipp Reisner int disconnect_on_error = 1; 586b411b363SPhilipp Reisner 587eac3e990SPhilipp Reisner if (!get_net_conf(tconn)) 588b411b363SPhilipp Reisner return NULL; 589b411b363SPhilipp Reisner 590b411b363SPhilipp Reisner what = "sock_create_kern"; 591eac3e990SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 592b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 593b411b363SPhilipp Reisner if (err < 0) { 594b411b363SPhilipp Reisner sock = NULL; 595b411b363SPhilipp Reisner goto out; 596b411b363SPhilipp Reisner } 597b411b363SPhilipp Reisner 598b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 599eac3e990SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->try_connect_int*HZ; 600eac3e990SPhilipp Reisner drbd_setbufsize(sock, tconn->net_conf->sndbuf_size, 601eac3e990SPhilipp Reisner tconn->net_conf->rcvbuf_size); 602b411b363SPhilipp Reisner 603b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 604b411b363SPhilipp Reisner * for the outgoing connections. 605b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 606b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 607b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 608b411b363SPhilipp Reisner * a free one dynamically. 609b411b363SPhilipp Reisner */ 610eac3e990SPhilipp Reisner memcpy(&src_in6, tconn->net_conf->my_addr, 611eac3e990SPhilipp Reisner min_t(int, tconn->net_conf->my_addr_len, sizeof(src_in6))); 612eac3e990SPhilipp Reisner if (((struct sockaddr *)tconn->net_conf->my_addr)->sa_family == AF_INET6) 613b411b363SPhilipp Reisner src_in6.sin6_port = 0; 614b411b363SPhilipp Reisner else 615b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 616b411b363SPhilipp Reisner 617b411b363SPhilipp Reisner what = "bind before connect"; 618b411b363SPhilipp Reisner err = sock->ops->bind(sock, 619b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 620eac3e990SPhilipp Reisner tconn->net_conf->my_addr_len); 621b411b363SPhilipp Reisner if (err < 0) 622b411b363SPhilipp Reisner goto out; 623b411b363SPhilipp Reisner 624b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 625b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 626b411b363SPhilipp Reisner disconnect_on_error = 0; 627b411b363SPhilipp Reisner what = "connect"; 628b411b363SPhilipp Reisner err = sock->ops->connect(sock, 629eac3e990SPhilipp Reisner (struct sockaddr *)tconn->net_conf->peer_addr, 630eac3e990SPhilipp Reisner tconn->net_conf->peer_addr_len, 0); 631b411b363SPhilipp Reisner 632b411b363SPhilipp Reisner out: 633b411b363SPhilipp Reisner if (err < 0) { 634b411b363SPhilipp Reisner if (sock) { 635b411b363SPhilipp Reisner sock_release(sock); 636b411b363SPhilipp Reisner sock = NULL; 637b411b363SPhilipp Reisner } 638b411b363SPhilipp Reisner switch (-err) { 639b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 640b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 641b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 642b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 643b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 644b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 645b411b363SPhilipp Reisner disconnect_on_error = 0; 646b411b363SPhilipp Reisner break; 647b411b363SPhilipp Reisner default: 648eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 649b411b363SPhilipp Reisner } 650b411b363SPhilipp Reisner if (disconnect_on_error) 651eac3e990SPhilipp Reisner drbd_force_state(tconn->volume0, NS(conn, C_DISCONNECTING)); 652b411b363SPhilipp Reisner } 653eac3e990SPhilipp Reisner put_net_conf(tconn); 654b411b363SPhilipp Reisner return sock; 655b411b363SPhilipp Reisner } 656b411b363SPhilipp Reisner 6577653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 658b411b363SPhilipp Reisner { 659b411b363SPhilipp Reisner int timeo, err; 660b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 661b411b363SPhilipp Reisner const char *what; 662b411b363SPhilipp Reisner 6637653620dSPhilipp Reisner if (!get_net_conf(tconn)) 664b411b363SPhilipp Reisner return NULL; 665b411b363SPhilipp Reisner 666b411b363SPhilipp Reisner what = "sock_create_kern"; 6677653620dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 668b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 669b411b363SPhilipp Reisner if (err) { 670b411b363SPhilipp Reisner s_listen = NULL; 671b411b363SPhilipp Reisner goto out; 672b411b363SPhilipp Reisner } 673b411b363SPhilipp Reisner 6747653620dSPhilipp Reisner timeo = tconn->net_conf->try_connect_int * HZ; 675b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 676b411b363SPhilipp Reisner 677b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 678b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 679b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 6807653620dSPhilipp Reisner drbd_setbufsize(s_listen, tconn->net_conf->sndbuf_size, 6817653620dSPhilipp Reisner tconn->net_conf->rcvbuf_size); 682b411b363SPhilipp Reisner 683b411b363SPhilipp Reisner what = "bind before listen"; 684b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 6857653620dSPhilipp Reisner (struct sockaddr *) tconn->net_conf->my_addr, 6867653620dSPhilipp Reisner tconn->net_conf->my_addr_len); 687b411b363SPhilipp Reisner if (err < 0) 688b411b363SPhilipp Reisner goto out; 689b411b363SPhilipp Reisner 6907653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 691b411b363SPhilipp Reisner 692b411b363SPhilipp Reisner out: 693b411b363SPhilipp Reisner if (s_listen) 694b411b363SPhilipp Reisner sock_release(s_listen); 695b411b363SPhilipp Reisner if (err < 0) { 696b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 6977653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 6987653620dSPhilipp Reisner drbd_force_state(tconn->volume0, NS(conn, C_DISCONNECTING)); 699b411b363SPhilipp Reisner } 700b411b363SPhilipp Reisner } 7017653620dSPhilipp Reisner put_net_conf(tconn); 702b411b363SPhilipp Reisner 703b411b363SPhilipp Reisner return s_estab; 704b411b363SPhilipp Reisner } 705b411b363SPhilipp Reisner 706d38e787eSPhilipp Reisner static int drbd_send_fp(struct drbd_tconn *tconn, struct socket *sock, enum drbd_packet cmd) 707b411b363SPhilipp Reisner { 708d38e787eSPhilipp Reisner struct p_header *h = &tconn->data.sbuf.header; 709b411b363SPhilipp Reisner 710d38e787eSPhilipp Reisner return _conn_send_cmd(tconn, 0, sock, cmd, h, sizeof(*h), 0); 711b411b363SPhilipp Reisner } 712b411b363SPhilipp Reisner 713a25b63f1SPhilipp Reisner static enum drbd_packet drbd_recv_fp(struct drbd_tconn *tconn, struct socket *sock) 714b411b363SPhilipp Reisner { 715a25b63f1SPhilipp Reisner struct p_header80 *h = &tconn->data.rbuf.header.h80; 716b411b363SPhilipp Reisner int rr; 717b411b363SPhilipp Reisner 718dbd9eea0SPhilipp Reisner rr = drbd_recv_short(sock, h, sizeof(*h), 0); 719b411b363SPhilipp Reisner 720ca9bc12bSAndreas Gruenbacher if (rr == sizeof(*h) && h->magic == cpu_to_be32(DRBD_MAGIC)) 721b411b363SPhilipp Reisner return be16_to_cpu(h->command); 722b411b363SPhilipp Reisner 723b411b363SPhilipp Reisner return 0xffff; 724b411b363SPhilipp Reisner } 725b411b363SPhilipp Reisner 726b411b363SPhilipp Reisner /** 727b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 728b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 729b411b363SPhilipp Reisner */ 730dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 731b411b363SPhilipp Reisner { 732b411b363SPhilipp Reisner int rr; 733b411b363SPhilipp Reisner char tb[4]; 734b411b363SPhilipp Reisner 735b411b363SPhilipp Reisner if (!*sock) 73681e84650SAndreas Gruenbacher return false; 737b411b363SPhilipp Reisner 738dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 739b411b363SPhilipp Reisner 740b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 74181e84650SAndreas Gruenbacher return true; 742b411b363SPhilipp Reisner } else { 743b411b363SPhilipp Reisner sock_release(*sock); 744b411b363SPhilipp Reisner *sock = NULL; 74581e84650SAndreas Gruenbacher return false; 746b411b363SPhilipp Reisner } 747b411b363SPhilipp Reisner } 748b411b363SPhilipp Reisner 749907599e0SPhilipp Reisner static int drbd_connected(int vnr, void *p, void *data) 750907599e0SPhilipp Reisner { 751907599e0SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 752907599e0SPhilipp Reisner int ok = 1; 753907599e0SPhilipp Reisner 754907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 755907599e0SPhilipp Reisner mdev->peer_seq = 0; 756907599e0SPhilipp Reisner 757907599e0SPhilipp Reisner ok &= drbd_send_sync_param(mdev, &mdev->sync_conf); 758907599e0SPhilipp Reisner ok &= drbd_send_sizes(mdev, 0, 0); 759907599e0SPhilipp Reisner ok &= drbd_send_uuids(mdev); 760907599e0SPhilipp Reisner ok &= drbd_send_state(mdev); 761907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 762907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 763907599e0SPhilipp Reisner 764907599e0SPhilipp Reisner return !ok; 765907599e0SPhilipp Reisner } 766907599e0SPhilipp Reisner 767b411b363SPhilipp Reisner /* 768b411b363SPhilipp Reisner * return values: 769b411b363SPhilipp Reisner * 1 yes, we have a valid connection 770b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 771b411b363SPhilipp Reisner * -1 peer talks different language, 772b411b363SPhilipp Reisner * no point in trying again, please go standalone. 773b411b363SPhilipp Reisner * -2 We do not have a network config... 774b411b363SPhilipp Reisner */ 775907599e0SPhilipp Reisner static int drbd_connect(struct drbd_tconn *tconn) 776b411b363SPhilipp Reisner { 777b411b363SPhilipp Reisner struct socket *s, *sock, *msock; 778b411b363SPhilipp Reisner int try, h, ok; 779b411b363SPhilipp Reisner 780907599e0SPhilipp Reisner if (drbd_request_state(tconn->volume0, NS(conn, C_WF_CONNECTION)) < SS_SUCCESS) 781b411b363SPhilipp Reisner return -2; 782b411b363SPhilipp Reisner 783907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 784907599e0SPhilipp Reisner tconn->agreed_pro_version = 99; 785fd340c12SPhilipp Reisner /* agreed_pro_version must be smaller than 100 so we send the old 786fd340c12SPhilipp Reisner header (h80) in the first packet and in the handshake packet. */ 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! */ 794907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 795b411b363SPhilipp Reisner if (s || ++try >= 3) 796b411b363SPhilipp Reisner break; 797b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 79820ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 799b411b363SPhilipp Reisner } 800b411b363SPhilipp Reisner 801b411b363SPhilipp Reisner if (s) { 802b411b363SPhilipp Reisner if (!sock) { 803907599e0SPhilipp Reisner drbd_send_fp(tconn, s, P_HAND_SHAKE_S); 804b411b363SPhilipp Reisner sock = s; 805b411b363SPhilipp Reisner s = NULL; 806b411b363SPhilipp Reisner } else if (!msock) { 807907599e0SPhilipp Reisner drbd_send_fp(tconn, s, P_HAND_SHAKE_M); 808b411b363SPhilipp Reisner msock = s; 809b411b363SPhilipp Reisner s = NULL; 810b411b363SPhilipp Reisner } else { 811907599e0SPhilipp Reisner conn_err(tconn, "Logic error in drbd_connect()\n"); 812b411b363SPhilipp Reisner goto out_release_sockets; 813b411b363SPhilipp Reisner } 814b411b363SPhilipp Reisner } 815b411b363SPhilipp Reisner 816b411b363SPhilipp Reisner if (sock && msock) { 817907599e0SPhilipp Reisner schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10); 818dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&sock); 819dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&msock) && ok; 820b411b363SPhilipp Reisner if (ok) 821b411b363SPhilipp Reisner break; 822b411b363SPhilipp Reisner } 823b411b363SPhilipp Reisner 824b411b363SPhilipp Reisner retry: 825907599e0SPhilipp Reisner s = drbd_wait_for_connect(tconn); 826b411b363SPhilipp Reisner if (s) { 827907599e0SPhilipp Reisner try = drbd_recv_fp(tconn, s); 828dbd9eea0SPhilipp Reisner drbd_socket_okay(&sock); 829dbd9eea0SPhilipp Reisner drbd_socket_okay(&msock); 830b411b363SPhilipp Reisner switch (try) { 831b411b363SPhilipp Reisner case P_HAND_SHAKE_S: 832b411b363SPhilipp Reisner if (sock) { 833907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 834b411b363SPhilipp Reisner sock_release(sock); 835b411b363SPhilipp Reisner } 836b411b363SPhilipp Reisner sock = s; 837b411b363SPhilipp Reisner break; 838b411b363SPhilipp Reisner case P_HAND_SHAKE_M: 839b411b363SPhilipp Reisner if (msock) { 840907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 841b411b363SPhilipp Reisner sock_release(msock); 842b411b363SPhilipp Reisner } 843b411b363SPhilipp Reisner msock = s; 844907599e0SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 845b411b363SPhilipp Reisner break; 846b411b363SPhilipp Reisner default: 847907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 848b411b363SPhilipp Reisner sock_release(s); 849b411b363SPhilipp Reisner if (random32() & 1) 850b411b363SPhilipp Reisner goto retry; 851b411b363SPhilipp Reisner } 852b411b363SPhilipp Reisner } 853b411b363SPhilipp Reisner 854907599e0SPhilipp Reisner if (tconn->volume0->state.conn <= C_DISCONNECTING) 855b411b363SPhilipp Reisner goto out_release_sockets; 856b411b363SPhilipp Reisner if (signal_pending(current)) { 857b411b363SPhilipp Reisner flush_signals(current); 858b411b363SPhilipp Reisner smp_rmb(); 859907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 860b411b363SPhilipp Reisner goto out_release_sockets; 861b411b363SPhilipp Reisner } 862b411b363SPhilipp Reisner 863b411b363SPhilipp Reisner if (sock && msock) { 864dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&sock); 865dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&msock) && ok; 866b411b363SPhilipp Reisner if (ok) 867b411b363SPhilipp Reisner break; 868b411b363SPhilipp Reisner } 869b411b363SPhilipp Reisner } while (1); 870b411b363SPhilipp Reisner 871b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 872b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 873b411b363SPhilipp Reisner 874b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 875b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 876b411b363SPhilipp Reisner 877b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 878b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 879b411b363SPhilipp Reisner 880b411b363SPhilipp Reisner /* NOT YET ... 881907599e0SPhilipp Reisner * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 882b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 883b411b363SPhilipp Reisner * first set it to the P_HAND_SHAKE timeout, 884b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 885b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 886907599e0SPhilipp Reisner sock->sk->sk_rcvtimeo = tconn->net_conf->ping_timeo*4*HZ/10; 887b411b363SPhilipp Reisner 888907599e0SPhilipp Reisner msock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 889907599e0SPhilipp Reisner msock->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 890b411b363SPhilipp Reisner 891b411b363SPhilipp Reisner /* we don't want delays. 89225985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 893b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 894b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 895b411b363SPhilipp Reisner 896907599e0SPhilipp Reisner tconn->data.socket = sock; 897907599e0SPhilipp Reisner tconn->meta.socket = msock; 898907599e0SPhilipp Reisner tconn->last_received = jiffies; 899b411b363SPhilipp Reisner 900907599e0SPhilipp Reisner h = drbd_do_handshake(tconn); 901b411b363SPhilipp Reisner if (h <= 0) 902b411b363SPhilipp Reisner return h; 903b411b363SPhilipp Reisner 904907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 905b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 906907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 907b10d96cbSJohannes Thoma case -1: 908907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 909b411b363SPhilipp Reisner return -1; 910b10d96cbSJohannes Thoma case 0: 911907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 912b10d96cbSJohannes Thoma return 0; 913b411b363SPhilipp Reisner } 914b411b363SPhilipp Reisner } 915b411b363SPhilipp Reisner 916907599e0SPhilipp Reisner if (drbd_request_state(tconn->volume0, NS(conn, C_WF_REPORT_PARAMS)) < SS_SUCCESS) 917b411b363SPhilipp Reisner return 0; 918b411b363SPhilipp Reisner 919907599e0SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 920b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 921b411b363SPhilipp Reisner 922907599e0SPhilipp Reisner drbd_thread_start(&tconn->asender); 923b411b363SPhilipp Reisner 924907599e0SPhilipp Reisner if (drbd_send_protocol(tconn) == -1) 9257e2455c1SPhilipp Reisner return -1; 926b411b363SPhilipp Reisner 927907599e0SPhilipp Reisner return !idr_for_each(&tconn->volumes, drbd_connected, tconn); 928b411b363SPhilipp Reisner 929b411b363SPhilipp Reisner out_release_sockets: 930b411b363SPhilipp Reisner if (sock) 931b411b363SPhilipp Reisner sock_release(sock); 932b411b363SPhilipp Reisner if (msock) 933b411b363SPhilipp Reisner sock_release(msock); 934b411b363SPhilipp Reisner return -1; 935b411b363SPhilipp Reisner } 936b411b363SPhilipp Reisner 937ce243853SPhilipp Reisner static bool decode_header(struct drbd_tconn *tconn, struct p_header *h, struct packet_info *pi) 938b411b363SPhilipp Reisner { 939fd340c12SPhilipp Reisner if (h->h80.magic == cpu_to_be32(DRBD_MAGIC)) { 94077351055SPhilipp Reisner pi->cmd = be16_to_cpu(h->h80.command); 94177351055SPhilipp Reisner pi->size = be16_to_cpu(h->h80.length); 942ca9bc12bSAndreas Gruenbacher } else if (h->h95.magic == cpu_to_be16(DRBD_MAGIC_BIG)) { 94377351055SPhilipp Reisner pi->cmd = be16_to_cpu(h->h95.command); 94477351055SPhilipp Reisner pi->size = be32_to_cpu(h->h95.length) & 0x00ffffff; 94577351055SPhilipp Reisner pi->vnr = 0; 94602918be2SPhilipp Reisner } else { 947ce243853SPhilipp Reisner conn_err(tconn, "magic?? on data m: 0x%08x c: %d l: %d\n", 948004352faSLars Ellenberg be32_to_cpu(h->h80.magic), 949004352faSLars Ellenberg be16_to_cpu(h->h80.command), 950004352faSLars Ellenberg be16_to_cpu(h->h80.length)); 95181e84650SAndreas Gruenbacher return false; 952b411b363SPhilipp Reisner } 953257d0af6SPhilipp Reisner return true; 954257d0af6SPhilipp Reisner } 955257d0af6SPhilipp Reisner 9569ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 957257d0af6SPhilipp Reisner { 9589ba7aa00SPhilipp Reisner struct p_header *h = &tconn->data.rbuf.header; 959257d0af6SPhilipp Reisner int r; 960257d0af6SPhilipp Reisner 9619ba7aa00SPhilipp Reisner r = drbd_recv(tconn, h, sizeof(*h)); 962257d0af6SPhilipp Reisner if (unlikely(r != sizeof(*h))) { 963257d0af6SPhilipp Reisner if (!signal_pending(current)) 9649ba7aa00SPhilipp Reisner conn_warn(tconn, "short read expecting header on sock: r=%d\n", r); 965257d0af6SPhilipp Reisner return false; 966257d0af6SPhilipp Reisner } 967257d0af6SPhilipp Reisner 9689ba7aa00SPhilipp Reisner r = decode_header(tconn, h, pi); 9699ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 970b411b363SPhilipp Reisner 971257d0af6SPhilipp Reisner return r; 972b411b363SPhilipp Reisner } 973b411b363SPhilipp Reisner 9742451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 975b411b363SPhilipp Reisner { 976b411b363SPhilipp Reisner int rv; 977b411b363SPhilipp Reisner 978b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 979fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 980dd3932edSChristoph Hellwig NULL); 981b411b363SPhilipp Reisner if (rv) { 982b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 983b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 984b411b363SPhilipp Reisner * don't try again for ANY return value != 0 985b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 986b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 987b411b363SPhilipp Reisner } 988b411b363SPhilipp Reisner put_ldev(mdev); 989b411b363SPhilipp Reisner } 990b411b363SPhilipp Reisner } 991b411b363SPhilipp Reisner 992b411b363SPhilipp Reisner /** 993b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 994b411b363SPhilipp Reisner * @mdev: DRBD device. 995b411b363SPhilipp Reisner * @epoch: Epoch object. 996b411b363SPhilipp Reisner * @ev: Epoch event. 997b411b363SPhilipp Reisner */ 998b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 999b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1000b411b363SPhilipp Reisner enum epoch_event ev) 1001b411b363SPhilipp Reisner { 10022451fc3bSPhilipp Reisner int epoch_size; 1003b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1004b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1005b411b363SPhilipp Reisner 1006b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1007b411b363SPhilipp Reisner do { 1008b411b363SPhilipp Reisner next_epoch = NULL; 1009b411b363SPhilipp Reisner 1010b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1011b411b363SPhilipp Reisner 1012b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1013b411b363SPhilipp Reisner case EV_PUT: 1014b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1015b411b363SPhilipp Reisner break; 1016b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1017b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1018b411b363SPhilipp Reisner break; 1019b411b363SPhilipp Reisner case EV_BECAME_LAST: 1020b411b363SPhilipp Reisner /* nothing to do*/ 1021b411b363SPhilipp Reisner break; 1022b411b363SPhilipp Reisner } 1023b411b363SPhilipp Reisner 1024b411b363SPhilipp Reisner if (epoch_size != 0 && 1025b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 10262451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1027b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1028b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1029b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1030b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1031b411b363SPhilipp Reisner } 1032b411b363SPhilipp Reisner dec_unacked(mdev); 1033b411b363SPhilipp Reisner 1034b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1035b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1036b411b363SPhilipp Reisner list_del(&epoch->list); 1037b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1038b411b363SPhilipp Reisner mdev->epochs--; 1039b411b363SPhilipp Reisner kfree(epoch); 1040b411b363SPhilipp Reisner 1041b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1042b411b363SPhilipp Reisner rv = FE_DESTROYED; 1043b411b363SPhilipp Reisner } else { 1044b411b363SPhilipp Reisner epoch->flags = 0; 1045b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1046698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1047b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1048b411b363SPhilipp Reisner rv = FE_RECYCLED; 10492451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1050b411b363SPhilipp Reisner } 1051b411b363SPhilipp Reisner } 1052b411b363SPhilipp Reisner 1053b411b363SPhilipp Reisner if (!next_epoch) 1054b411b363SPhilipp Reisner break; 1055b411b363SPhilipp Reisner 1056b411b363SPhilipp Reisner epoch = next_epoch; 1057b411b363SPhilipp Reisner } while (1); 1058b411b363SPhilipp Reisner 1059b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1060b411b363SPhilipp Reisner 1061b411b363SPhilipp Reisner return rv; 1062b411b363SPhilipp Reisner } 1063b411b363SPhilipp Reisner 1064b411b363SPhilipp Reisner /** 1065b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1066b411b363SPhilipp Reisner * @mdev: DRBD device. 1067b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1068b411b363SPhilipp Reisner */ 1069b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1070b411b363SPhilipp Reisner { 1071b411b363SPhilipp Reisner enum write_ordering_e pwo; 1072b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1073b411b363SPhilipp Reisner [WO_none] = "none", 1074b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1075b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1076b411b363SPhilipp Reisner }; 1077b411b363SPhilipp Reisner 1078b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1079b411b363SPhilipp Reisner wo = min(pwo, wo); 1080b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1081b411b363SPhilipp Reisner wo = WO_drain_io; 1082b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1083b411b363SPhilipp Reisner wo = WO_none; 1084b411b363SPhilipp Reisner mdev->write_ordering = wo; 10852451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1086b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1087b411b363SPhilipp Reisner } 1088b411b363SPhilipp Reisner 1089b411b363SPhilipp Reisner /** 109045bb912bSLars Ellenberg * drbd_submit_ee() 109145bb912bSLars Ellenberg * @mdev: DRBD device. 1092db830c46SAndreas Gruenbacher * @peer_req: peer request 109345bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 109410f6d992SLars Ellenberg * 109510f6d992SLars Ellenberg * May spread the pages to multiple bios, 109610f6d992SLars Ellenberg * depending on bio_add_page restrictions. 109710f6d992SLars Ellenberg * 109810f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 109910f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 110010f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 110110f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 110210f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 110310f6d992SLars Ellenberg * on certain Xen deployments. 110445bb912bSLars Ellenberg */ 110545bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1106db830c46SAndreas Gruenbacher int drbd_submit_ee(struct drbd_conf *mdev, struct drbd_peer_request *peer_req, 110745bb912bSLars Ellenberg const unsigned rw, const int fault_type) 110845bb912bSLars Ellenberg { 110945bb912bSLars Ellenberg struct bio *bios = NULL; 111045bb912bSLars Ellenberg struct bio *bio; 1111db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1112db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1113db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 111445bb912bSLars Ellenberg unsigned n_bios = 0; 111545bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 111610f6d992SLars Ellenberg int err = -ENOMEM; 111745bb912bSLars Ellenberg 111845bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 111945bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 112045bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 112145bb912bSLars Ellenberg * request in more than one bio. */ 112245bb912bSLars Ellenberg next_bio: 112345bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 112445bb912bSLars Ellenberg if (!bio) { 112545bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 112645bb912bSLars Ellenberg goto fail; 112745bb912bSLars Ellenberg } 1128db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 112945bb912bSLars Ellenberg bio->bi_sector = sector; 113045bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 113145bb912bSLars Ellenberg bio->bi_rw = rw; 1132db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 113345bb912bSLars Ellenberg bio->bi_end_io = drbd_endio_sec; 113445bb912bSLars Ellenberg 113545bb912bSLars Ellenberg bio->bi_next = bios; 113645bb912bSLars Ellenberg bios = bio; 113745bb912bSLars Ellenberg ++n_bios; 113845bb912bSLars Ellenberg 113945bb912bSLars Ellenberg page_chain_for_each(page) { 114045bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 114145bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 114210f6d992SLars Ellenberg /* A single page must always be possible! 114310f6d992SLars Ellenberg * But in case it fails anyways, 114410f6d992SLars Ellenberg * we deal with it, and complain (below). */ 114510f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 114610f6d992SLars Ellenberg dev_err(DEV, 114710f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 114810f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 114910f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 115010f6d992SLars Ellenberg err = -ENOSPC; 115110f6d992SLars Ellenberg goto fail; 115210f6d992SLars Ellenberg } 115345bb912bSLars Ellenberg goto next_bio; 115445bb912bSLars Ellenberg } 115545bb912bSLars Ellenberg ds -= len; 115645bb912bSLars Ellenberg sector += len >> 9; 115745bb912bSLars Ellenberg --nr_pages; 115845bb912bSLars Ellenberg } 115945bb912bSLars Ellenberg D_ASSERT(page == NULL); 116045bb912bSLars Ellenberg D_ASSERT(ds == 0); 116145bb912bSLars Ellenberg 1162db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 116345bb912bSLars Ellenberg do { 116445bb912bSLars Ellenberg bio = bios; 116545bb912bSLars Ellenberg bios = bios->bi_next; 116645bb912bSLars Ellenberg bio->bi_next = NULL; 116745bb912bSLars Ellenberg 116845bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 116945bb912bSLars Ellenberg } while (bios); 117045bb912bSLars Ellenberg return 0; 117145bb912bSLars Ellenberg 117245bb912bSLars Ellenberg fail: 117345bb912bSLars Ellenberg while (bios) { 117445bb912bSLars Ellenberg bio = bios; 117545bb912bSLars Ellenberg bios = bios->bi_next; 117645bb912bSLars Ellenberg bio_put(bio); 117745bb912bSLars Ellenberg } 117810f6d992SLars Ellenberg return err; 117945bb912bSLars Ellenberg } 118045bb912bSLars Ellenberg 118153840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1182db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 118353840641SAndreas Gruenbacher { 1184db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 118553840641SAndreas Gruenbacher 118653840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 118753840641SAndreas Gruenbacher drbd_clear_interval(i); 118853840641SAndreas Gruenbacher 11896c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 119053840641SAndreas Gruenbacher if (i->waiting) 119153840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 119253840641SAndreas Gruenbacher } 119353840641SAndreas Gruenbacher 1194d8763023SAndreas Gruenbacher static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packet cmd, 1195d8763023SAndreas Gruenbacher unsigned int data_size) 1196b411b363SPhilipp Reisner { 11972451fc3bSPhilipp Reisner int rv; 1198e42325a5SPhilipp Reisner struct p_barrier *p = &mdev->tconn->data.rbuf.barrier; 1199b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1200b411b363SPhilipp Reisner 1201b411b363SPhilipp Reisner inc_unacked(mdev); 1202b411b363SPhilipp Reisner 1203b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1204b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1205b411b363SPhilipp Reisner 1206b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1207b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1208b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1209b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1210b411b363SPhilipp Reisner * completed. */ 1211b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1212b411b363SPhilipp Reisner case WO_none: 1213b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 121481e84650SAndreas Gruenbacher return true; 1215b411b363SPhilipp Reisner 1216b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1217b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1218b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12192451fc3bSPhilipp Reisner if (epoch) 12202451fc3bSPhilipp Reisner break; 12212451fc3bSPhilipp Reisner else 1222b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 12232451fc3bSPhilipp Reisner /* Fall through */ 12242451fc3bSPhilipp Reisner 12252451fc3bSPhilipp Reisner case WO_bdev_flush: 12262451fc3bSPhilipp Reisner case WO_drain_io: 1227b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 12282451fc3bSPhilipp Reisner drbd_flush(mdev); 12292451fc3bSPhilipp Reisner 12302451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 12312451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12322451fc3bSPhilipp Reisner if (epoch) 12332451fc3bSPhilipp Reisner break; 1234b411b363SPhilipp Reisner } 1235b411b363SPhilipp Reisner 12362451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 12372451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 12382451fc3bSPhilipp Reisner 12392451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 12402451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1241b411b363SPhilipp Reisner 124281e84650SAndreas Gruenbacher return true; 12432451fc3bSPhilipp Reisner default: 12442451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 124581e84650SAndreas Gruenbacher return false; 1246b411b363SPhilipp Reisner } 1247b411b363SPhilipp Reisner 1248b411b363SPhilipp Reisner epoch->flags = 0; 1249b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1250b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1251b411b363SPhilipp Reisner 1252b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1253b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1254b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1255b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1256b411b363SPhilipp Reisner mdev->epochs++; 1257b411b363SPhilipp Reisner } else { 1258b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1259b411b363SPhilipp Reisner kfree(epoch); 1260b411b363SPhilipp Reisner } 1261b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1262b411b363SPhilipp Reisner 126381e84650SAndreas Gruenbacher return true; 1264b411b363SPhilipp Reisner } 1265b411b363SPhilipp Reisner 1266b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1267b411b363SPhilipp Reisner * and from receive_Data */ 1268f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1269f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1270f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1271b411b363SPhilipp Reisner { 12726666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1273db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1274b411b363SPhilipp Reisner struct page *page; 127545bb912bSLars Ellenberg int dgs, ds, rr; 1276a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1277a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 12786b4388acSPhilipp Reisner unsigned long *data; 1279b411b363SPhilipp Reisner 1280a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1281a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1282b411b363SPhilipp Reisner 1283b411b363SPhilipp Reisner if (dgs) { 1284de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, dig_in, dgs); 1285b411b363SPhilipp Reisner if (rr != dgs) { 12860ddc5549SLars Ellenberg if (!signal_pending(current)) 12870ddc5549SLars Ellenberg dev_warn(DEV, 12880ddc5549SLars Ellenberg "short read receiving data digest: read %d expected %d\n", 1289b411b363SPhilipp Reisner rr, dgs); 1290b411b363SPhilipp Reisner return NULL; 1291b411b363SPhilipp Reisner } 1292b411b363SPhilipp Reisner } 1293b411b363SPhilipp Reisner 1294b411b363SPhilipp Reisner data_size -= dgs; 1295b411b363SPhilipp Reisner 1296841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1297841ce241SAndreas Gruenbacher return NULL; 1298841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1299841ce241SAndreas Gruenbacher return NULL; 1300841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1301841ce241SAndreas Gruenbacher return NULL; 1302b411b363SPhilipp Reisner 13036666032aSLars Ellenberg /* even though we trust out peer, 13046666032aSLars Ellenberg * we sometimes have to double check. */ 13056666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1306fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1307fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 13086666032aSLars Ellenberg (unsigned long long)capacity, 13096666032aSLars Ellenberg (unsigned long long)sector, data_size); 13106666032aSLars Ellenberg return NULL; 13116666032aSLars Ellenberg } 13126666032aSLars Ellenberg 1313b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1314b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1315b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1316db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO); 1317db830c46SAndreas Gruenbacher if (!peer_req) 1318b411b363SPhilipp Reisner return NULL; 131945bb912bSLars Ellenberg 1320b411b363SPhilipp Reisner ds = data_size; 1321db830c46SAndreas Gruenbacher page = peer_req->pages; 132245bb912bSLars Ellenberg page_chain_for_each(page) { 132345bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 13246b4388acSPhilipp Reisner data = kmap(page); 1325de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, data, len); 13260cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 13276b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 13286b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 13296b4388acSPhilipp Reisner } 1330b411b363SPhilipp Reisner kunmap(page); 133145bb912bSLars Ellenberg if (rr != len) { 1332db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 13330ddc5549SLars Ellenberg if (!signal_pending(current)) 1334b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 133545bb912bSLars Ellenberg rr, len); 1336b411b363SPhilipp Reisner return NULL; 1337b411b363SPhilipp Reisner } 1338b411b363SPhilipp Reisner ds -= rr; 1339b411b363SPhilipp Reisner } 1340b411b363SPhilipp Reisner 1341b411b363SPhilipp Reisner if (dgs) { 1342db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->integrity_r_tfm, peer_req, dig_vv); 1343b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1344470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1345470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1346b411b363SPhilipp Reisner drbd_bcast_ee(mdev, "digest failed", 1347db830c46SAndreas Gruenbacher dgs, dig_in, dig_vv, peer_req); 1348db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1349b411b363SPhilipp Reisner return NULL; 1350b411b363SPhilipp Reisner } 1351b411b363SPhilipp Reisner } 1352b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1353db830c46SAndreas Gruenbacher return peer_req; 1354b411b363SPhilipp Reisner } 1355b411b363SPhilipp Reisner 1356b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1357b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1358b411b363SPhilipp Reisner */ 1359b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1360b411b363SPhilipp Reisner { 1361b411b363SPhilipp Reisner struct page *page; 1362b411b363SPhilipp Reisner int rr, rv = 1; 1363b411b363SPhilipp Reisner void *data; 1364b411b363SPhilipp Reisner 1365c3470cdeSLars Ellenberg if (!data_size) 136681e84650SAndreas Gruenbacher return true; 1367c3470cdeSLars Ellenberg 136845bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, 1, 1); 1369b411b363SPhilipp Reisner 1370b411b363SPhilipp Reisner data = kmap(page); 1371b411b363SPhilipp Reisner while (data_size) { 1372de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, data, min_t(int, data_size, PAGE_SIZE)); 1373b411b363SPhilipp Reisner if (rr != min_t(int, data_size, PAGE_SIZE)) { 1374b411b363SPhilipp Reisner rv = 0; 13750ddc5549SLars Ellenberg if (!signal_pending(current)) 13760ddc5549SLars Ellenberg dev_warn(DEV, 13770ddc5549SLars Ellenberg "short read receiving data: read %d expected %d\n", 1378b411b363SPhilipp Reisner rr, min_t(int, data_size, PAGE_SIZE)); 1379b411b363SPhilipp Reisner break; 1380b411b363SPhilipp Reisner } 1381b411b363SPhilipp Reisner data_size -= rr; 1382b411b363SPhilipp Reisner } 1383b411b363SPhilipp Reisner kunmap(page); 1384435f0740SLars Ellenberg drbd_pp_free(mdev, page, 0); 1385b411b363SPhilipp Reisner return rv; 1386b411b363SPhilipp Reisner } 1387b411b363SPhilipp Reisner 1388b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1389b411b363SPhilipp Reisner sector_t sector, int data_size) 1390b411b363SPhilipp Reisner { 1391b411b363SPhilipp Reisner struct bio_vec *bvec; 1392b411b363SPhilipp Reisner struct bio *bio; 1393b411b363SPhilipp Reisner int dgs, rr, i, expect; 1394a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1395a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1396b411b363SPhilipp Reisner 1397a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1398a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1399b411b363SPhilipp Reisner 1400b411b363SPhilipp Reisner if (dgs) { 1401de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, dig_in, dgs); 1402b411b363SPhilipp Reisner if (rr != dgs) { 14030ddc5549SLars Ellenberg if (!signal_pending(current)) 14040ddc5549SLars Ellenberg dev_warn(DEV, 14050ddc5549SLars Ellenberg "short read receiving data reply digest: read %d expected %d\n", 1406b411b363SPhilipp Reisner rr, dgs); 1407b411b363SPhilipp Reisner return 0; 1408b411b363SPhilipp Reisner } 1409b411b363SPhilipp Reisner } 1410b411b363SPhilipp Reisner 1411b411b363SPhilipp Reisner data_size -= dgs; 1412b411b363SPhilipp Reisner 1413b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1414b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1415b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1416b411b363SPhilipp Reisner 1417b411b363SPhilipp Reisner bio = req->master_bio; 1418b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1419b411b363SPhilipp Reisner 1420b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1421b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1422de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, 1423b411b363SPhilipp Reisner kmap(bvec->bv_page)+bvec->bv_offset, 1424b411b363SPhilipp Reisner expect); 1425b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1426b411b363SPhilipp Reisner if (rr != expect) { 14270ddc5549SLars Ellenberg if (!signal_pending(current)) 1428b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply: " 1429b411b363SPhilipp Reisner "read %d expected %d\n", 1430b411b363SPhilipp Reisner rr, expect); 1431b411b363SPhilipp Reisner return 0; 1432b411b363SPhilipp Reisner } 1433b411b363SPhilipp Reisner data_size -= rr; 1434b411b363SPhilipp Reisner } 1435b411b363SPhilipp Reisner 1436b411b363SPhilipp Reisner if (dgs) { 1437a0638456SPhilipp Reisner drbd_csum_bio(mdev, mdev->tconn->integrity_r_tfm, bio, dig_vv); 1438b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1439b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 1440b411b363SPhilipp Reisner return 0; 1441b411b363SPhilipp Reisner } 1442b411b363SPhilipp Reisner } 1443b411b363SPhilipp Reisner 1444b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 1445b411b363SPhilipp Reisner return 1; 1446b411b363SPhilipp Reisner } 1447b411b363SPhilipp Reisner 1448b411b363SPhilipp Reisner /* e_end_resync_block() is called via 1449b411b363SPhilipp Reisner * drbd_process_done_ee() by asender only */ 1450b411b363SPhilipp Reisner static int e_end_resync_block(struct drbd_conf *mdev, struct drbd_work *w, int unused) 1451b411b363SPhilipp Reisner { 1452db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = (struct drbd_peer_request *)w; 1453db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1454b411b363SPhilipp Reisner int ok; 1455b411b363SPhilipp Reisner 1456db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1457b411b363SPhilipp Reisner 1458db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1459db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1460db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1461b411b363SPhilipp Reisner } else { 1462b411b363SPhilipp Reisner /* Record failure to sync */ 1463db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1464b411b363SPhilipp Reisner 1465db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1466b411b363SPhilipp Reisner } 1467b411b363SPhilipp Reisner dec_unacked(mdev); 1468b411b363SPhilipp Reisner 1469b411b363SPhilipp Reisner return ok; 1470b411b363SPhilipp Reisner } 1471b411b363SPhilipp Reisner 1472b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1473b411b363SPhilipp Reisner { 1474db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1475b411b363SPhilipp Reisner 1476db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1477db830c46SAndreas Gruenbacher if (!peer_req) 147845bb912bSLars Ellenberg goto fail; 1479b411b363SPhilipp Reisner 1480b411b363SPhilipp Reisner dec_rs_pending(mdev); 1481b411b363SPhilipp Reisner 1482b411b363SPhilipp Reisner inc_unacked(mdev); 1483b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1484b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1485b411b363SPhilipp Reisner 1486db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 148745bb912bSLars Ellenberg 148887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1489db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 149087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1491b411b363SPhilipp Reisner 14920f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1493db830c46SAndreas Gruenbacher if (drbd_submit_ee(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 149481e84650SAndreas Gruenbacher return true; 149545bb912bSLars Ellenberg 149610f6d992SLars Ellenberg /* don't care for the reason here */ 149710f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 149887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1499db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 150087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 150122cc37a9SLars Ellenberg 1502db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 150345bb912bSLars Ellenberg fail: 150445bb912bSLars Ellenberg put_ldev(mdev); 150581e84650SAndreas Gruenbacher return false; 1506b411b363SPhilipp Reisner } 1507b411b363SPhilipp Reisner 1508668eebc6SAndreas Gruenbacher static struct drbd_request * 1509bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1510bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1511668eebc6SAndreas Gruenbacher { 1512668eebc6SAndreas Gruenbacher struct drbd_request *req; 1513668eebc6SAndreas Gruenbacher 1514bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1515bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 15165e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1517668eebc6SAndreas Gruenbacher return req; 1518c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1519c3afd8f5SAndreas Gruenbacher dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func, 1520c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1521c3afd8f5SAndreas Gruenbacher } 1522668eebc6SAndreas Gruenbacher return NULL; 1523668eebc6SAndreas Gruenbacher } 1524668eebc6SAndreas Gruenbacher 1525d8763023SAndreas Gruenbacher static int receive_DataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1526d8763023SAndreas Gruenbacher unsigned int data_size) 1527b411b363SPhilipp Reisner { 1528b411b363SPhilipp Reisner struct drbd_request *req; 1529b411b363SPhilipp Reisner sector_t sector; 1530b411b363SPhilipp Reisner int ok; 1531e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1532b411b363SPhilipp Reisner 1533b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1534b411b363SPhilipp Reisner 153587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1536bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 153787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1538c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 153981e84650SAndreas Gruenbacher return false; 1540b411b363SPhilipp Reisner 154124c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1542b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1543b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1544b411b363SPhilipp Reisner ok = recv_dless_read(mdev, req, sector, data_size); 1545b411b363SPhilipp Reisner 1546b411b363SPhilipp Reisner if (ok) 15478554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1548b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1549b411b363SPhilipp Reisner * I don't think we may complete this just yet 1550b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1551b411b363SPhilipp Reisner 1552b411b363SPhilipp Reisner return ok; 1553b411b363SPhilipp Reisner } 1554b411b363SPhilipp Reisner 1555d8763023SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1556d8763023SAndreas Gruenbacher unsigned int data_size) 1557b411b363SPhilipp Reisner { 1558b411b363SPhilipp Reisner sector_t sector; 1559b411b363SPhilipp Reisner int ok; 1560e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1561b411b363SPhilipp Reisner 1562b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1563b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1564b411b363SPhilipp Reisner 1565b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1566b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1567b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 15689c50842aSAndreas Gruenbacher * or in drbd_endio_sec. */ 1569b411b363SPhilipp Reisner ok = recv_resync_read(mdev, sector, data_size); 1570b411b363SPhilipp Reisner } else { 1571b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1572b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1573b411b363SPhilipp Reisner 1574b411b363SPhilipp Reisner ok = drbd_drain_block(mdev, data_size); 1575b411b363SPhilipp Reisner 15762b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1577b411b363SPhilipp Reisner } 1578b411b363SPhilipp Reisner 1579778f271dSPhilipp Reisner atomic_add(data_size >> 9, &mdev->rs_sect_in); 1580778f271dSPhilipp Reisner 1581b411b363SPhilipp Reisner return ok; 1582b411b363SPhilipp Reisner } 1583b411b363SPhilipp Reisner 1584b411b363SPhilipp Reisner /* e_end_block() is called via drbd_process_done_ee(). 1585b411b363SPhilipp Reisner * this means this function only runs in the asender thread 1586b411b363SPhilipp Reisner */ 1587b411b363SPhilipp Reisner static int e_end_block(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1588b411b363SPhilipp Reisner { 1589db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = (struct drbd_peer_request *)w; 1590db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1591b411b363SPhilipp Reisner int ok = 1, pcmd; 1592b411b363SPhilipp Reisner 159389e58e75SPhilipp Reisner if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C) { 1594db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1595b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1596b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1597db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1598b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1599db830c46SAndreas Gruenbacher ok &= drbd_send_ack(mdev, pcmd, peer_req); 1600b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1601db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1602b411b363SPhilipp Reisner } else { 1603db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1604b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1605b411b363SPhilipp Reisner * maybe assert this? */ 1606b411b363SPhilipp Reisner } 1607b411b363SPhilipp Reisner dec_unacked(mdev); 1608b411b363SPhilipp Reisner } 1609b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1610b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 161189e58e75SPhilipp Reisner if (mdev->tconn->net_conf->two_primaries) { 161287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1613db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1614db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 161587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1616bb3bfe96SAndreas Gruenbacher } else 1617db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1618b411b363SPhilipp Reisner 1619db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1620b411b363SPhilipp Reisner 1621b411b363SPhilipp Reisner return ok; 1622b411b363SPhilipp Reisner } 1623b411b363SPhilipp Reisner 1624b411b363SPhilipp Reisner static int e_send_discard_ack(struct drbd_conf *mdev, struct drbd_work *w, int unused) 1625b411b363SPhilipp Reisner { 1626db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = (struct drbd_peer_request *)w; 1627b411b363SPhilipp Reisner int ok = 1; 1628b411b363SPhilipp Reisner 162989e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 1630db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_DISCARD_ACK, peer_req); 1631b411b363SPhilipp Reisner 163287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1633db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1634db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 163587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1636b411b363SPhilipp Reisner 1637b411b363SPhilipp Reisner dec_unacked(mdev); 1638b411b363SPhilipp Reisner 1639b411b363SPhilipp Reisner return ok; 1640b411b363SPhilipp Reisner } 1641b411b363SPhilipp Reisner 16423e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 16433e394da1SAndreas Gruenbacher { 16443e394da1SAndreas Gruenbacher /* 16453e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 16463e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 16473e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 16483e394da1SAndreas Gruenbacher */ 16493e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 16503e394da1SAndreas Gruenbacher } 16513e394da1SAndreas Gruenbacher 16523e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 16533e394da1SAndreas Gruenbacher { 16543e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 16553e394da1SAndreas Gruenbacher } 16563e394da1SAndreas Gruenbacher 165743ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 16583e394da1SAndreas Gruenbacher { 165943ae077dSAndreas Gruenbacher unsigned int old_peer_seq; 16603e394da1SAndreas Gruenbacher 16613e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 166243ae077dSAndreas Gruenbacher old_peer_seq = mdev->peer_seq; 166343ae077dSAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 16643e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 166543ae077dSAndreas Gruenbacher if (old_peer_seq != peer_seq) 16663e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 16673e394da1SAndreas Gruenbacher } 16683e394da1SAndreas Gruenbacher 1669b411b363SPhilipp Reisner /* Called from receive_Data. 1670b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1671b411b363SPhilipp Reisner * 1672b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1673b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1674b411b363SPhilipp Reisner * been sent. 1675b411b363SPhilipp Reisner * 1676b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1677b411b363SPhilipp Reisner * 1678b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1679b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1680b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1681b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1682b411b363SPhilipp Reisner * 1683b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1684b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1685b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1686b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1687b411b363SPhilipp Reisner * 1688b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1689b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 1690b411b363SPhilipp Reisner static int drbd_wait_peer_seq(struct drbd_conf *mdev, const u32 packet_seq) 1691b411b363SPhilipp Reisner { 1692b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1693b411b363SPhilipp Reisner unsigned int p_seq; 1694b411b363SPhilipp Reisner long timeout; 1695b411b363SPhilipp Reisner int ret = 0; 1696b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1697b411b363SPhilipp Reisner for (;;) { 1698b411b363SPhilipp Reisner prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 16993e394da1SAndreas Gruenbacher if (!seq_greater(packet_seq, mdev->peer_seq + 1)) 1700b411b363SPhilipp Reisner break; 1701b411b363SPhilipp Reisner if (signal_pending(current)) { 1702b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1703b411b363SPhilipp Reisner break; 1704b411b363SPhilipp Reisner } 1705b411b363SPhilipp Reisner p_seq = mdev->peer_seq; 1706b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1707b411b363SPhilipp Reisner timeout = schedule_timeout(30*HZ); 1708b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1709b411b363SPhilipp Reisner if (timeout == 0 && p_seq == mdev->peer_seq) { 1710b411b363SPhilipp Reisner ret = -ETIMEDOUT; 1711b411b363SPhilipp Reisner dev_err(DEV, "ASSERT FAILED waited 30 seconds for sequence update, forcing reconnect\n"); 1712b411b363SPhilipp Reisner break; 1713b411b363SPhilipp Reisner } 1714b411b363SPhilipp Reisner } 1715b411b363SPhilipp Reisner finish_wait(&mdev->seq_wait, &wait); 1716b411b363SPhilipp Reisner if (mdev->peer_seq+1 == packet_seq) 1717b411b363SPhilipp Reisner mdev->peer_seq++; 1718b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1719b411b363SPhilipp Reisner return ret; 1720b411b363SPhilipp Reisner } 1721b411b363SPhilipp Reisner 1722688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1723688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1724688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1725688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 172676d2e7ecSPhilipp Reisner { 172776d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 172876d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1729688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 173076d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 173176d2e7ecSPhilipp Reisner } 173276d2e7ecSPhilipp Reisner 1733b411b363SPhilipp Reisner /* mirrored write */ 1734d8763023SAndreas Gruenbacher static int receive_Data(struct drbd_conf *mdev, enum drbd_packet cmd, 1735d8763023SAndreas Gruenbacher unsigned int data_size) 1736b411b363SPhilipp Reisner { 1737b411b363SPhilipp Reisner sector_t sector; 1738db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1739e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1740b411b363SPhilipp Reisner int rw = WRITE; 1741b411b363SPhilipp Reisner u32 dp_flags; 1742b411b363SPhilipp Reisner 1743b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 1744b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1745b411b363SPhilipp Reisner if (mdev->peer_seq+1 == be32_to_cpu(p->seq_num)) 1746b411b363SPhilipp Reisner mdev->peer_seq++; 1747b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1748b411b363SPhilipp Reisner 17492b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1750b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 1751b411b363SPhilipp Reisner return drbd_drain_block(mdev, data_size); 1752b411b363SPhilipp Reisner } 1753b411b363SPhilipp Reisner 1754b411b363SPhilipp Reisner /* get_ldev(mdev) successful. 1755b411b363SPhilipp Reisner * Corresponding put_ldev done either below (on various errors), 17569c50842aSAndreas Gruenbacher * or in drbd_endio_sec, if we successfully submit the data at 1757b411b363SPhilipp Reisner * the end of this function. */ 1758b411b363SPhilipp Reisner 1759b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1760db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, data_size); 1761db830c46SAndreas Gruenbacher if (!peer_req) { 1762b411b363SPhilipp Reisner put_ldev(mdev); 176381e84650SAndreas Gruenbacher return false; 1764b411b363SPhilipp Reisner } 1765b411b363SPhilipp Reisner 1766db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 1767b411b363SPhilipp Reisner 1768688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 1769688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 1770688593c5SLars Ellenberg 1771688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 1772db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 1773688593c5SLars Ellenberg 1774b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1775db830c46SAndreas Gruenbacher peer_req->epoch = mdev->current_epoch; 1776db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 1777db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 1778b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1779b411b363SPhilipp Reisner 1780b411b363SPhilipp Reisner /* I'm the receiver, I do hold a net_cnt reference. */ 178189e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->two_primaries) { 178287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1783b411b363SPhilipp Reisner } else { 1784b411b363SPhilipp Reisner /* don't get the req_lock yet, 1785b411b363SPhilipp Reisner * we may sleep in drbd_wait_peer_seq */ 1786db830c46SAndreas Gruenbacher const int size = peer_req->i.size; 178725703f83SPhilipp Reisner const int discard = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 1788b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1789b411b363SPhilipp Reisner int first; 1790b411b363SPhilipp Reisner 179189e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 1792b411b363SPhilipp Reisner 1793b411b363SPhilipp Reisner /* conflict detection and handling: 1794b411b363SPhilipp Reisner * 1. wait on the sequence number, 1795b411b363SPhilipp Reisner * in case this data packet overtook ACK packets. 17965e472264SAndreas Gruenbacher * 2. check for conflicting write requests. 1797b411b363SPhilipp Reisner * 1798b411b363SPhilipp Reisner * Note: for two_primaries, we are protocol C, 1799b411b363SPhilipp Reisner * so there cannot be any request that is DONE 1800b411b363SPhilipp Reisner * but still on the transfer log. 1801b411b363SPhilipp Reisner * 1802b411b363SPhilipp Reisner * if no conflicting request is found: 1803b411b363SPhilipp Reisner * submit. 1804b411b363SPhilipp Reisner * 1805b411b363SPhilipp Reisner * if any conflicting request is found 1806b411b363SPhilipp Reisner * that has not yet been acked, 1807b411b363SPhilipp Reisner * AND I have the "discard concurrent writes" flag: 1808b411b363SPhilipp Reisner * queue (via done_ee) the P_DISCARD_ACK; OUT. 1809b411b363SPhilipp Reisner * 1810b411b363SPhilipp Reisner * if any conflicting request is found: 1811b411b363SPhilipp Reisner * block the receiver, waiting on misc_wait 1812b411b363SPhilipp Reisner * until no more conflicting requests are there, 1813b411b363SPhilipp Reisner * or we get interrupted (disconnect). 1814b411b363SPhilipp Reisner * 1815b411b363SPhilipp Reisner * we do not just write after local io completion of those 1816b411b363SPhilipp Reisner * requests, but only after req is done completely, i.e. 1817b411b363SPhilipp Reisner * we wait for the P_DISCARD_ACK to arrive! 1818b411b363SPhilipp Reisner * 1819b411b363SPhilipp Reisner * then proceed normally, i.e. submit. 1820b411b363SPhilipp Reisner */ 1821b411b363SPhilipp Reisner if (drbd_wait_peer_seq(mdev, be32_to_cpu(p->seq_num))) 1822b411b363SPhilipp Reisner goto out_interrupted; 1823b411b363SPhilipp Reisner 182487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1825b411b363SPhilipp Reisner 1826b411b363SPhilipp Reisner first = 1; 1827b411b363SPhilipp Reisner for (;;) { 1828de696716SAndreas Gruenbacher struct drbd_interval *i; 1829b411b363SPhilipp Reisner int have_unacked = 0; 1830b411b363SPhilipp Reisner int have_conflict = 0; 1831b411b363SPhilipp Reisner prepare_to_wait(&mdev->misc_wait, &wait, 1832b411b363SPhilipp Reisner TASK_INTERRUPTIBLE); 1833de696716SAndreas Gruenbacher 1834de696716SAndreas Gruenbacher i = drbd_find_overlap(&mdev->write_requests, sector, size); 1835de696716SAndreas Gruenbacher if (i) { 1836b411b363SPhilipp Reisner /* only ALERT on first iteration, 1837b411b363SPhilipp Reisner * we may be woken up early... */ 1838b411b363SPhilipp Reisner if (first) 18395e472264SAndreas Gruenbacher dev_alert(DEV, "%s[%u] Concurrent %s write detected!" 1840b411b363SPhilipp Reisner " new: %llus +%u; pending: %llus +%u\n", 1841b411b363SPhilipp Reisner current->comm, current->pid, 18425e472264SAndreas Gruenbacher i->local ? "local" : "remote", 1843b411b363SPhilipp Reisner (unsigned long long)sector, size, 18445e472264SAndreas Gruenbacher (unsigned long long)i->sector, i->size); 18455e472264SAndreas Gruenbacher 18465e472264SAndreas Gruenbacher if (i->local) { 18475e472264SAndreas Gruenbacher struct drbd_request *req2; 18485e472264SAndreas Gruenbacher 18495e472264SAndreas Gruenbacher req2 = container_of(i, struct drbd_request, i); 1850de696716SAndreas Gruenbacher if (req2->rq_state & RQ_NET_PENDING) 1851b411b363SPhilipp Reisner ++have_unacked; 18525e472264SAndreas Gruenbacher } 1853b411b363SPhilipp Reisner ++have_conflict; 1854b411b363SPhilipp Reisner } 1855b411b363SPhilipp Reisner if (!have_conflict) 1856b411b363SPhilipp Reisner break; 1857b411b363SPhilipp Reisner 1858b411b363SPhilipp Reisner /* Discard Ack only for the _first_ iteration */ 1859b411b363SPhilipp Reisner if (first && discard && have_unacked) { 1860b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [DISCARD BY FLAG] sec=%llus\n", 1861b411b363SPhilipp Reisner (unsigned long long)sector); 1862b411b363SPhilipp Reisner inc_unacked(mdev); 1863db830c46SAndreas Gruenbacher peer_req->w.cb = e_send_discard_ack; 1864db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 1865b411b363SPhilipp Reisner 186687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1867b411b363SPhilipp Reisner 1868b411b363SPhilipp Reisner /* we could probably send that P_DISCARD_ACK ourselves, 1869b411b363SPhilipp Reisner * but I don't like the receiver using the msock */ 1870b411b363SPhilipp Reisner 1871b411b363SPhilipp Reisner put_ldev(mdev); 18720625ac19SPhilipp Reisner wake_asender(mdev->tconn); 1873b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 187481e84650SAndreas Gruenbacher return true; 1875b411b363SPhilipp Reisner } 1876b411b363SPhilipp Reisner 1877b411b363SPhilipp Reisner if (signal_pending(current)) { 187887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1879b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1880b411b363SPhilipp Reisner goto out_interrupted; 1881b411b363SPhilipp Reisner } 1882b411b363SPhilipp Reisner 1883a500c2efSAndreas Gruenbacher /* Indicate to wake up mdev->misc_wait upon completion. */ 188453840641SAndreas Gruenbacher i->waiting = true; 1885a500c2efSAndreas Gruenbacher 188687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1887b411b363SPhilipp Reisner if (first) { 1888b411b363SPhilipp Reisner first = 0; 1889b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [W AFTERWARDS] " 1890b411b363SPhilipp Reisner "sec=%llus\n", (unsigned long long)sector); 1891b411b363SPhilipp Reisner } else if (discard) { 1892b411b363SPhilipp Reisner /* we had none on the first iteration. 1893b411b363SPhilipp Reisner * there must be none now. */ 1894b411b363SPhilipp Reisner D_ASSERT(have_unacked == 0); 1895b411b363SPhilipp Reisner } 1896b411b363SPhilipp Reisner schedule(); 189787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1898b411b363SPhilipp Reisner } 1899b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 19005e472264SAndreas Gruenbacher 1901db830c46SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 1902b411b363SPhilipp Reisner } 1903b411b363SPhilipp Reisner 1904db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 190587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1906b411b363SPhilipp Reisner 190789e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->wire_protocol) { 1908b411b363SPhilipp Reisner case DRBD_PROT_C: 1909b411b363SPhilipp Reisner inc_unacked(mdev); 1910b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 1911b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1912b411b363SPhilipp Reisner break; 1913b411b363SPhilipp Reisner case DRBD_PROT_B: 1914b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 1915b411b363SPhilipp Reisner * sends on the msock, but anyways */ 1916db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 1917b411b363SPhilipp Reisner break; 1918b411b363SPhilipp Reisner case DRBD_PROT_A: 1919b411b363SPhilipp Reisner /* nothing to do */ 1920b411b363SPhilipp Reisner break; 1921b411b363SPhilipp Reisner } 1922b411b363SPhilipp Reisner 19236719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 1924b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 1925db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 1926db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 1927db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 1928db830c46SAndreas Gruenbacher drbd_al_begin_io(mdev, peer_req->i.sector); 1929b411b363SPhilipp Reisner } 1930b411b363SPhilipp Reisner 1931db830c46SAndreas Gruenbacher if (drbd_submit_ee(mdev, peer_req, rw, DRBD_FAULT_DT_WR) == 0) 193281e84650SAndreas Gruenbacher return true; 1933b411b363SPhilipp Reisner 193410f6d992SLars Ellenberg /* don't care for the reason here */ 193510f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 193687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1937db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 1938db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 193987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1940db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 1941db830c46SAndreas Gruenbacher drbd_al_complete_io(mdev, peer_req->i.sector); 194222cc37a9SLars Ellenberg 1943b411b363SPhilipp Reisner out_interrupted: 1944db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP); 1945b411b363SPhilipp Reisner put_ldev(mdev); 1946db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 194781e84650SAndreas Gruenbacher return false; 1948b411b363SPhilipp Reisner } 1949b411b363SPhilipp Reisner 19500f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 19510f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 19520f0601f4SLars Ellenberg * 19530f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 19540f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 19550f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 19560f0601f4SLars Ellenberg * activity, it obviously is "busy". 19570f0601f4SLars Ellenberg * 19580f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 19590f0601f4SLars Ellenberg * to have a short time average so we can react faster. 19600f0601f4SLars Ellenberg */ 1961e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 19620f0601f4SLars Ellenberg { 19630f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 19640f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 1965e3555d85SPhilipp Reisner struct lc_element *tmp; 19660f0601f4SLars Ellenberg int curr_events; 19670f0601f4SLars Ellenberg int throttle = 0; 19680f0601f4SLars Ellenberg 19690f0601f4SLars Ellenberg /* feature disabled? */ 19700f0601f4SLars Ellenberg if (mdev->sync_conf.c_min_rate == 0) 19710f0601f4SLars Ellenberg return 0; 19720f0601f4SLars Ellenberg 1973e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 1974e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 1975e3555d85SPhilipp Reisner if (tmp) { 1976e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 1977e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 1978e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 1979e3555d85SPhilipp Reisner return 0; 1980e3555d85SPhilipp Reisner } 1981e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 1982e3555d85SPhilipp Reisner } 1983e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 1984e3555d85SPhilipp Reisner 19850f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 19860f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 19870f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 1988e3555d85SPhilipp Reisner 19890f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 19900f0601f4SLars Ellenberg unsigned long rs_left; 19910f0601f4SLars Ellenberg int i; 19920f0601f4SLars Ellenberg 19930f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 19940f0601f4SLars Ellenberg 19950f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 19960f0601f4SLars Ellenberg * approx. */ 19972649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 19982649f080SLars Ellenberg 19992649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 20002649f080SLars Ellenberg rs_left = mdev->ov_left; 20012649f080SLars Ellenberg else 20020f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 20030f0601f4SLars Ellenberg 20040f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 20050f0601f4SLars Ellenberg if (!dt) 20060f0601f4SLars Ellenberg dt++; 20070f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 20080f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 20090f0601f4SLars Ellenberg 20100f0601f4SLars Ellenberg if (dbdt > mdev->sync_conf.c_min_rate) 20110f0601f4SLars Ellenberg throttle = 1; 20120f0601f4SLars Ellenberg } 20130f0601f4SLars Ellenberg return throttle; 20140f0601f4SLars Ellenberg } 20150f0601f4SLars Ellenberg 20160f0601f4SLars Ellenberg 2017d8763023SAndreas Gruenbacher static int receive_DataRequest(struct drbd_conf *mdev, enum drbd_packet cmd, 2018d8763023SAndreas Gruenbacher unsigned int digest_size) 2019b411b363SPhilipp Reisner { 2020b411b363SPhilipp Reisner sector_t sector; 2021b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 2022db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2023b411b363SPhilipp Reisner struct digest_info *di = NULL; 2024b18b37beSPhilipp Reisner int size, verb; 2025b411b363SPhilipp Reisner unsigned int fault_type; 2026e42325a5SPhilipp Reisner struct p_block_req *p = &mdev->tconn->data.rbuf.block_req; 2027b411b363SPhilipp Reisner 2028b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2029b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2030b411b363SPhilipp Reisner 20311816a2b4SLars Ellenberg if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_BIO_SIZE) { 2032b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2033b411b363SPhilipp Reisner (unsigned long long)sector, size); 203481e84650SAndreas Gruenbacher return false; 2035b411b363SPhilipp Reisner } 2036b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2037b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2038b411b363SPhilipp Reisner (unsigned long long)sector, size); 203981e84650SAndreas Gruenbacher return false; 2040b411b363SPhilipp Reisner } 2041b411b363SPhilipp Reisner 2042b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2043b18b37beSPhilipp Reisner verb = 1; 2044b18b37beSPhilipp Reisner switch (cmd) { 2045b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2046b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2047b18b37beSPhilipp Reisner break; 2048b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2049b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2050b18b37beSPhilipp Reisner case P_OV_REQUEST: 2051b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2052b18b37beSPhilipp Reisner break; 2053b18b37beSPhilipp Reisner case P_OV_REPLY: 2054b18b37beSPhilipp Reisner verb = 0; 2055b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2056b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2057b18b37beSPhilipp Reisner break; 2058b18b37beSPhilipp Reisner default: 2059b18b37beSPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 2060b18b37beSPhilipp Reisner cmdname(cmd)); 2061b18b37beSPhilipp Reisner } 2062b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2063b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2064b411b363SPhilipp Reisner "no local data.\n"); 2065b18b37beSPhilipp Reisner 2066a821cc4aSLars Ellenberg /* drain possibly payload */ 2067a821cc4aSLars Ellenberg return drbd_drain_block(mdev, digest_size); 2068b411b363SPhilipp Reisner } 2069b411b363SPhilipp Reisner 2070b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2071b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2072b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2073db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO); 2074db830c46SAndreas Gruenbacher if (!peer_req) { 2075b411b363SPhilipp Reisner put_ldev(mdev); 207681e84650SAndreas Gruenbacher return false; 2077b411b363SPhilipp Reisner } 2078b411b363SPhilipp Reisner 207902918be2SPhilipp Reisner switch (cmd) { 2080b411b363SPhilipp Reisner case P_DATA_REQUEST: 2081db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2082b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 208380a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 208480a40e43SLars Ellenberg goto submit; 208580a40e43SLars Ellenberg 2086b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2087db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2088b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 20895f9915bbSLars Ellenberg /* used in the sector offset progress display */ 20905f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2091b411b363SPhilipp Reisner break; 2092b411b363SPhilipp Reisner 2093b411b363SPhilipp Reisner case P_OV_REPLY: 2094b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2095b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2096b411b363SPhilipp Reisner di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO); 2097b411b363SPhilipp Reisner if (!di) 2098b411b363SPhilipp Reisner goto out_free_e; 2099b411b363SPhilipp Reisner 2100b411b363SPhilipp Reisner di->digest_size = digest_size; 2101b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2102b411b363SPhilipp Reisner 2103db830c46SAndreas Gruenbacher peer_req->digest = di; 2104db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2105c36c3cedSLars Ellenberg 2106de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, di->digest, digest_size) != digest_size) 2107b411b363SPhilipp Reisner goto out_free_e; 2108b411b363SPhilipp Reisner 210902918be2SPhilipp Reisner if (cmd == P_CSUM_RS_REQUEST) { 211031890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2111db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 21125f9915bbSLars Ellenberg /* used in the sector offset progress display */ 21135f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 211402918be2SPhilipp Reisner } else if (cmd == P_OV_REPLY) { 21152649f080SLars Ellenberg /* track progress, we may need to throttle */ 21162649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2117db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2118b411b363SPhilipp Reisner dec_rs_pending(mdev); 21190f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 21200f0601f4SLars Ellenberg * but accounting still needs to be done. */ 21210f0601f4SLars Ellenberg goto submit_for_resync; 2122b411b363SPhilipp Reisner } 2123b411b363SPhilipp Reisner break; 2124b411b363SPhilipp Reisner 2125b411b363SPhilipp Reisner case P_OV_REQUEST: 2126b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 212731890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2128de228bbaSLars Ellenberg unsigned long now = jiffies; 2129de228bbaSLars Ellenberg int i; 2130b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2131b411b363SPhilipp Reisner mdev->ov_position = sector; 213230b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 213330b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2134de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2135de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2136de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2137de228bbaSLars Ellenberg } 2138b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2139b411b363SPhilipp Reisner (unsigned long long)sector); 2140b411b363SPhilipp Reisner } 2141db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2142b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2143b411b363SPhilipp Reisner break; 2144b411b363SPhilipp Reisner 2145b411b363SPhilipp Reisner default: 2146b411b363SPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 214702918be2SPhilipp Reisner cmdname(cmd)); 2148b411b363SPhilipp Reisner fault_type = DRBD_FAULT_MAX; 214980a40e43SLars Ellenberg goto out_free_e; 2150b411b363SPhilipp Reisner } 2151b411b363SPhilipp Reisner 21520f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 21530f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 21540f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 21550f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 21560f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 21570f0601f4SLars Ellenberg * 21580f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 21590f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 21600f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 21610f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 21620f0601f4SLars Ellenberg * a while, anyways. 21630f0601f4SLars Ellenberg */ 2164b411b363SPhilipp Reisner 21650f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 21660f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 21670f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 21680f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 21690f0601f4SLars Ellenberg * 21700f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 21710f0601f4SLars Ellenberg * we would also throttle its application reads. 21720f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 21730f0601f4SLars Ellenberg */ 2174e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2175e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2176e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 217780a40e43SLars Ellenberg goto out_free_e; 2178b411b363SPhilipp Reisner 21790f0601f4SLars Ellenberg submit_for_resync: 21800f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 21810f0601f4SLars Ellenberg 218280a40e43SLars Ellenberg submit: 2183b411b363SPhilipp Reisner inc_unacked(mdev); 218487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2185db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 218687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2187b411b363SPhilipp Reisner 2188db830c46SAndreas Gruenbacher if (drbd_submit_ee(mdev, peer_req, READ, fault_type) == 0) 218981e84650SAndreas Gruenbacher return true; 2190b411b363SPhilipp Reisner 219110f6d992SLars Ellenberg /* don't care for the reason here */ 219210f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 219387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2194db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 219587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 219622cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 219722cc37a9SLars Ellenberg 2198b411b363SPhilipp Reisner out_free_e: 2199b411b363SPhilipp Reisner put_ldev(mdev); 2200db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 220181e84650SAndreas Gruenbacher return false; 2202b411b363SPhilipp Reisner } 2203b411b363SPhilipp Reisner 2204b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2205b411b363SPhilipp Reisner { 2206b411b363SPhilipp Reisner int self, peer, rv = -100; 2207b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2208b411b363SPhilipp Reisner 2209b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2210b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2211b411b363SPhilipp Reisner 2212b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2213b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2214b411b363SPhilipp Reisner 221589e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_0p) { 2216b411b363SPhilipp Reisner case ASB_CONSENSUS: 2217b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2218b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2219b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2220b411b363SPhilipp Reisner break; 2221b411b363SPhilipp Reisner case ASB_DISCONNECT: 2222b411b363SPhilipp Reisner break; 2223b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2224b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2225b411b363SPhilipp Reisner rv = -1; 2226b411b363SPhilipp Reisner break; 2227b411b363SPhilipp Reisner } 2228b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2229b411b363SPhilipp Reisner rv = 1; 2230b411b363SPhilipp Reisner break; 2231b411b363SPhilipp Reisner } 2232b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2233b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2234b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2235b411b363SPhilipp Reisner rv = 1; 2236b411b363SPhilipp Reisner break; 2237b411b363SPhilipp Reisner } 2238b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2239b411b363SPhilipp Reisner rv = -1; 2240b411b363SPhilipp Reisner break; 2241b411b363SPhilipp Reisner } 2242b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2243ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2244b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2245b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2246b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 224725703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2248b411b363SPhilipp Reisner ? -1 : 1; 2249b411b363SPhilipp Reisner break; 2250b411b363SPhilipp Reisner } else { 2251b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2252b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2253b411b363SPhilipp Reisner } 225489e58e75SPhilipp Reisner if (mdev->tconn->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2255b411b363SPhilipp Reisner break; 2256b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2257b411b363SPhilipp Reisner if (ch_self < ch_peer) 2258b411b363SPhilipp Reisner rv = -1; 2259b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2260b411b363SPhilipp Reisner rv = 1; 2261b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2262b411b363SPhilipp Reisner /* Well, then use something else. */ 226325703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2264b411b363SPhilipp Reisner ? -1 : 1; 2265b411b363SPhilipp Reisner break; 2266b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2267b411b363SPhilipp Reisner rv = -1; 2268b411b363SPhilipp Reisner break; 2269b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2270b411b363SPhilipp Reisner rv = 1; 2271b411b363SPhilipp Reisner } 2272b411b363SPhilipp Reisner 2273b411b363SPhilipp Reisner return rv; 2274b411b363SPhilipp Reisner } 2275b411b363SPhilipp Reisner 2276b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2277b411b363SPhilipp Reisner { 22786184ea21SAndreas Gruenbacher int hg, rv = -100; 2279b411b363SPhilipp Reisner 228089e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_1p) { 2281b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2282b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2283b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2284b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2285b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2286b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2287b411b363SPhilipp Reisner break; 2288b411b363SPhilipp Reisner case ASB_DISCONNECT: 2289b411b363SPhilipp Reisner break; 2290b411b363SPhilipp Reisner case ASB_CONSENSUS: 2291b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2292b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2293b411b363SPhilipp Reisner rv = hg; 2294b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2295b411b363SPhilipp Reisner rv = hg; 2296b411b363SPhilipp Reisner break; 2297b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2298b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2299b411b363SPhilipp Reisner break; 2300b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2301b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2302b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2303b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2304b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2305bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2306bb437946SAndreas Gruenbacher 2307bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2308b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2309b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2310b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2311bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2312bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2313b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2314b411b363SPhilipp Reisner } else { 2315b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2316b411b363SPhilipp Reisner rv = hg; 2317b411b363SPhilipp Reisner } 2318b411b363SPhilipp Reisner } else 2319b411b363SPhilipp Reisner rv = hg; 2320b411b363SPhilipp Reisner } 2321b411b363SPhilipp Reisner 2322b411b363SPhilipp Reisner return rv; 2323b411b363SPhilipp Reisner } 2324b411b363SPhilipp Reisner 2325b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2326b411b363SPhilipp Reisner { 23276184ea21SAndreas Gruenbacher int hg, rv = -100; 2328b411b363SPhilipp Reisner 232989e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_2p) { 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 case ASB_CONSENSUS: 2336b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2337b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2338b411b363SPhilipp Reisner break; 2339b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2340b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2341b411b363SPhilipp Reisner break; 2342b411b363SPhilipp Reisner case ASB_DISCONNECT: 2343b411b363SPhilipp Reisner break; 2344b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2345b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2346b411b363SPhilipp Reisner if (hg == -1) { 2347bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2348bb437946SAndreas Gruenbacher 2349b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2350b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2351b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2352bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2353bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2354b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2355b411b363SPhilipp Reisner } else { 2356b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2357b411b363SPhilipp Reisner rv = hg; 2358b411b363SPhilipp Reisner } 2359b411b363SPhilipp Reisner } else 2360b411b363SPhilipp Reisner rv = hg; 2361b411b363SPhilipp Reisner } 2362b411b363SPhilipp Reisner 2363b411b363SPhilipp Reisner return rv; 2364b411b363SPhilipp Reisner } 2365b411b363SPhilipp Reisner 2366b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2367b411b363SPhilipp Reisner u64 bits, u64 flags) 2368b411b363SPhilipp Reisner { 2369b411b363SPhilipp Reisner if (!uuid) { 2370b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2371b411b363SPhilipp Reisner return; 2372b411b363SPhilipp Reisner } 2373b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2374b411b363SPhilipp Reisner text, 2375b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2376b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2377b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2378b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2379b411b363SPhilipp Reisner (unsigned long long)bits, 2380b411b363SPhilipp Reisner (unsigned long long)flags); 2381b411b363SPhilipp Reisner } 2382b411b363SPhilipp Reisner 2383b411b363SPhilipp Reisner /* 2384b411b363SPhilipp Reisner 100 after split brain try auto recover 2385b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2386b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2387b411b363SPhilipp Reisner 0 no Sync 2388b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2389b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2390b411b363SPhilipp Reisner -100 after split brain, disconnect 2391b411b363SPhilipp Reisner -1000 unrelated data 23924a23f264SPhilipp Reisner -1091 requires proto 91 23934a23f264SPhilipp Reisner -1096 requires proto 96 2394b411b363SPhilipp Reisner */ 2395b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2396b411b363SPhilipp Reisner { 2397b411b363SPhilipp Reisner u64 self, peer; 2398b411b363SPhilipp Reisner int i, j; 2399b411b363SPhilipp Reisner 2400b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2401b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2402b411b363SPhilipp Reisner 2403b411b363SPhilipp Reisner *rule_nr = 10; 2404b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2405b411b363SPhilipp Reisner return 0; 2406b411b363SPhilipp Reisner 2407b411b363SPhilipp Reisner *rule_nr = 20; 2408b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2409b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2410b411b363SPhilipp Reisner return -2; 2411b411b363SPhilipp Reisner 2412b411b363SPhilipp Reisner *rule_nr = 30; 2413b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2414b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2415b411b363SPhilipp Reisner return 2; 2416b411b363SPhilipp Reisner 2417b411b363SPhilipp Reisner if (self == peer) { 2418b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2419b411b363SPhilipp Reisner 2420b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2421b411b363SPhilipp Reisner 242231890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 24234a23f264SPhilipp Reisner return -1091; 2424b411b363SPhilipp Reisner 2425b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2426b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2427b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2428b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2429b411b363SPhilipp Reisner 2430b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2431b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2432b411b363SPhilipp Reisner *rule_nr = 34; 2433b411b363SPhilipp Reisner } else { 2434b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2435b411b363SPhilipp Reisner *rule_nr = 36; 2436b411b363SPhilipp Reisner } 2437b411b363SPhilipp Reisner 2438b411b363SPhilipp Reisner return 1; 2439b411b363SPhilipp Reisner } 2440b411b363SPhilipp Reisner 2441b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2442b411b363SPhilipp Reisner 244331890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 24444a23f264SPhilipp Reisner return -1091; 2445b411b363SPhilipp Reisner 2446b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2447b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2448b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2449b411b363SPhilipp Reisner 2450b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2451b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2452b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2453b411b363SPhilipp Reisner 2454b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2455b411b363SPhilipp Reisner *rule_nr = 35; 2456b411b363SPhilipp Reisner } else { 2457b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2458b411b363SPhilipp Reisner *rule_nr = 37; 2459b411b363SPhilipp Reisner } 2460b411b363SPhilipp Reisner 2461b411b363SPhilipp Reisner return -1; 2462b411b363SPhilipp Reisner } 2463b411b363SPhilipp Reisner 2464b411b363SPhilipp Reisner /* Common power [off|failure] */ 2465b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2466b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2467b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2468b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2469b411b363SPhilipp Reisner *rule_nr = 40; 2470b411b363SPhilipp Reisner 2471b411b363SPhilipp Reisner switch (rct) { 2472b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2473b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2474b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2475b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 247625703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2477b411b363SPhilipp Reisner return dc ? -1 : 1; 2478b411b363SPhilipp Reisner } 2479b411b363SPhilipp Reisner } 2480b411b363SPhilipp Reisner 2481b411b363SPhilipp Reisner *rule_nr = 50; 2482b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2483b411b363SPhilipp Reisner if (self == peer) 2484b411b363SPhilipp Reisner return -1; 2485b411b363SPhilipp Reisner 2486b411b363SPhilipp Reisner *rule_nr = 51; 2487b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2488b411b363SPhilipp Reisner if (self == peer) { 248931890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 24904a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 24914a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 24924a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2493b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2494b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2495b411b363SPhilipp Reisner 249631890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 24974a23f264SPhilipp Reisner return -1091; 2498b411b363SPhilipp Reisner 2499b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2500b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 25014a23f264SPhilipp Reisner 25024a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 25034a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 25044a23f264SPhilipp Reisner 2505b411b363SPhilipp Reisner return -1; 2506b411b363SPhilipp Reisner } 2507b411b363SPhilipp Reisner } 2508b411b363SPhilipp Reisner 2509b411b363SPhilipp Reisner *rule_nr = 60; 2510b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2511b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2512b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2513b411b363SPhilipp Reisner if (self == peer) 2514b411b363SPhilipp Reisner return -2; 2515b411b363SPhilipp Reisner } 2516b411b363SPhilipp Reisner 2517b411b363SPhilipp Reisner *rule_nr = 70; 2518b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2519b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2520b411b363SPhilipp Reisner if (self == peer) 2521b411b363SPhilipp Reisner return 1; 2522b411b363SPhilipp Reisner 2523b411b363SPhilipp Reisner *rule_nr = 71; 2524b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2525b411b363SPhilipp Reisner if (self == peer) { 252631890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 25274a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 25284a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 25294a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2530b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2531b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2532b411b363SPhilipp Reisner 253331890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25344a23f264SPhilipp Reisner return -1091; 2535b411b363SPhilipp Reisner 2536b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2537b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2538b411b363SPhilipp Reisner 25394a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2540b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2541b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2542b411b363SPhilipp Reisner 2543b411b363SPhilipp Reisner return 1; 2544b411b363SPhilipp Reisner } 2545b411b363SPhilipp Reisner } 2546b411b363SPhilipp Reisner 2547b411b363SPhilipp Reisner 2548b411b363SPhilipp Reisner *rule_nr = 80; 2549d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2550b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2551b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2552b411b363SPhilipp Reisner if (self == peer) 2553b411b363SPhilipp Reisner return 2; 2554b411b363SPhilipp Reisner } 2555b411b363SPhilipp Reisner 2556b411b363SPhilipp Reisner *rule_nr = 90; 2557b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2558b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2559b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2560b411b363SPhilipp Reisner return 100; 2561b411b363SPhilipp Reisner 2562b411b363SPhilipp Reisner *rule_nr = 100; 2563b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2564b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2565b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2566b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2567b411b363SPhilipp Reisner if (self == peer) 2568b411b363SPhilipp Reisner return -100; 2569b411b363SPhilipp Reisner } 2570b411b363SPhilipp Reisner } 2571b411b363SPhilipp Reisner 2572b411b363SPhilipp Reisner return -1000; 2573b411b363SPhilipp Reisner } 2574b411b363SPhilipp Reisner 2575b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2576b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2577b411b363SPhilipp Reisner */ 2578b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2579b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2580b411b363SPhilipp Reisner { 2581b411b363SPhilipp Reisner int hg, rule_nr; 2582b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2583b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2584b411b363SPhilipp Reisner 2585b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2586b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2587b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2588b411b363SPhilipp Reisner 2589b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2590b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2591b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2592b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2593b411b363SPhilipp Reisner 2594b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2595b411b363SPhilipp Reisner 2596b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2597b411b363SPhilipp Reisner 2598b411b363SPhilipp Reisner if (hg == -1000) { 2599b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2600b411b363SPhilipp Reisner return C_MASK; 2601b411b363SPhilipp Reisner } 26024a23f264SPhilipp Reisner if (hg < -1000) { 26034a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2604b411b363SPhilipp Reisner return C_MASK; 2605b411b363SPhilipp Reisner } 2606b411b363SPhilipp Reisner 2607b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2608b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2609b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2610b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2611b411b363SPhilipp Reisner if (f) 2612b411b363SPhilipp Reisner hg = hg*2; 2613b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2614b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2615b411b363SPhilipp Reisner } 2616b411b363SPhilipp Reisner 26173a11a487SAdam Gandelman if (abs(hg) == 100) 26183a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 26193a11a487SAdam Gandelman 262089e58e75SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->tconn->net_conf->always_asbp)) { 2621b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2622b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2623b411b363SPhilipp Reisner int forced = (hg == -100); 2624b411b363SPhilipp Reisner 2625b411b363SPhilipp Reisner switch (pcount) { 2626b411b363SPhilipp Reisner case 0: 2627b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2628b411b363SPhilipp Reisner break; 2629b411b363SPhilipp Reisner case 1: 2630b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2631b411b363SPhilipp Reisner break; 2632b411b363SPhilipp Reisner case 2: 2633b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2634b411b363SPhilipp Reisner break; 2635b411b363SPhilipp Reisner } 2636b411b363SPhilipp Reisner if (abs(hg) < 100) { 2637b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2638b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2639b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2640b411b363SPhilipp Reisner if (forced) { 2641b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2642b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2643b411b363SPhilipp Reisner hg = hg*2; 2644b411b363SPhilipp Reisner } 2645b411b363SPhilipp Reisner } 2646b411b363SPhilipp Reisner } 2647b411b363SPhilipp Reisner 2648b411b363SPhilipp Reisner if (hg == -100) { 264989e58e75SPhilipp Reisner if (mdev->tconn->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2650b411b363SPhilipp Reisner hg = -1; 265189e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2652b411b363SPhilipp Reisner hg = 1; 2653b411b363SPhilipp Reisner 2654b411b363SPhilipp Reisner if (abs(hg) < 100) 2655b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2656b411b363SPhilipp Reisner "Sync from %s node\n", 2657b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2658b411b363SPhilipp Reisner } 2659b411b363SPhilipp Reisner 2660b411b363SPhilipp Reisner if (hg == -100) { 2661580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2662580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2663580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2664580b9767SLars Ellenberg * to that disk, in a way... */ 26653a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2666b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2667b411b363SPhilipp Reisner return C_MASK; 2668b411b363SPhilipp Reisner } 2669b411b363SPhilipp Reisner 2670b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2671b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2672b411b363SPhilipp Reisner return C_MASK; 2673b411b363SPhilipp Reisner } 2674b411b363SPhilipp Reisner 2675b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2676b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 267789e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->rr_conflict) { 2678b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2679b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2680b411b363SPhilipp Reisner /* fall through */ 2681b411b363SPhilipp Reisner case ASB_DISCONNECT: 2682b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2683b411b363SPhilipp Reisner return C_MASK; 2684b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2685b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2686b411b363SPhilipp Reisner "assumption\n"); 2687b411b363SPhilipp Reisner } 2688b411b363SPhilipp Reisner } 2689b411b363SPhilipp Reisner 269089e58e75SPhilipp Reisner if (mdev->tconn->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->flags)) { 2691cf14c2e9SPhilipp Reisner if (hg == 0) 2692cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2693cf14c2e9SPhilipp Reisner else 2694cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2695cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2696cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2697cf14c2e9SPhilipp Reisner return C_MASK; 2698cf14c2e9SPhilipp Reisner } 2699cf14c2e9SPhilipp Reisner 2700b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2701b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 270220ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 270320ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2704b411b363SPhilipp Reisner return C_MASK; 2705b411b363SPhilipp Reisner } 2706b411b363SPhilipp Reisner 2707b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2708b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2709b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2710b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2711b411b363SPhilipp Reisner } else { 2712b411b363SPhilipp Reisner rv = C_CONNECTED; 2713b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2714b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2715b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2716b411b363SPhilipp Reisner } 2717b411b363SPhilipp Reisner } 2718b411b363SPhilipp Reisner 2719b411b363SPhilipp Reisner return rv; 2720b411b363SPhilipp Reisner } 2721b411b363SPhilipp Reisner 2722b411b363SPhilipp Reisner /* returns 1 if invalid */ 2723b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2724b411b363SPhilipp Reisner { 2725b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2726b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2727b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2728b411b363SPhilipp Reisner return 0; 2729b411b363SPhilipp Reisner 2730b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2731b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2732b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2733b411b363SPhilipp Reisner return 1; 2734b411b363SPhilipp Reisner 2735b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2736b411b363SPhilipp Reisner if (peer == self) 2737b411b363SPhilipp Reisner return 0; 2738b411b363SPhilipp Reisner 2739b411b363SPhilipp Reisner /* everything es is invalid. */ 2740b411b363SPhilipp Reisner return 1; 2741b411b363SPhilipp Reisner } 2742b411b363SPhilipp Reisner 2743d8763023SAndreas Gruenbacher static int receive_protocol(struct drbd_conf *mdev, enum drbd_packet cmd, 2744d8763023SAndreas Gruenbacher unsigned int data_size) 2745b411b363SPhilipp Reisner { 2746e42325a5SPhilipp Reisner struct p_protocol *p = &mdev->tconn->data.rbuf.protocol; 2747b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2748cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2749b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2750b411b363SPhilipp Reisner 2751b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2752b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2753b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2754b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2755b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2756cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2757cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2758cf14c2e9SPhilipp Reisner 2759cf14c2e9SPhilipp Reisner clear_bit(CONN_DRY_RUN, &mdev->flags); 2760cf14c2e9SPhilipp Reisner 2761cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 2762cf14c2e9SPhilipp Reisner set_bit(CONN_DRY_RUN, &mdev->flags); 2763b411b363SPhilipp Reisner 276489e58e75SPhilipp Reisner if (p_proto != mdev->tconn->net_conf->wire_protocol) { 2765b411b363SPhilipp Reisner dev_err(DEV, "incompatible communication protocols\n"); 2766b411b363SPhilipp Reisner goto disconnect; 2767b411b363SPhilipp Reisner } 2768b411b363SPhilipp Reisner 276989e58e75SPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, mdev->tconn->net_conf->after_sb_0p)) { 2770b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-0pri settings\n"); 2771b411b363SPhilipp Reisner goto disconnect; 2772b411b363SPhilipp Reisner } 2773b411b363SPhilipp Reisner 277489e58e75SPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, mdev->tconn->net_conf->after_sb_1p)) { 2775b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-1pri settings\n"); 2776b411b363SPhilipp Reisner goto disconnect; 2777b411b363SPhilipp Reisner } 2778b411b363SPhilipp Reisner 277989e58e75SPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, mdev->tconn->net_conf->after_sb_2p)) { 2780b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-2pri settings\n"); 2781b411b363SPhilipp Reisner goto disconnect; 2782b411b363SPhilipp Reisner } 2783b411b363SPhilipp Reisner 278489e58e75SPhilipp Reisner if (p_want_lose && mdev->tconn->net_conf->want_lose) { 2785b411b363SPhilipp Reisner dev_err(DEV, "both sides have the 'want_lose' flag set\n"); 2786b411b363SPhilipp Reisner goto disconnect; 2787b411b363SPhilipp Reisner } 2788b411b363SPhilipp Reisner 278989e58e75SPhilipp Reisner if (p_two_primaries != mdev->tconn->net_conf->two_primaries) { 2790b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the two-primaries options\n"); 2791b411b363SPhilipp Reisner goto disconnect; 2792b411b363SPhilipp Reisner } 2793b411b363SPhilipp Reisner 279431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version >= 87) { 279589e58e75SPhilipp Reisner unsigned char *my_alg = mdev->tconn->net_conf->integrity_alg; 2796b411b363SPhilipp Reisner 2797de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, p_integrity_alg, data_size) != data_size) 279881e84650SAndreas Gruenbacher return false; 2799b411b363SPhilipp Reisner 2800b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2801b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 2802b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the data-integrity-alg\n"); 2803b411b363SPhilipp Reisner goto disconnect; 2804b411b363SPhilipp Reisner } 2805b411b363SPhilipp Reisner dev_info(DEV, "data-integrity-alg: %s\n", 2806b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2807b411b363SPhilipp Reisner } 2808b411b363SPhilipp Reisner 280981e84650SAndreas Gruenbacher return true; 2810b411b363SPhilipp Reisner 2811b411b363SPhilipp Reisner disconnect: 2812b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 281381e84650SAndreas Gruenbacher return false; 2814b411b363SPhilipp Reisner } 2815b411b363SPhilipp Reisner 2816b411b363SPhilipp Reisner /* helper function 2817b411b363SPhilipp Reisner * input: alg name, feature name 2818b411b363SPhilipp Reisner * return: NULL (alg name was "") 2819b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2820b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2821b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2822b411b363SPhilipp Reisner const char *alg, const char *name) 2823b411b363SPhilipp Reisner { 2824b411b363SPhilipp Reisner struct crypto_hash *tfm; 2825b411b363SPhilipp Reisner 2826b411b363SPhilipp Reisner if (!alg[0]) 2827b411b363SPhilipp Reisner return NULL; 2828b411b363SPhilipp Reisner 2829b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2830b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 2831b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 2832b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 2833b411b363SPhilipp Reisner return tfm; 2834b411b363SPhilipp Reisner } 2835b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 2836b411b363SPhilipp Reisner crypto_free_hash(tfm); 2837b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 2838b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 2839b411b363SPhilipp Reisner } 2840b411b363SPhilipp Reisner return tfm; 2841b411b363SPhilipp Reisner } 2842b411b363SPhilipp Reisner 2843d8763023SAndreas Gruenbacher static int receive_SyncParam(struct drbd_conf *mdev, enum drbd_packet cmd, 2844d8763023SAndreas Gruenbacher unsigned int packet_size) 2845b411b363SPhilipp Reisner { 284681e84650SAndreas Gruenbacher int ok = true; 2847e42325a5SPhilipp Reisner struct p_rs_param_95 *p = &mdev->tconn->data.rbuf.rs_param_95; 2848b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 2849b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 2850b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 285131890f4aSPhilipp Reisner const int apv = mdev->tconn->agreed_pro_version; 2852778f271dSPhilipp Reisner int *rs_plan_s = NULL; 2853778f271dSPhilipp Reisner int fifo_size = 0; 2854b411b363SPhilipp Reisner 2855b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 2856b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 2857b411b363SPhilipp Reisner + SHARED_SECRET_MAX 28588e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 28598e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 2860b411b363SPhilipp Reisner 286102918be2SPhilipp Reisner if (packet_size > exp_max_sz) { 2862b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 286302918be2SPhilipp Reisner packet_size, exp_max_sz); 286481e84650SAndreas Gruenbacher return false; 2865b411b363SPhilipp Reisner } 2866b411b363SPhilipp Reisner 2867b411b363SPhilipp Reisner if (apv <= 88) { 2868257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param) - sizeof(struct p_header); 286902918be2SPhilipp Reisner data_size = packet_size - header_size; 28708e26f9ccSPhilipp Reisner } else if (apv <= 94) { 2871257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header); 287202918be2SPhilipp Reisner data_size = packet_size - header_size; 2873b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 28748e26f9ccSPhilipp Reisner } else { 2875257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header); 287602918be2SPhilipp Reisner data_size = packet_size - header_size; 2877b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 2878b411b363SPhilipp Reisner } 2879b411b363SPhilipp Reisner 2880b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 2881b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 2882b411b363SPhilipp Reisner 2883de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, &p->head.payload, header_size) != header_size) 288481e84650SAndreas Gruenbacher return false; 2885b411b363SPhilipp Reisner 2886b411b363SPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 2887b411b363SPhilipp Reisner 2888b411b363SPhilipp Reisner if (apv >= 88) { 2889b411b363SPhilipp Reisner if (apv == 88) { 2890b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 2891b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 2892b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 2893b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 289481e84650SAndreas Gruenbacher return false; 2895b411b363SPhilipp Reisner } 2896b411b363SPhilipp Reisner 2897de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, p->verify_alg, data_size) != data_size) 289881e84650SAndreas Gruenbacher return false; 2899b411b363SPhilipp Reisner 2900b411b363SPhilipp Reisner /* we expect NUL terminated string */ 2901b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2902b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 2903b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 2904b411b363SPhilipp Reisner 2905b411b363SPhilipp Reisner } else /* apv >= 89 */ { 2906b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 2907b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2908b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 2909b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 2910b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 2911b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 2912b411b363SPhilipp Reisner } 2913b411b363SPhilipp Reisner 2914b411b363SPhilipp Reisner if (strcmp(mdev->sync_conf.verify_alg, p->verify_alg)) { 2915b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2916b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 2917b411b363SPhilipp Reisner mdev->sync_conf.verify_alg, p->verify_alg); 2918b411b363SPhilipp Reisner goto disconnect; 2919b411b363SPhilipp Reisner } 2920b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 2921b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 2922b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 2923b411b363SPhilipp Reisner verify_tfm = NULL; 2924b411b363SPhilipp Reisner goto disconnect; 2925b411b363SPhilipp Reisner } 2926b411b363SPhilipp Reisner } 2927b411b363SPhilipp Reisner 2928b411b363SPhilipp Reisner if (apv >= 89 && strcmp(mdev->sync_conf.csums_alg, p->csums_alg)) { 2929b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2930b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 2931b411b363SPhilipp Reisner mdev->sync_conf.csums_alg, p->csums_alg); 2932b411b363SPhilipp Reisner goto disconnect; 2933b411b363SPhilipp Reisner } 2934b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 2935b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 2936b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 2937b411b363SPhilipp Reisner csums_tfm = NULL; 2938b411b363SPhilipp Reisner goto disconnect; 2939b411b363SPhilipp Reisner } 2940b411b363SPhilipp Reisner } 2941b411b363SPhilipp Reisner 29428e26f9ccSPhilipp Reisner if (apv > 94) { 29438e26f9ccSPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 29448e26f9ccSPhilipp Reisner mdev->sync_conf.c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 29458e26f9ccSPhilipp Reisner mdev->sync_conf.c_delay_target = be32_to_cpu(p->c_delay_target); 29468e26f9ccSPhilipp Reisner mdev->sync_conf.c_fill_target = be32_to_cpu(p->c_fill_target); 29478e26f9ccSPhilipp Reisner mdev->sync_conf.c_max_rate = be32_to_cpu(p->c_max_rate); 2948778f271dSPhilipp Reisner 2949778f271dSPhilipp Reisner fifo_size = (mdev->sync_conf.c_plan_ahead * 10 * SLEEP_TIME) / HZ; 2950778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) { 2951778f271dSPhilipp Reisner rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL); 2952778f271dSPhilipp Reisner if (!rs_plan_s) { 2953778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 2954778f271dSPhilipp Reisner goto disconnect; 2955778f271dSPhilipp Reisner } 2956778f271dSPhilipp Reisner } 29578e26f9ccSPhilipp Reisner } 2958b411b363SPhilipp Reisner 2959b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 2960b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 2961b411b363SPhilipp Reisner if (verify_tfm) { 2962b411b363SPhilipp Reisner strcpy(mdev->sync_conf.verify_alg, p->verify_alg); 2963b411b363SPhilipp Reisner mdev->sync_conf.verify_alg_len = strlen(p->verify_alg) + 1; 2964b411b363SPhilipp Reisner crypto_free_hash(mdev->verify_tfm); 2965b411b363SPhilipp Reisner mdev->verify_tfm = verify_tfm; 2966b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 2967b411b363SPhilipp Reisner } 2968b411b363SPhilipp Reisner if (csums_tfm) { 2969b411b363SPhilipp Reisner strcpy(mdev->sync_conf.csums_alg, p->csums_alg); 2970b411b363SPhilipp Reisner mdev->sync_conf.csums_alg_len = strlen(p->csums_alg) + 1; 2971b411b363SPhilipp Reisner crypto_free_hash(mdev->csums_tfm); 2972b411b363SPhilipp Reisner mdev->csums_tfm = csums_tfm; 2973b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 2974b411b363SPhilipp Reisner } 2975778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size) { 2976778f271dSPhilipp Reisner kfree(mdev->rs_plan_s.values); 2977778f271dSPhilipp Reisner mdev->rs_plan_s.values = rs_plan_s; 2978778f271dSPhilipp Reisner mdev->rs_plan_s.size = fifo_size; 2979778f271dSPhilipp Reisner mdev->rs_planed = 0; 2980778f271dSPhilipp Reisner } 2981b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 2982b411b363SPhilipp Reisner } 2983b411b363SPhilipp Reisner 2984b411b363SPhilipp Reisner return ok; 2985b411b363SPhilipp Reisner disconnect: 2986b411b363SPhilipp Reisner /* just for completeness: actually not needed, 2987b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 2988b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 2989b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 2990b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 2991b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 299281e84650SAndreas Gruenbacher return false; 2993b411b363SPhilipp Reisner } 2994b411b363SPhilipp Reisner 2995b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 2996b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 2997b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 2998b411b363SPhilipp Reisner { 2999b411b363SPhilipp Reisner sector_t d; 3000b411b363SPhilipp Reisner if (a == 0 || b == 0) 3001b411b363SPhilipp Reisner return; 3002b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3003b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3004b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3005b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3006b411b363SPhilipp Reisner } 3007b411b363SPhilipp Reisner 3008d8763023SAndreas Gruenbacher static int receive_sizes(struct drbd_conf *mdev, enum drbd_packet cmd, 3009d8763023SAndreas Gruenbacher unsigned int data_size) 3010b411b363SPhilipp Reisner { 3011e42325a5SPhilipp Reisner struct p_sizes *p = &mdev->tconn->data.rbuf.sizes; 3012b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3013b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3014b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3015e89b591cSPhilipp Reisner enum dds_flags ddsf; 3016b411b363SPhilipp Reisner 3017b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3018b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3019b411b363SPhilipp Reisner 3020b411b363SPhilipp Reisner if (p_size == 0 && mdev->state.disk == D_DISKLESS) { 3021b411b363SPhilipp Reisner dev_err(DEV, "some backing storage is needed\n"); 3022b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 302381e84650SAndreas Gruenbacher return false; 3024b411b363SPhilipp Reisner } 3025b411b363SPhilipp Reisner 3026b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3027b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3028b411b363SPhilipp Reisner mdev->p_size = p_size; 3029b411b363SPhilipp Reisner 3030b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3031b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3032b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3033b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3034b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 3035b411b363SPhilipp Reisner 3036b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3037b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3038b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3039b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 3040b411b363SPhilipp Reisner p_usize); 3041b411b363SPhilipp Reisner 3042b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 3043b411b363SPhilipp Reisner 3044b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 3045b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 3046b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3047b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 3048b411b363SPhilipp Reisner } 3049b411b363SPhilipp Reisner 3050b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3051b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3052a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 3053b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3054b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3055b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3056b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 3057b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3058b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 3059b411b363SPhilipp Reisner put_ldev(mdev); 306081e84650SAndreas Gruenbacher return false; 3061b411b363SPhilipp Reisner } 3062b411b363SPhilipp Reisner put_ldev(mdev); 3063b411b363SPhilipp Reisner } 3064b411b363SPhilipp Reisner 3065e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3066b411b363SPhilipp Reisner if (get_ldev(mdev)) { 306724c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3068b411b363SPhilipp Reisner put_ldev(mdev); 3069b411b363SPhilipp Reisner if (dd == dev_size_error) 307081e84650SAndreas Gruenbacher return false; 3071b411b363SPhilipp Reisner drbd_md_sync(mdev); 3072b411b363SPhilipp Reisner } else { 3073b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3074b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3075b411b363SPhilipp Reisner } 3076b411b363SPhilipp Reisner 307799432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 307899432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 307999432fccSPhilipp Reisner 3080b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3081b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3082b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3083b411b363SPhilipp Reisner ldsc = 1; 3084b411b363SPhilipp Reisner } 3085b411b363SPhilipp Reisner 3086b411b363SPhilipp Reisner put_ldev(mdev); 3087b411b363SPhilipp Reisner } 3088b411b363SPhilipp Reisner 3089b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3090b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3091b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3092b411b363SPhilipp Reisner /* we have different sizes, probably peer 3093b411b363SPhilipp Reisner * needs to know my new size... */ 3094e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3095b411b363SPhilipp Reisner } 3096b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3097b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3098b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3099e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3100e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3101e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3102b411b363SPhilipp Reisner else 3103e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3104e89b591cSPhilipp Reisner } else 3105b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3106b411b363SPhilipp Reisner } 3107b411b363SPhilipp Reisner } 3108b411b363SPhilipp Reisner 310981e84650SAndreas Gruenbacher return true; 3110b411b363SPhilipp Reisner } 3111b411b363SPhilipp Reisner 3112d8763023SAndreas Gruenbacher static int receive_uuids(struct drbd_conf *mdev, enum drbd_packet cmd, 3113d8763023SAndreas Gruenbacher unsigned int data_size) 3114b411b363SPhilipp Reisner { 3115e42325a5SPhilipp Reisner struct p_uuids *p = &mdev->tconn->data.rbuf.uuids; 3116b411b363SPhilipp Reisner u64 *p_uuid; 311762b0da3aSLars Ellenberg int i, updated_uuids = 0; 3118b411b363SPhilipp Reisner 3119b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3120b411b363SPhilipp Reisner 3121b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3122b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3123b411b363SPhilipp Reisner 3124b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3125b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3126b411b363SPhilipp Reisner 3127b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3128b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3129b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3130b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3131b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3132b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 3133b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 313481e84650SAndreas Gruenbacher return false; 3135b411b363SPhilipp Reisner } 3136b411b363SPhilipp Reisner 3137b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3138b411b363SPhilipp Reisner int skip_initial_sync = 3139b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 314031890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3141b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3142b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3143b411b363SPhilipp Reisner if (skip_initial_sync) { 3144b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3145b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 314620ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 314720ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3148b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3149b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3150b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3151b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3152b411b363SPhilipp Reisner drbd_md_sync(mdev); 315362b0da3aSLars Ellenberg updated_uuids = 1; 3154b411b363SPhilipp Reisner } 3155b411b363SPhilipp Reisner put_ldev(mdev); 315618a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 315718a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 315818a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 315918a50fa2SPhilipp Reisner for me. */ 316062b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3161b411b363SPhilipp Reisner } 3162b411b363SPhilipp Reisner 3163b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3164b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3165b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3166b411b363SPhilipp Reisner new disk state... */ 3167b411b363SPhilipp Reisner wait_event(mdev->misc_wait, !test_bit(CLUSTER_ST_CHANGE, &mdev->flags)); 3168b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 316962b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 317062b0da3aSLars Ellenberg 317162b0da3aSLars Ellenberg if (updated_uuids) 317262b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3173b411b363SPhilipp Reisner 317481e84650SAndreas Gruenbacher return true; 3175b411b363SPhilipp Reisner } 3176b411b363SPhilipp Reisner 3177b411b363SPhilipp Reisner /** 3178b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3179b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3180b411b363SPhilipp Reisner */ 3181b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3182b411b363SPhilipp Reisner { 3183b411b363SPhilipp Reisner union drbd_state ms; 3184b411b363SPhilipp Reisner 3185b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3186b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3187b411b363SPhilipp Reisner 3188b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3189b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3190b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3191b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3192b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3193b411b363SPhilipp Reisner }; 3194b411b363SPhilipp Reisner 3195b411b363SPhilipp Reisner ms.i = ps.i; 3196b411b363SPhilipp Reisner 3197b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3198b411b363SPhilipp Reisner ms.peer = ps.role; 3199b411b363SPhilipp Reisner ms.role = ps.peer; 3200b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3201b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3202b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3203b411b363SPhilipp Reisner 3204b411b363SPhilipp Reisner return ms; 3205b411b363SPhilipp Reisner } 3206b411b363SPhilipp Reisner 3207d8763023SAndreas Gruenbacher static int receive_req_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3208d8763023SAndreas Gruenbacher unsigned int data_size) 3209b411b363SPhilipp Reisner { 3210e42325a5SPhilipp Reisner struct p_req_state *p = &mdev->tconn->data.rbuf.req_state; 3211b411b363SPhilipp Reisner union drbd_state mask, val; 3212bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3213b411b363SPhilipp Reisner 3214b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3215b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3216b411b363SPhilipp Reisner 321725703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 3218b411b363SPhilipp Reisner test_bit(CLUSTER_ST_CHANGE, &mdev->flags)) { 3219b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 322081e84650SAndreas Gruenbacher return true; 3221b411b363SPhilipp Reisner } 3222b411b363SPhilipp Reisner 3223b411b363SPhilipp Reisner mask = convert_state(mask); 3224b411b363SPhilipp Reisner val = convert_state(val); 3225b411b363SPhilipp Reisner 3226b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3227b411b363SPhilipp Reisner 3228b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3229b411b363SPhilipp Reisner drbd_md_sync(mdev); 3230b411b363SPhilipp Reisner 323181e84650SAndreas Gruenbacher return true; 3232b411b363SPhilipp Reisner } 3233b411b363SPhilipp Reisner 3234d8763023SAndreas Gruenbacher static int receive_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3235d8763023SAndreas Gruenbacher unsigned int data_size) 3236b411b363SPhilipp Reisner { 3237e42325a5SPhilipp Reisner struct p_state *p = &mdev->tconn->data.rbuf.state; 32384ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3239b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 324065d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3241b411b363SPhilipp Reisner int rv; 3242b411b363SPhilipp Reisner 3243b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3244b411b363SPhilipp Reisner 3245b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3246b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3247b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3248b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3249b411b363SPhilipp Reisner } 3250b411b363SPhilipp Reisner 325187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3252b411b363SPhilipp Reisner retry: 32534ac4aadaSLars Ellenberg os = ns = mdev->state; 325487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3255b411b363SPhilipp Reisner 3256e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3257e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3258e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3259e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3260e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3261e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3262e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3263e9ef7bb6SLars Ellenberg * syncing states. 3264e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3265e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3266e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3267e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3268e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3269e9ef7bb6SLars Ellenberg 3270e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3271e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3272e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3273e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3274e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3275e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3276e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 327781e84650SAndreas Gruenbacher return true; 3278e9ef7bb6SLars Ellenberg } 3279e9ef7bb6SLars Ellenberg } 3280e9ef7bb6SLars Ellenberg 3281e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3282e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3283e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3284e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3285e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3286e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3287e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3288e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3289e9ef7bb6SLars Ellenberg 32904ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 32914ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3292b411b363SPhilipp Reisner 329367531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 329467531718SPhilipp Reisner ns.conn = C_BEHIND; 329567531718SPhilipp Reisner 3296b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3297b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3298b411b363SPhilipp Reisner int cr; /* consider resync */ 3299b411b363SPhilipp Reisner 3300b411b363SPhilipp Reisner /* if we established a new connection */ 33014ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3302b411b363SPhilipp Reisner /* if we had an established connection 3303b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 33044ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3305b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 33064ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3307b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3308b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3309b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3310b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3311b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 33124ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3313b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3314b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3315b411b363SPhilipp Reisner 3316b411b363SPhilipp Reisner if (cr) 33174ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3318b411b363SPhilipp Reisner 3319b411b363SPhilipp Reisner put_ldev(mdev); 33204ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 33214ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3322b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 332382f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3324b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3325b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3326b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3327580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3328b411b363SPhilipp Reisner } else { 3329cf14c2e9SPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->flags)) 333081e84650SAndreas Gruenbacher return false; 33314ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 3332b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 333381e84650SAndreas Gruenbacher return false; 3334b411b363SPhilipp Reisner } 3335b411b363SPhilipp Reisner } 3336b411b363SPhilipp Reisner } 3337b411b363SPhilipp Reisner 333887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 33394ac4aadaSLars Ellenberg if (mdev->state.i != os.i) 3340b411b363SPhilipp Reisner goto retry; 3341b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3342b411b363SPhilipp Reisner ns.peer = peer_state.role; 3343b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3344b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 33454ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3346b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 33474ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 33484ac4aadaSLars Ellenberg if (ns.pdsk == D_CONSISTENT && is_susp(ns) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3349481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 33508554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3351481c6f50SPhilipp Reisner for temporal network outages! */ 335287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3353481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 3354481c6f50SPhilipp Reisner tl_clear(mdev); 3355481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3356481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 3357481c6f50SPhilipp Reisner drbd_force_state(mdev, NS2(conn, C_PROTOCOL_ERROR, susp, 0)); 335881e84650SAndreas Gruenbacher return false; 3359481c6f50SPhilipp Reisner } 336065d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 3361b411b363SPhilipp Reisner ns = mdev->state; 336287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3363b411b363SPhilipp Reisner 3364b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 3365b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 336681e84650SAndreas Gruenbacher return false; 3367b411b363SPhilipp Reisner } 3368b411b363SPhilipp Reisner 33694ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 33704ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3371b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3372b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3373b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3374b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3375b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3376b411b363SPhilipp Reisner drbd_send_state(mdev); 3377b411b363SPhilipp Reisner } 3378b411b363SPhilipp Reisner } 3379b411b363SPhilipp Reisner 338089e58e75SPhilipp Reisner mdev->tconn->net_conf->want_lose = 0; 3381b411b363SPhilipp Reisner 3382b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3383b411b363SPhilipp Reisner 338481e84650SAndreas Gruenbacher return true; 3385b411b363SPhilipp Reisner } 3386b411b363SPhilipp Reisner 3387d8763023SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_conf *mdev, enum drbd_packet cmd, 3388d8763023SAndreas Gruenbacher unsigned int data_size) 3389b411b363SPhilipp Reisner { 3390e42325a5SPhilipp Reisner struct p_rs_uuid *p = &mdev->tconn->data.rbuf.rs_uuid; 3391b411b363SPhilipp Reisner 3392b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3393b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3394c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3395b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3396b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3397b411b363SPhilipp Reisner 3398b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3399b411b363SPhilipp Reisner 3400b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3401b411b363SPhilipp Reisner _not_ be rotated into the history */ 3402b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3403b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3404b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3405b411b363SPhilipp Reisner 340662b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3407b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3408b411b363SPhilipp Reisner 3409b411b363SPhilipp Reisner put_ldev(mdev); 3410b411b363SPhilipp Reisner } else 3411b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3412b411b363SPhilipp Reisner 341381e84650SAndreas Gruenbacher return true; 3414b411b363SPhilipp Reisner } 3415b411b363SPhilipp Reisner 34162c46407dSAndreas Gruenbacher /** 34172c46407dSAndreas Gruenbacher * receive_bitmap_plain 34182c46407dSAndreas Gruenbacher * 34192c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 34202c46407dSAndreas Gruenbacher * code upon failure. 34212c46407dSAndreas Gruenbacher */ 34222c46407dSAndreas Gruenbacher static int 342302918be2SPhilipp Reisner receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size, 3424b411b363SPhilipp Reisner unsigned long *buffer, struct bm_xfer_ctx *c) 3425b411b363SPhilipp Reisner { 3426b411b363SPhilipp Reisner unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset); 3427b411b363SPhilipp Reisner unsigned want = num_words * sizeof(long); 34282c46407dSAndreas Gruenbacher int err; 3429b411b363SPhilipp Reisner 343002918be2SPhilipp Reisner if (want != data_size) { 343102918be2SPhilipp Reisner dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size); 34322c46407dSAndreas Gruenbacher return -EIO; 3433b411b363SPhilipp Reisner } 3434b411b363SPhilipp Reisner if (want == 0) 34352c46407dSAndreas Gruenbacher return 0; 3436de0ff338SPhilipp Reisner err = drbd_recv(mdev->tconn, buffer, want); 34372c46407dSAndreas Gruenbacher if (err != want) { 34382c46407dSAndreas Gruenbacher if (err >= 0) 34392c46407dSAndreas Gruenbacher err = -EIO; 34402c46407dSAndreas Gruenbacher return err; 34412c46407dSAndreas Gruenbacher } 3442b411b363SPhilipp Reisner 3443b411b363SPhilipp Reisner drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer); 3444b411b363SPhilipp Reisner 3445b411b363SPhilipp Reisner c->word_offset += num_words; 3446b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3447b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3448b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3449b411b363SPhilipp Reisner 34502c46407dSAndreas Gruenbacher return 1; 3451b411b363SPhilipp Reisner } 3452b411b363SPhilipp Reisner 34532c46407dSAndreas Gruenbacher /** 34542c46407dSAndreas Gruenbacher * recv_bm_rle_bits 34552c46407dSAndreas Gruenbacher * 34562c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 34572c46407dSAndreas Gruenbacher * code upon failure. 34582c46407dSAndreas Gruenbacher */ 34592c46407dSAndreas Gruenbacher static int 3460b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3461b411b363SPhilipp Reisner struct p_compressed_bm *p, 3462c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3463c6d25cfeSPhilipp Reisner unsigned int len) 3464b411b363SPhilipp Reisner { 3465b411b363SPhilipp Reisner struct bitstream bs; 3466b411b363SPhilipp Reisner u64 look_ahead; 3467b411b363SPhilipp Reisner u64 rl; 3468b411b363SPhilipp Reisner u64 tmp; 3469b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3470b411b363SPhilipp Reisner unsigned long e; 3471b411b363SPhilipp Reisner int toggle = DCBP_get_start(p); 3472b411b363SPhilipp Reisner int have; 3473b411b363SPhilipp Reisner int bits; 3474b411b363SPhilipp Reisner 3475b411b363SPhilipp Reisner bitstream_init(&bs, p->code, len, DCBP_get_pad_bits(p)); 3476b411b363SPhilipp Reisner 3477b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3478b411b363SPhilipp Reisner if (bits < 0) 34792c46407dSAndreas Gruenbacher return -EIO; 3480b411b363SPhilipp Reisner 3481b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3482b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3483b411b363SPhilipp Reisner if (bits <= 0) 34842c46407dSAndreas Gruenbacher return -EIO; 3485b411b363SPhilipp Reisner 3486b411b363SPhilipp Reisner if (toggle) { 3487b411b363SPhilipp Reisner e = s + rl -1; 3488b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3489b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 34902c46407dSAndreas Gruenbacher return -EIO; 3491b411b363SPhilipp Reisner } 3492b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3493b411b363SPhilipp Reisner } 3494b411b363SPhilipp Reisner 3495b411b363SPhilipp Reisner if (have < bits) { 3496b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3497b411b363SPhilipp Reisner have, bits, look_ahead, 3498b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3499b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 35002c46407dSAndreas Gruenbacher return -EIO; 3501b411b363SPhilipp Reisner } 3502b411b363SPhilipp Reisner look_ahead >>= bits; 3503b411b363SPhilipp Reisner have -= bits; 3504b411b363SPhilipp Reisner 3505b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3506b411b363SPhilipp Reisner if (bits < 0) 35072c46407dSAndreas Gruenbacher return -EIO; 3508b411b363SPhilipp Reisner look_ahead |= tmp << have; 3509b411b363SPhilipp Reisner have += bits; 3510b411b363SPhilipp Reisner } 3511b411b363SPhilipp Reisner 3512b411b363SPhilipp Reisner c->bit_offset = s; 3513b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3514b411b363SPhilipp Reisner 35152c46407dSAndreas Gruenbacher return (s != c->bm_bits); 3516b411b363SPhilipp Reisner } 3517b411b363SPhilipp Reisner 35182c46407dSAndreas Gruenbacher /** 35192c46407dSAndreas Gruenbacher * decode_bitmap_c 35202c46407dSAndreas Gruenbacher * 35212c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 35222c46407dSAndreas Gruenbacher * code upon failure. 35232c46407dSAndreas Gruenbacher */ 35242c46407dSAndreas Gruenbacher static int 3525b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3526b411b363SPhilipp Reisner struct p_compressed_bm *p, 3527c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3528c6d25cfeSPhilipp Reisner unsigned int len) 3529b411b363SPhilipp Reisner { 3530b411b363SPhilipp Reisner if (DCBP_get_code(p) == RLE_VLI_Bits) 3531c6d25cfeSPhilipp Reisner return recv_bm_rle_bits(mdev, p, c, len); 3532b411b363SPhilipp Reisner 3533b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3534b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3535b411b363SPhilipp Reisner * during all our tests. */ 3536b411b363SPhilipp Reisner 3537b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 3538b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 35392c46407dSAndreas Gruenbacher return -EIO; 3540b411b363SPhilipp Reisner } 3541b411b363SPhilipp Reisner 3542b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3543b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3544b411b363SPhilipp Reisner { 3545b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 3546c012949aSPhilipp Reisner unsigned plain = sizeof(struct p_header) * 3547b411b363SPhilipp Reisner ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1) 3548b411b363SPhilipp Reisner + c->bm_words * sizeof(long); 3549b411b363SPhilipp Reisner unsigned total = c->bytes[0] + c->bytes[1]; 3550b411b363SPhilipp Reisner unsigned r; 3551b411b363SPhilipp Reisner 3552b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3553b411b363SPhilipp Reisner if (total == 0) 3554b411b363SPhilipp Reisner return; 3555b411b363SPhilipp Reisner 3556b411b363SPhilipp Reisner /* don't report if not compressed */ 3557b411b363SPhilipp Reisner if (total >= plain) 3558b411b363SPhilipp Reisner return; 3559b411b363SPhilipp Reisner 3560b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3561b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3562b411b363SPhilipp Reisner : (1000 * total / plain); 3563b411b363SPhilipp Reisner 3564b411b363SPhilipp Reisner if (r > 1000) 3565b411b363SPhilipp Reisner r = 1000; 3566b411b363SPhilipp Reisner 3567b411b363SPhilipp Reisner r = 1000 - r; 3568b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3569b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3570b411b363SPhilipp Reisner direction, 3571b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3572b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3573b411b363SPhilipp Reisner total, r/10, r % 10); 3574b411b363SPhilipp Reisner } 3575b411b363SPhilipp Reisner 3576b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3577b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3578b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3579b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3580b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3581b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3582b411b363SPhilipp Reisner 3583b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 3584d8763023SAndreas Gruenbacher static int receive_bitmap(struct drbd_conf *mdev, enum drbd_packet cmd, 3585d8763023SAndreas Gruenbacher unsigned int data_size) 3586b411b363SPhilipp Reisner { 3587b411b363SPhilipp Reisner struct bm_xfer_ctx c; 3588b411b363SPhilipp Reisner void *buffer; 35892c46407dSAndreas Gruenbacher int err; 359081e84650SAndreas Gruenbacher int ok = false; 3591257d0af6SPhilipp Reisner struct p_header *h = &mdev->tconn->data.rbuf.header; 359277351055SPhilipp Reisner struct packet_info pi; 3593b411b363SPhilipp Reisner 359420ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 359520ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 359620ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 3597b411b363SPhilipp Reisner 3598b411b363SPhilipp Reisner /* maybe we should use some per thread scratch page, 3599b411b363SPhilipp Reisner * and allocate that during initial device creation? */ 3600b411b363SPhilipp Reisner buffer = (unsigned long *) __get_free_page(GFP_NOIO); 3601b411b363SPhilipp Reisner if (!buffer) { 3602b411b363SPhilipp Reisner dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__); 3603b411b363SPhilipp Reisner goto out; 3604b411b363SPhilipp Reisner } 3605b411b363SPhilipp Reisner 3606b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3607b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3608b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3609b411b363SPhilipp Reisner }; 3610b411b363SPhilipp Reisner 36112c46407dSAndreas Gruenbacher for(;;) { 361202918be2SPhilipp Reisner if (cmd == P_BITMAP) { 36132c46407dSAndreas Gruenbacher err = receive_bitmap_plain(mdev, data_size, buffer, &c); 361402918be2SPhilipp Reisner } else if (cmd == P_COMPRESSED_BITMAP) { 3615b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3616b411b363SPhilipp Reisner * and the feature is enabled! */ 3617b411b363SPhilipp Reisner struct p_compressed_bm *p; 3618b411b363SPhilipp Reisner 361902918be2SPhilipp Reisner if (data_size > BM_PACKET_PAYLOAD_BYTES) { 3620b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 3621b411b363SPhilipp Reisner goto out; 3622b411b363SPhilipp Reisner } 3623b411b363SPhilipp Reisner /* use the page buff */ 3624b411b363SPhilipp Reisner p = buffer; 3625b411b363SPhilipp Reisner memcpy(p, h, sizeof(*h)); 3626de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, p->head.payload, data_size) != data_size) 3627b411b363SPhilipp Reisner goto out; 3628004352faSLars Ellenberg if (data_size <= (sizeof(*p) - sizeof(p->head))) { 3629004352faSLars Ellenberg dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", data_size); 363078fcbdaeSAndreas Gruenbacher goto out; 3631b411b363SPhilipp Reisner } 3632c6d25cfeSPhilipp Reisner err = decode_bitmap_c(mdev, p, &c, data_size); 3633b411b363SPhilipp Reisner } else { 363402918be2SPhilipp Reisner dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", cmd); 3635b411b363SPhilipp Reisner goto out; 3636b411b363SPhilipp Reisner } 3637b411b363SPhilipp Reisner 363802918be2SPhilipp Reisner c.packets[cmd == P_BITMAP]++; 3639257d0af6SPhilipp Reisner c.bytes[cmd == P_BITMAP] += sizeof(struct p_header) + data_size; 3640b411b363SPhilipp Reisner 36412c46407dSAndreas Gruenbacher if (err <= 0) { 36422c46407dSAndreas Gruenbacher if (err < 0) 36432c46407dSAndreas Gruenbacher goto out; 3644b411b363SPhilipp Reisner break; 36452c46407dSAndreas Gruenbacher } 36469ba7aa00SPhilipp Reisner if (!drbd_recv_header(mdev->tconn, &pi)) 3647b411b363SPhilipp Reisner goto out; 364877351055SPhilipp Reisner cmd = pi.cmd; 364977351055SPhilipp Reisner data_size = pi.size; 36502c46407dSAndreas Gruenbacher } 3651b411b363SPhilipp Reisner 3652b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3653b411b363SPhilipp Reisner 3654b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3655de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 3656de1f8e4aSAndreas Gruenbacher 3657b411b363SPhilipp Reisner ok = !drbd_send_bitmap(mdev); 3658b411b363SPhilipp Reisner if (!ok) 3659b411b363SPhilipp Reisner goto out; 3660b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3661de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3662de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 3663b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3664b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3665b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3666b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3667b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3668b411b363SPhilipp Reisner } 3669b411b363SPhilipp Reisner 367081e84650SAndreas Gruenbacher ok = true; 3671b411b363SPhilipp Reisner out: 367220ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 3673b411b363SPhilipp Reisner if (ok && mdev->state.conn == C_WF_BITMAP_S) 3674b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 3675b411b363SPhilipp Reisner free_page((unsigned long) buffer); 3676b411b363SPhilipp Reisner return ok; 3677b411b363SPhilipp Reisner } 3678b411b363SPhilipp Reisner 3679d8763023SAndreas Gruenbacher static int receive_skip(struct drbd_conf *mdev, enum drbd_packet cmd, 3680d8763023SAndreas Gruenbacher unsigned int data_size) 3681b411b363SPhilipp Reisner { 3682b411b363SPhilipp Reisner /* TODO zero copy sink :) */ 3683b411b363SPhilipp Reisner static char sink[128]; 3684b411b363SPhilipp Reisner int size, want, r; 3685b411b363SPhilipp Reisner 3686b411b363SPhilipp Reisner dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n", 368702918be2SPhilipp Reisner cmd, data_size); 3688b411b363SPhilipp Reisner 368902918be2SPhilipp Reisner size = data_size; 3690b411b363SPhilipp Reisner while (size > 0) { 3691b411b363SPhilipp Reisner want = min_t(int, size, sizeof(sink)); 3692de0ff338SPhilipp Reisner r = drbd_recv(mdev->tconn, sink, want); 3693841ce241SAndreas Gruenbacher if (!expect(r > 0)) 3694841ce241SAndreas Gruenbacher break; 3695b411b363SPhilipp Reisner size -= r; 3696b411b363SPhilipp Reisner } 3697b411b363SPhilipp Reisner return size == 0; 3698b411b363SPhilipp Reisner } 3699b411b363SPhilipp Reisner 3700d8763023SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packet cmd, 3701d8763023SAndreas Gruenbacher unsigned int data_size) 3702b411b363SPhilipp Reisner { 3703b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3704b411b363SPhilipp Reisner * with the data requests being unplugged */ 3705e42325a5SPhilipp Reisner drbd_tcp_quickack(mdev->tconn->data.socket); 3706b411b363SPhilipp Reisner 370781e84650SAndreas Gruenbacher return true; 3708b411b363SPhilipp Reisner } 3709b411b363SPhilipp Reisner 3710d8763023SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_conf *mdev, enum drbd_packet cmd, 3711d8763023SAndreas Gruenbacher unsigned int data_size) 371273a01a18SPhilipp Reisner { 3713e42325a5SPhilipp Reisner struct p_block_desc *p = &mdev->tconn->data.rbuf.block_desc; 371473a01a18SPhilipp Reisner 3715f735e363SLars Ellenberg switch (mdev->state.conn) { 3716f735e363SLars Ellenberg case C_WF_SYNC_UUID: 3717f735e363SLars Ellenberg case C_WF_BITMAP_T: 3718f735e363SLars Ellenberg case C_BEHIND: 3719f735e363SLars Ellenberg break; 3720f735e363SLars Ellenberg default: 3721f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 3722f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 3723f735e363SLars Ellenberg } 3724f735e363SLars Ellenberg 372573a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 372673a01a18SPhilipp Reisner 372781e84650SAndreas Gruenbacher return true; 372873a01a18SPhilipp Reisner } 372973a01a18SPhilipp Reisner 3730d8763023SAndreas Gruenbacher typedef int (*drbd_cmd_handler_f)(struct drbd_conf *, enum drbd_packet cmd, 3731d8763023SAndreas Gruenbacher unsigned int to_receive); 3732b411b363SPhilipp Reisner 373302918be2SPhilipp Reisner struct data_cmd { 373402918be2SPhilipp Reisner int expect_payload; 373502918be2SPhilipp Reisner size_t pkt_size; 373602918be2SPhilipp Reisner drbd_cmd_handler_f function; 3737b411b363SPhilipp Reisner }; 3738b411b363SPhilipp Reisner 373902918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 374002918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 374102918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 374202918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 374302918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 3744257d0af6SPhilipp Reisner [P_BITMAP] = { 1, sizeof(struct p_header), receive_bitmap } , 3745257d0af6SPhilipp Reisner [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header), receive_bitmap } , 3746257d0af6SPhilipp Reisner [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header), receive_UnplugRemote }, 374702918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 374802918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 3749257d0af6SPhilipp Reisner [P_SYNC_PARAM] = { 1, sizeof(struct p_header), receive_SyncParam }, 3750257d0af6SPhilipp Reisner [P_SYNC_PARAM89] = { 1, sizeof(struct p_header), receive_SyncParam }, 375102918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 375202918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 375302918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 375402918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 375502918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 375602918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 375702918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 375802918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 375902918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 376002918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 376173a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 376202918be2SPhilipp Reisner /* anything missing from this table is in 376302918be2SPhilipp Reisner * the asender_tbl, see get_asender_cmd */ 376402918be2SPhilipp Reisner [P_MAX_CMD] = { 0, 0, NULL }, 376502918be2SPhilipp Reisner }; 376602918be2SPhilipp Reisner 376702918be2SPhilipp Reisner /* All handler functions that expect a sub-header get that sub-heder in 3768e42325a5SPhilipp Reisner mdev->tconn->data.rbuf.header.head.payload. 376902918be2SPhilipp Reisner 3770e42325a5SPhilipp Reisner Usually in mdev->tconn->data.rbuf.header.head the callback can find the usual 377102918be2SPhilipp Reisner p_header, but they may not rely on that. Since there is also p_header95 ! 377202918be2SPhilipp Reisner */ 3773b411b363SPhilipp Reisner 3774b411b363SPhilipp Reisner static void drbdd(struct drbd_conf *mdev) 3775b411b363SPhilipp Reisner { 3776c012949aSPhilipp Reisner struct p_header *header = &mdev->tconn->data.rbuf.header; 377777351055SPhilipp Reisner struct packet_info pi; 377802918be2SPhilipp Reisner size_t shs; /* sub header size */ 377902918be2SPhilipp Reisner int rv; 3780b411b363SPhilipp Reisner 3781e6b3ea83SPhilipp Reisner while (get_t_state(&mdev->tconn->receiver) == RUNNING) { 3782bc31fe33SPhilipp Reisner drbd_thread_current_set_cpu(mdev, &mdev->tconn->receiver); 37839ba7aa00SPhilipp Reisner if (!drbd_recv_header(mdev->tconn, &pi)) 378402918be2SPhilipp Reisner goto err_out; 378502918be2SPhilipp Reisner 378677351055SPhilipp Reisner if (unlikely(pi.cmd >= P_MAX_CMD || !drbd_cmd_handler[pi.cmd].function)) { 378777351055SPhilipp Reisner dev_err(DEV, "unknown packet type %d, l: %d!\n", pi.cmd, pi.size); 378802918be2SPhilipp Reisner goto err_out; 37890b33a916SLars Ellenberg } 3790b411b363SPhilipp Reisner 379177351055SPhilipp Reisner shs = drbd_cmd_handler[pi.cmd].pkt_size - sizeof(struct p_header); 379277351055SPhilipp Reisner if (pi.size - shs > 0 && !drbd_cmd_handler[pi.cmd].expect_payload) { 379377351055SPhilipp Reisner dev_err(DEV, "No payload expected %s l:%d\n", cmdname(pi.cmd), pi.size); 3794c13f7e1aSLars Ellenberg goto err_out; 3795c13f7e1aSLars Ellenberg } 3796c13f7e1aSLars Ellenberg 3797c13f7e1aSLars Ellenberg if (shs) { 3798de0ff338SPhilipp Reisner rv = drbd_recv(mdev->tconn, &header->payload, shs); 379902918be2SPhilipp Reisner if (unlikely(rv != shs)) { 38000ddc5549SLars Ellenberg if (!signal_pending(current)) 38010ddc5549SLars Ellenberg dev_warn(DEV, "short read while reading sub header: rv=%d\n", rv); 380202918be2SPhilipp Reisner goto err_out; 3803b411b363SPhilipp Reisner } 380402918be2SPhilipp Reisner } 380502918be2SPhilipp Reisner 380677351055SPhilipp Reisner rv = drbd_cmd_handler[pi.cmd].function(mdev, pi.cmd, pi.size - shs); 380702918be2SPhilipp Reisner 380802918be2SPhilipp Reisner if (unlikely(!rv)) { 3809b411b363SPhilipp Reisner dev_err(DEV, "error receiving %s, l: %d!\n", 381077351055SPhilipp Reisner cmdname(pi.cmd), pi.size); 381102918be2SPhilipp Reisner goto err_out; 3812b411b363SPhilipp Reisner } 3813b411b363SPhilipp Reisner } 381402918be2SPhilipp Reisner 381502918be2SPhilipp Reisner if (0) { 381602918be2SPhilipp Reisner err_out: 3817b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 3818b411b363SPhilipp Reisner } 3819856c50c7SLars Ellenberg /* If we leave here, we probably want to update at least the 3820856c50c7SLars Ellenberg * "Connected" indicator on stable storage. Do so explicitly here. */ 3821856c50c7SLars Ellenberg drbd_md_sync(mdev); 3822b411b363SPhilipp Reisner } 3823b411b363SPhilipp Reisner 3824191d3cc8SPhilipp Reisner void drbd_flush_workqueue(struct drbd_tconn *tconn) 3825b411b363SPhilipp Reisner { 3826b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 3827b411b363SPhilipp Reisner 3828b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 3829b411b363SPhilipp Reisner init_completion(&barr.done); 3830191d3cc8SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 3831b411b363SPhilipp Reisner wait_for_completion(&barr.done); 3832b411b363SPhilipp Reisner } 3833b411b363SPhilipp Reisner 3834b411b363SPhilipp Reisner static void drbd_disconnect(struct drbd_conf *mdev) 3835b411b363SPhilipp Reisner { 3836b411b363SPhilipp Reisner enum drbd_fencing_p fp; 3837b411b363SPhilipp Reisner union drbd_state os, ns; 3838b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 3839b411b363SPhilipp Reisner unsigned int i; 3840b411b363SPhilipp Reisner 3841b411b363SPhilipp Reisner if (mdev->state.conn == C_STANDALONE) 3842b411b363SPhilipp Reisner return; 3843b411b363SPhilipp Reisner 3844b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 3845e6b3ea83SPhilipp Reisner drbd_thread_stop(&mdev->tconn->asender); 3846b411b363SPhilipp Reisner drbd_free_sock(mdev); 3847b411b363SPhilipp Reisner 384885719573SPhilipp Reisner /* wait for current activity to cease. */ 384987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3850b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 3851b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 3852b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 385387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3854b411b363SPhilipp Reisner 3855b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 3856b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 3857b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 3858b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 3859b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 3860b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 3861b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 3862b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 3863b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 3864b411b363SPhilipp Reisner * on the fly. */ 3865b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 3866b411b363SPhilipp Reisner mdev->rs_total = 0; 3867b411b363SPhilipp Reisner mdev->rs_failed = 0; 3868b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 3869b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 3870b411b363SPhilipp Reisner 38717fde2be9SPhilipp Reisner del_timer(&mdev->request_timer); 38727fde2be9SPhilipp Reisner 3873b411b363SPhilipp Reisner /* make sure syncer is stopped and w_resume_next_sg queued */ 3874b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 3875b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 3876b411b363SPhilipp Reisner 3877b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 3878b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 3879b411b363SPhilipp Reisner * to be "canceled" */ 3880191d3cc8SPhilipp Reisner drbd_flush_workqueue(mdev->tconn); 3881b411b363SPhilipp Reisner 3882b411b363SPhilipp Reisner /* This also does reclaim_net_ee(). If we do this too early, we might 3883b411b363SPhilipp Reisner * miss some resync ee and pages.*/ 3884b411b363SPhilipp Reisner drbd_process_done_ee(mdev); 3885b411b363SPhilipp Reisner 3886b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3887b411b363SPhilipp Reisner mdev->p_uuid = NULL; 3888b411b363SPhilipp Reisner 3889fb22c402SPhilipp Reisner if (!is_susp(mdev->state)) 3890b411b363SPhilipp Reisner tl_clear(mdev); 3891b411b363SPhilipp Reisner 3892b411b363SPhilipp Reisner dev_info(DEV, "Connection closed\n"); 3893b411b363SPhilipp Reisner 3894b411b363SPhilipp Reisner drbd_md_sync(mdev); 3895b411b363SPhilipp Reisner 3896b411b363SPhilipp Reisner fp = FP_DONT_CARE; 3897b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3898b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 3899b411b363SPhilipp Reisner put_ldev(mdev); 3900b411b363SPhilipp Reisner } 3901b411b363SPhilipp Reisner 390287f7be4cSPhilipp Reisner if (mdev->state.role == R_PRIMARY && fp >= FP_RESOURCE && mdev->state.pdsk >= D_UNKNOWN) 390387f7be4cSPhilipp Reisner drbd_try_outdate_peer_async(mdev); 3904b411b363SPhilipp Reisner 390587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3906b411b363SPhilipp Reisner os = mdev->state; 3907b411b363SPhilipp Reisner if (os.conn >= C_UNCONNECTED) { 3908b411b363SPhilipp Reisner /* Do not restart in case we are C_DISCONNECTING */ 3909b411b363SPhilipp Reisner ns = os; 3910b411b363SPhilipp Reisner ns.conn = C_UNCONNECTED; 3911b411b363SPhilipp Reisner rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 3912b411b363SPhilipp Reisner } 391387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3914b411b363SPhilipp Reisner 3915b411b363SPhilipp Reisner if (os.conn == C_DISCONNECTING) { 3916b2fb6dbeSPhilipp Reisner wait_event(mdev->tconn->net_cnt_wait, atomic_read(&mdev->tconn->net_cnt) == 0); 3917b411b363SPhilipp Reisner 3918a0638456SPhilipp Reisner crypto_free_hash(mdev->tconn->cram_hmac_tfm); 3919a0638456SPhilipp Reisner mdev->tconn->cram_hmac_tfm = NULL; 3920b411b363SPhilipp Reisner 392189e58e75SPhilipp Reisner kfree(mdev->tconn->net_conf); 392289e58e75SPhilipp Reisner mdev->tconn->net_conf = NULL; 3923b411b363SPhilipp Reisner drbd_request_state(mdev, NS(conn, C_STANDALONE)); 3924b411b363SPhilipp Reisner } 3925b411b363SPhilipp Reisner 392620ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 392720ceb2b2SLars Ellenberg * if any. */ 392820ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 392920ceb2b2SLars Ellenberg 3930b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 3931b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 3932b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 3933b411b363SPhilipp Reisner * 3934b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 3935b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 3936b411b363SPhilipp Reisner */ 3937b411b363SPhilipp Reisner i = drbd_release_ee(mdev, &mdev->net_ee); 3938b411b363SPhilipp Reisner if (i) 3939b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 3940435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 3941435f0740SLars Ellenberg if (i) 3942435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 3943b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 3944b411b363SPhilipp Reisner if (i) 394545bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 3946b411b363SPhilipp Reisner 3947b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 3948b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 3949b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 3950b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 3951b411b363SPhilipp Reisner 3952b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 3953b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 3954b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 3955b411b363SPhilipp Reisner } 3956b411b363SPhilipp Reisner 3957b411b363SPhilipp Reisner /* 3958b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 3959b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 3960b411b363SPhilipp Reisner * 3961b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 3962b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 3963b411b363SPhilipp Reisner * 3964b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 3965b411b363SPhilipp Reisner */ 39668a22ccccSPhilipp Reisner static int drbd_send_handshake(struct drbd_tconn *tconn) 3967b411b363SPhilipp Reisner { 3968e6b3ea83SPhilipp Reisner /* ASSERT current == mdev->tconn->receiver ... */ 39698a22ccccSPhilipp Reisner struct p_handshake *p = &tconn->data.sbuf.handshake; 3970b411b363SPhilipp Reisner int ok; 3971b411b363SPhilipp Reisner 39728a22ccccSPhilipp Reisner if (mutex_lock_interruptible(&tconn->data.mutex)) { 39738a22ccccSPhilipp Reisner conn_err(tconn, "interrupted during initial handshake\n"); 3974b411b363SPhilipp Reisner return 0; /* interrupted. not ok. */ 3975b411b363SPhilipp Reisner } 3976b411b363SPhilipp Reisner 39778a22ccccSPhilipp Reisner if (tconn->data.socket == NULL) { 39788a22ccccSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 3979b411b363SPhilipp Reisner return 0; 3980b411b363SPhilipp Reisner } 3981b411b363SPhilipp Reisner 3982b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 3983b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 3984b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 39858a22ccccSPhilipp Reisner ok = _conn_send_cmd(tconn, 0, tconn->data.socket, P_HAND_SHAKE, 3986c012949aSPhilipp Reisner &p->head, sizeof(*p), 0); 39878a22ccccSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 3988b411b363SPhilipp Reisner return ok; 3989b411b363SPhilipp Reisner } 3990b411b363SPhilipp Reisner 3991b411b363SPhilipp Reisner /* 3992b411b363SPhilipp Reisner * return values: 3993b411b363SPhilipp Reisner * 1 yes, we have a valid connection 3994b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 3995b411b363SPhilipp Reisner * -1 peer talks different language, 3996b411b363SPhilipp Reisner * no point in trying again, please go standalone. 3997b411b363SPhilipp Reisner */ 399865d11ed6SPhilipp Reisner static int drbd_do_handshake(struct drbd_tconn *tconn) 3999b411b363SPhilipp Reisner { 400065d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 400165d11ed6SPhilipp Reisner struct p_handshake *p = &tconn->data.rbuf.handshake; 400202918be2SPhilipp Reisner const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80); 400377351055SPhilipp Reisner struct packet_info pi; 4004b411b363SPhilipp Reisner int rv; 4005b411b363SPhilipp Reisner 400665d11ed6SPhilipp Reisner rv = drbd_send_handshake(tconn); 4007b411b363SPhilipp Reisner if (!rv) 4008b411b363SPhilipp Reisner return 0; 4009b411b363SPhilipp Reisner 401065d11ed6SPhilipp Reisner rv = drbd_recv_header(tconn, &pi); 4011b411b363SPhilipp Reisner if (!rv) 4012b411b363SPhilipp Reisner return 0; 4013b411b363SPhilipp Reisner 401477351055SPhilipp Reisner if (pi.cmd != P_HAND_SHAKE) { 401565d11ed6SPhilipp Reisner conn_err(tconn, "expected HandShake packet, received: %s (0x%04x)\n", 401677351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4017b411b363SPhilipp Reisner return -1; 4018b411b363SPhilipp Reisner } 4019b411b363SPhilipp Reisner 402077351055SPhilipp Reisner if (pi.size != expect) { 402165d11ed6SPhilipp Reisner conn_err(tconn, "expected HandShake length: %u, received: %u\n", 402277351055SPhilipp Reisner expect, pi.size); 4023b411b363SPhilipp Reisner return -1; 4024b411b363SPhilipp Reisner } 4025b411b363SPhilipp Reisner 402665d11ed6SPhilipp Reisner rv = drbd_recv(tconn, &p->head.payload, expect); 4027b411b363SPhilipp Reisner 4028b411b363SPhilipp Reisner if (rv != expect) { 40290ddc5549SLars Ellenberg if (!signal_pending(current)) 403065d11ed6SPhilipp Reisner conn_warn(tconn, "short read receiving handshake packet: l=%u\n", rv); 4031b411b363SPhilipp Reisner return 0; 4032b411b363SPhilipp Reisner } 4033b411b363SPhilipp Reisner 4034b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4035b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4036b411b363SPhilipp Reisner if (p->protocol_max == 0) 4037b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4038b411b363SPhilipp Reisner 4039b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4040b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4041b411b363SPhilipp Reisner goto incompat; 4042b411b363SPhilipp Reisner 404365d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4044b411b363SPhilipp Reisner 404565d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 404665d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4047b411b363SPhilipp Reisner 4048b411b363SPhilipp Reisner return 1; 4049b411b363SPhilipp Reisner 4050b411b363SPhilipp Reisner incompat: 405165d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4052b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4053b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4054b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4055b411b363SPhilipp Reisner return -1; 4056b411b363SPhilipp Reisner } 4057b411b363SPhilipp Reisner 4058b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 405913e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4060b411b363SPhilipp Reisner { 4061b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4062b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4063b10d96cbSJohannes Thoma return -1; 4064b411b363SPhilipp Reisner } 4065b411b363SPhilipp Reisner #else 4066b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4067b10d96cbSJohannes Thoma 4068b10d96cbSJohannes Thoma /* Return value: 4069b10d96cbSJohannes Thoma 1 - auth succeeded, 4070b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4071b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4072b10d96cbSJohannes Thoma */ 4073b10d96cbSJohannes Thoma 407413e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4075b411b363SPhilipp Reisner { 4076b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4077b411b363SPhilipp Reisner struct scatterlist sg; 4078b411b363SPhilipp Reisner char *response = NULL; 4079b411b363SPhilipp Reisner char *right_response = NULL; 4080b411b363SPhilipp Reisner char *peers_ch = NULL; 408113e6037dSPhilipp Reisner unsigned int key_len = strlen(tconn->net_conf->shared_secret); 4082b411b363SPhilipp Reisner unsigned int resp_size; 4083b411b363SPhilipp Reisner struct hash_desc desc; 408477351055SPhilipp Reisner struct packet_info pi; 4085b411b363SPhilipp Reisner int rv; 4086b411b363SPhilipp Reisner 408713e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4088b411b363SPhilipp Reisner desc.flags = 0; 4089b411b363SPhilipp Reisner 409013e6037dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, 409113e6037dSPhilipp Reisner (u8 *)tconn->net_conf->shared_secret, key_len); 4092b411b363SPhilipp Reisner if (rv) { 409313e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4094b10d96cbSJohannes Thoma rv = -1; 4095b411b363SPhilipp Reisner goto fail; 4096b411b363SPhilipp Reisner } 4097b411b363SPhilipp Reisner 4098b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4099b411b363SPhilipp Reisner 410013e6037dSPhilipp Reisner rv = conn_send_cmd2(tconn, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN); 4101b411b363SPhilipp Reisner if (!rv) 4102b411b363SPhilipp Reisner goto fail; 4103b411b363SPhilipp Reisner 410413e6037dSPhilipp Reisner rv = drbd_recv_header(tconn, &pi); 4105b411b363SPhilipp Reisner if (!rv) 4106b411b363SPhilipp Reisner goto fail; 4107b411b363SPhilipp Reisner 410877351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 410913e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 411077351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4111b411b363SPhilipp Reisner rv = 0; 4112b411b363SPhilipp Reisner goto fail; 4113b411b363SPhilipp Reisner } 4114b411b363SPhilipp Reisner 411577351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 411613e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4117b10d96cbSJohannes Thoma rv = -1; 4118b411b363SPhilipp Reisner goto fail; 4119b411b363SPhilipp Reisner } 4120b411b363SPhilipp Reisner 412177351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4122b411b363SPhilipp Reisner if (peers_ch == NULL) { 412313e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4124b10d96cbSJohannes Thoma rv = -1; 4125b411b363SPhilipp Reisner goto fail; 4126b411b363SPhilipp Reisner } 4127b411b363SPhilipp Reisner 412813e6037dSPhilipp Reisner rv = drbd_recv(tconn, peers_ch, pi.size); 4129b411b363SPhilipp Reisner 413077351055SPhilipp Reisner if (rv != pi.size) { 41310ddc5549SLars Ellenberg if (!signal_pending(current)) 413213e6037dSPhilipp Reisner conn_warn(tconn, "short read AuthChallenge: l=%u\n", rv); 4133b411b363SPhilipp Reisner rv = 0; 4134b411b363SPhilipp Reisner goto fail; 4135b411b363SPhilipp Reisner } 4136b411b363SPhilipp Reisner 413713e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4138b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4139b411b363SPhilipp Reisner if (response == NULL) { 414013e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4141b10d96cbSJohannes Thoma rv = -1; 4142b411b363SPhilipp Reisner goto fail; 4143b411b363SPhilipp Reisner } 4144b411b363SPhilipp Reisner 4145b411b363SPhilipp Reisner sg_init_table(&sg, 1); 414677351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4147b411b363SPhilipp Reisner 4148b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4149b411b363SPhilipp Reisner if (rv) { 415013e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4151b10d96cbSJohannes Thoma rv = -1; 4152b411b363SPhilipp Reisner goto fail; 4153b411b363SPhilipp Reisner } 4154b411b363SPhilipp Reisner 415513e6037dSPhilipp Reisner rv = conn_send_cmd2(tconn, P_AUTH_RESPONSE, response, resp_size); 4156b411b363SPhilipp Reisner if (!rv) 4157b411b363SPhilipp Reisner goto fail; 4158b411b363SPhilipp Reisner 415913e6037dSPhilipp Reisner rv = drbd_recv_header(tconn, &pi); 4160b411b363SPhilipp Reisner if (!rv) 4161b411b363SPhilipp Reisner goto fail; 4162b411b363SPhilipp Reisner 416377351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 416413e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 416577351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4166b411b363SPhilipp Reisner rv = 0; 4167b411b363SPhilipp Reisner goto fail; 4168b411b363SPhilipp Reisner } 4169b411b363SPhilipp Reisner 417077351055SPhilipp Reisner if (pi.size != resp_size) { 417113e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4172b411b363SPhilipp Reisner rv = 0; 4173b411b363SPhilipp Reisner goto fail; 4174b411b363SPhilipp Reisner } 4175b411b363SPhilipp Reisner 417613e6037dSPhilipp Reisner rv = drbd_recv(tconn, response , resp_size); 4177b411b363SPhilipp Reisner 4178b411b363SPhilipp Reisner if (rv != resp_size) { 41790ddc5549SLars Ellenberg if (!signal_pending(current)) 418013e6037dSPhilipp Reisner conn_warn(tconn, "short read receiving AuthResponse: l=%u\n", rv); 4181b411b363SPhilipp Reisner rv = 0; 4182b411b363SPhilipp Reisner goto fail; 4183b411b363SPhilipp Reisner } 4184b411b363SPhilipp Reisner 4185b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 41862d1ee87dSJulia Lawall if (right_response == NULL) { 418713e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4188b10d96cbSJohannes Thoma rv = -1; 4189b411b363SPhilipp Reisner goto fail; 4190b411b363SPhilipp Reisner } 4191b411b363SPhilipp Reisner 4192b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4193b411b363SPhilipp Reisner 4194b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4195b411b363SPhilipp Reisner if (rv) { 419613e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4197b10d96cbSJohannes Thoma rv = -1; 4198b411b363SPhilipp Reisner goto fail; 4199b411b363SPhilipp Reisner } 4200b411b363SPhilipp Reisner 4201b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4202b411b363SPhilipp Reisner 4203b411b363SPhilipp Reisner if (rv) 420413e6037dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes of '%s' HMAC\n", 420513e6037dSPhilipp Reisner resp_size, tconn->net_conf->cram_hmac_alg); 4206b10d96cbSJohannes Thoma else 4207b10d96cbSJohannes Thoma rv = -1; 4208b411b363SPhilipp Reisner 4209b411b363SPhilipp Reisner fail: 4210b411b363SPhilipp Reisner kfree(peers_ch); 4211b411b363SPhilipp Reisner kfree(response); 4212b411b363SPhilipp Reisner kfree(right_response); 4213b411b363SPhilipp Reisner 4214b411b363SPhilipp Reisner return rv; 4215b411b363SPhilipp Reisner } 4216b411b363SPhilipp Reisner #endif 4217b411b363SPhilipp Reisner 4218b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4219b411b363SPhilipp Reisner { 4220b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 4221b411b363SPhilipp Reisner unsigned int minor = mdev_to_minor(mdev); 4222b411b363SPhilipp Reisner int h; 4223b411b363SPhilipp Reisner 4224b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_receiver", minor); 4225b411b363SPhilipp Reisner 4226b411b363SPhilipp Reisner dev_info(DEV, "receiver (re)started\n"); 4227b411b363SPhilipp Reisner 4228b411b363SPhilipp Reisner do { 4229907599e0SPhilipp Reisner h = drbd_connect(mdev->tconn); 4230b411b363SPhilipp Reisner if (h == 0) { 4231b411b363SPhilipp Reisner drbd_disconnect(mdev); 423220ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4233b411b363SPhilipp Reisner } 4234b411b363SPhilipp Reisner if (h == -1) { 4235b411b363SPhilipp Reisner dev_warn(DEV, "Discarding network configuration.\n"); 4236b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 4237b411b363SPhilipp Reisner } 4238b411b363SPhilipp Reisner } while (h == 0); 4239b411b363SPhilipp Reisner 4240b411b363SPhilipp Reisner if (h > 0) { 4241b2fb6dbeSPhilipp Reisner if (get_net_conf(mdev->tconn)) { 4242b411b363SPhilipp Reisner drbdd(mdev); 4243b2fb6dbeSPhilipp Reisner put_net_conf(mdev->tconn); 4244b411b363SPhilipp Reisner } 4245b411b363SPhilipp Reisner } 4246b411b363SPhilipp Reisner 4247b411b363SPhilipp Reisner drbd_disconnect(mdev); 4248b411b363SPhilipp Reisner 4249b411b363SPhilipp Reisner dev_info(DEV, "receiver terminated\n"); 4250b411b363SPhilipp Reisner return 0; 4251b411b363SPhilipp Reisner } 4252b411b363SPhilipp Reisner 4253b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4254b411b363SPhilipp Reisner 4255d8763023SAndreas Gruenbacher static int got_RqSReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4256b411b363SPhilipp Reisner { 4257257d0af6SPhilipp Reisner struct p_req_state_reply *p = &mdev->tconn->meta.rbuf.req_state_reply; 4258b411b363SPhilipp Reisner 4259b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4260b411b363SPhilipp Reisner 4261b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4262b411b363SPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4263b411b363SPhilipp Reisner } else { 4264b411b363SPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4265b411b363SPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4266b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4267b411b363SPhilipp Reisner } 4268b411b363SPhilipp Reisner wake_up(&mdev->state_wait); 4269b411b363SPhilipp Reisner 427081e84650SAndreas Gruenbacher return true; 4271b411b363SPhilipp Reisner } 4272b411b363SPhilipp Reisner 4273d8763023SAndreas Gruenbacher static int got_Ping(struct drbd_conf *mdev, enum drbd_packet cmd) 4274b411b363SPhilipp Reisner { 4275b411b363SPhilipp Reisner return drbd_send_ping_ack(mdev); 4276b411b363SPhilipp Reisner 4277b411b363SPhilipp Reisner } 4278b411b363SPhilipp Reisner 4279d8763023SAndreas Gruenbacher static int got_PingAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4280b411b363SPhilipp Reisner { 4281b411b363SPhilipp Reisner /* restore idle timeout */ 4282e42325a5SPhilipp Reisner mdev->tconn->meta.socket->sk->sk_rcvtimeo = mdev->tconn->net_conf->ping_int*HZ; 4283309d1608SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &mdev->flags)) 4284309d1608SPhilipp Reisner wake_up(&mdev->misc_wait); 4285b411b363SPhilipp Reisner 428681e84650SAndreas Gruenbacher return true; 4287b411b363SPhilipp Reisner } 4288b411b363SPhilipp Reisner 4289d8763023SAndreas Gruenbacher static int got_IsInSync(struct drbd_conf *mdev, enum drbd_packet cmd) 4290b411b363SPhilipp Reisner { 4291257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4292b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4293b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4294b411b363SPhilipp Reisner 429531890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4296b411b363SPhilipp Reisner 4297b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4298b411b363SPhilipp Reisner 42991d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4300b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4301b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4302b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4303b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 43041d53f09eSLars Ellenberg put_ldev(mdev); 43051d53f09eSLars Ellenberg } 4306b411b363SPhilipp Reisner dec_rs_pending(mdev); 4307778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4308b411b363SPhilipp Reisner 430981e84650SAndreas Gruenbacher return true; 4310b411b363SPhilipp Reisner } 4311b411b363SPhilipp Reisner 4312bc9c5c41SAndreas Gruenbacher static int 4313bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4314bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4315bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4316b411b363SPhilipp Reisner { 4317b411b363SPhilipp Reisner struct drbd_request *req; 4318b411b363SPhilipp Reisner struct bio_and_error m; 4319b411b363SPhilipp Reisner 432087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4321bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4322b411b363SPhilipp Reisner if (unlikely(!req)) { 432387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 432481e84650SAndreas Gruenbacher return false; 4325b411b363SPhilipp Reisner } 4326b411b363SPhilipp Reisner __req_mod(req, what, &m); 432787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4328b411b363SPhilipp Reisner 4329b411b363SPhilipp Reisner if (m.bio) 4330b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 433181e84650SAndreas Gruenbacher return true; 4332b411b363SPhilipp Reisner } 4333b411b363SPhilipp Reisner 4334d8763023SAndreas Gruenbacher static int got_BlockAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4335b411b363SPhilipp Reisner { 4336257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4337b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4338b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4339b411b363SPhilipp Reisner enum drbd_req_event what; 4340b411b363SPhilipp Reisner 4341b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4342b411b363SPhilipp Reisner 4343579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4344b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4345b411b363SPhilipp Reisner dec_rs_pending(mdev); 434681e84650SAndreas Gruenbacher return true; 4347b411b363SPhilipp Reisner } 4348257d0af6SPhilipp Reisner switch (cmd) { 4349b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 435089e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 43518554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4352b411b363SPhilipp Reisner break; 4353b411b363SPhilipp Reisner case P_WRITE_ACK: 435489e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 43558554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4356b411b363SPhilipp Reisner break; 4357b411b363SPhilipp Reisner case P_RECV_ACK: 435889e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B); 43598554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4360b411b363SPhilipp Reisner break; 4361b411b363SPhilipp Reisner case P_DISCARD_ACK: 436289e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 43638554df1cSAndreas Gruenbacher what = CONFLICT_DISCARDED_BY_PEER; 4364b411b363SPhilipp Reisner break; 4365b411b363SPhilipp Reisner default: 4366b411b363SPhilipp Reisner D_ASSERT(0); 436781e84650SAndreas Gruenbacher return false; 4368b411b363SPhilipp Reisner } 4369b411b363SPhilipp Reisner 4370b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4371bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4372bc9c5c41SAndreas Gruenbacher what, false); 4373b411b363SPhilipp Reisner } 4374b411b363SPhilipp Reisner 4375d8763023SAndreas Gruenbacher static int got_NegAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4376b411b363SPhilipp Reisner { 4377257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4378b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 43792deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 438089e58e75SPhilipp Reisner bool missing_ok = mdev->tconn->net_conf->wire_protocol == DRBD_PROT_A || 438189e58e75SPhilipp Reisner mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B; 4382c3afd8f5SAndreas Gruenbacher bool found; 4383b411b363SPhilipp Reisner 4384b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4385b411b363SPhilipp Reisner 4386579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4387b411b363SPhilipp Reisner dec_rs_pending(mdev); 4388b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 438981e84650SAndreas Gruenbacher return true; 4390b411b363SPhilipp Reisner } 43912deb8336SPhilipp Reisner 4392c3afd8f5SAndreas Gruenbacher found = validate_req_change_req_state(mdev, p->block_id, sector, 4393bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 43948554df1cSAndreas Gruenbacher NEG_ACKED, missing_ok); 4395c3afd8f5SAndreas Gruenbacher if (!found) { 43962deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 43972deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4398c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 43992deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 44002deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4401c3afd8f5SAndreas Gruenbacher if (!missing_ok) 44022deb8336SPhilipp Reisner return false; 4403c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 44042deb8336SPhilipp Reisner } 44052deb8336SPhilipp Reisner return true; 4406b411b363SPhilipp Reisner } 4407b411b363SPhilipp Reisner 4408d8763023SAndreas Gruenbacher static int got_NegDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4409b411b363SPhilipp Reisner { 4410257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4411b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4412b411b363SPhilipp Reisner 4413b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4414b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4415b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4416b411b363SPhilipp Reisner 4417b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4418bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 44198554df1cSAndreas Gruenbacher NEG_ACKED, false); 4420b411b363SPhilipp Reisner } 4421b411b363SPhilipp Reisner 4422d8763023SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4423b411b363SPhilipp Reisner { 4424b411b363SPhilipp Reisner sector_t sector; 4425b411b363SPhilipp Reisner int size; 4426257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4427b411b363SPhilipp Reisner 4428b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4429b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4430b411b363SPhilipp Reisner 4431b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4432b411b363SPhilipp Reisner 4433b411b363SPhilipp Reisner dec_rs_pending(mdev); 4434b411b363SPhilipp Reisner 4435b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4436b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4437257d0af6SPhilipp Reisner switch (cmd) { 4438d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4439b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4440d612d309SPhilipp Reisner case P_RS_CANCEL: 4441d612d309SPhilipp Reisner break; 4442d612d309SPhilipp Reisner default: 4443d612d309SPhilipp Reisner D_ASSERT(0); 4444d612d309SPhilipp Reisner put_ldev(mdev); 4445d612d309SPhilipp Reisner return false; 4446d612d309SPhilipp Reisner } 4447b411b363SPhilipp Reisner put_ldev(mdev); 4448b411b363SPhilipp Reisner } 4449b411b363SPhilipp Reisner 445081e84650SAndreas Gruenbacher return true; 4451b411b363SPhilipp Reisner } 4452b411b363SPhilipp Reisner 4453d8763023SAndreas Gruenbacher static int got_BarrierAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4454b411b363SPhilipp Reisner { 4455257d0af6SPhilipp Reisner struct p_barrier_ack *p = &mdev->tconn->meta.rbuf.barrier_ack; 4456b411b363SPhilipp Reisner 4457b411b363SPhilipp Reisner tl_release(mdev, p->barrier, be32_to_cpu(p->set_size)); 4458b411b363SPhilipp Reisner 4459c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 4460c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 4461370a43e7SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) { 4462370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 4463370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 4464c4752ef1SPhilipp Reisner } 4465c4752ef1SPhilipp Reisner 446681e84650SAndreas Gruenbacher return true; 4467b411b363SPhilipp Reisner } 4468b411b363SPhilipp Reisner 4469d8763023SAndreas Gruenbacher static int got_OVResult(struct drbd_conf *mdev, enum drbd_packet cmd) 4470b411b363SPhilipp Reisner { 4471257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4472b411b363SPhilipp Reisner struct drbd_work *w; 4473b411b363SPhilipp Reisner sector_t sector; 4474b411b363SPhilipp Reisner int size; 4475b411b363SPhilipp Reisner 4476b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4477b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4478b411b363SPhilipp Reisner 4479b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4480b411b363SPhilipp Reisner 4481b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 4482b411b363SPhilipp Reisner drbd_ov_oos_found(mdev, sector, size); 4483b411b363SPhilipp Reisner else 4484b411b363SPhilipp Reisner ov_oos_print(mdev); 4485b411b363SPhilipp Reisner 44861d53f09eSLars Ellenberg if (!get_ldev(mdev)) 448781e84650SAndreas Gruenbacher return true; 44881d53f09eSLars Ellenberg 4489b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4490b411b363SPhilipp Reisner dec_rs_pending(mdev); 4491b411b363SPhilipp Reisner 4492ea5442afSLars Ellenberg --mdev->ov_left; 4493ea5442afSLars Ellenberg 4494ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 4495ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 4496ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 4497ea5442afSLars Ellenberg 4498ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 4499b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4500b411b363SPhilipp Reisner if (w) { 4501b411b363SPhilipp Reisner w->cb = w_ov_finished; 4502e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 4503b411b363SPhilipp Reisner } else { 4504b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 4505b411b363SPhilipp Reisner ov_oos_print(mdev); 4506b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4507b411b363SPhilipp Reisner } 4508b411b363SPhilipp Reisner } 45091d53f09eSLars Ellenberg put_ldev(mdev); 451081e84650SAndreas Gruenbacher return true; 4511b411b363SPhilipp Reisner } 4512b411b363SPhilipp Reisner 4513d8763023SAndreas Gruenbacher static int got_skip(struct drbd_conf *mdev, enum drbd_packet cmd) 45140ced55a3SPhilipp Reisner { 451581e84650SAndreas Gruenbacher return true; 45160ced55a3SPhilipp Reisner } 45170ced55a3SPhilipp Reisner 4518b411b363SPhilipp Reisner struct asender_cmd { 4519b411b363SPhilipp Reisner size_t pkt_size; 4520d8763023SAndreas Gruenbacher int (*process)(struct drbd_conf *mdev, enum drbd_packet cmd); 4521b411b363SPhilipp Reisner }; 4522b411b363SPhilipp Reisner 4523b411b363SPhilipp Reisner static struct asender_cmd *get_asender_cmd(int cmd) 4524b411b363SPhilipp Reisner { 4525b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 4526b411b363SPhilipp Reisner /* anything missing from this table is in 4527b411b363SPhilipp Reisner * the drbd_cmd_handler (drbd_default_handler) table, 4528b411b363SPhilipp Reisner * see the beginning of drbdd() */ 4529257d0af6SPhilipp Reisner [P_PING] = { sizeof(struct p_header), got_Ping }, 4530257d0af6SPhilipp Reisner [P_PING_ACK] = { sizeof(struct p_header), got_PingAck }, 4531b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4532b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4533b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4534b411b363SPhilipp Reisner [P_DISCARD_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4535b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 4536b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 4537b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply}, 4538b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 4539b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 4540b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 4541b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 454202918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 4543d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply}, 4544b411b363SPhilipp Reisner [P_MAX_CMD] = { 0, NULL }, 4545b411b363SPhilipp Reisner }; 4546b411b363SPhilipp Reisner if (cmd > P_MAX_CMD || asender_tbl[cmd].process == NULL) 4547b411b363SPhilipp Reisner return NULL; 4548b411b363SPhilipp Reisner return &asender_tbl[cmd]; 4549b411b363SPhilipp Reisner } 4550b411b363SPhilipp Reisner 4551b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4552b411b363SPhilipp Reisner { 4553b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 4554257d0af6SPhilipp Reisner struct p_header *h = &mdev->tconn->meta.rbuf.header; 4555b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 455677351055SPhilipp Reisner struct packet_info pi; 4557b411b363SPhilipp Reisner 4558257d0af6SPhilipp Reisner int rv; 4559b411b363SPhilipp Reisner void *buf = h; 4560b411b363SPhilipp Reisner int received = 0; 4561257d0af6SPhilipp Reisner int expect = sizeof(struct p_header); 4562f36af18cSLars Ellenberg int ping_timeout_active = 0; 456377351055SPhilipp Reisner int empty; 4564b411b363SPhilipp Reisner 4565b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_asender", mdev_to_minor(mdev)); 4566b411b363SPhilipp Reisner 4567b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4568b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4569b411b363SPhilipp Reisner 4570e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 4571bc31fe33SPhilipp Reisner drbd_thread_current_set_cpu(mdev, thi); 4572e43ef195SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &mdev->tconn->flags)) { 4573841ce241SAndreas Gruenbacher if (!drbd_send_ping(mdev)) { 4574841ce241SAndreas Gruenbacher dev_err(DEV, "drbd_send_ping has failed\n"); 4575841ce241SAndreas Gruenbacher goto reconnect; 4576841ce241SAndreas Gruenbacher } 4577e42325a5SPhilipp Reisner mdev->tconn->meta.socket->sk->sk_rcvtimeo = 457889e58e75SPhilipp Reisner mdev->tconn->net_conf->ping_timeo*HZ/10; 4579f36af18cSLars Ellenberg ping_timeout_active = 1; 4580b411b363SPhilipp Reisner } 4581b411b363SPhilipp Reisner 4582b411b363SPhilipp Reisner /* conditionally cork; 4583b411b363SPhilipp Reisner * it may hurt latency if we cork without much to send */ 458489e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->no_cork && 4585b411b363SPhilipp Reisner 3 < atomic_read(&mdev->unacked_cnt)) 4586e42325a5SPhilipp Reisner drbd_tcp_cork(mdev->tconn->meta.socket); 4587b411b363SPhilipp Reisner while (1) { 4588808e37b8SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->tconn->flags); 4589b411b363SPhilipp Reisner flush_signals(current); 45900f8488e1SLars Ellenberg if (!drbd_process_done_ee(mdev)) 4591b411b363SPhilipp Reisner goto reconnect; 4592b411b363SPhilipp Reisner /* to avoid race with newly queued ACKs */ 4593808e37b8SPhilipp Reisner set_bit(SIGNAL_ASENDER, &mdev->tconn->flags); 459487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4595b411b363SPhilipp Reisner empty = list_empty(&mdev->done_ee); 459687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4597b411b363SPhilipp Reisner /* new ack may have been queued right here, 4598b411b363SPhilipp Reisner * but then there is also a signal pending, 4599b411b363SPhilipp Reisner * and we start over... */ 4600b411b363SPhilipp Reisner if (empty) 4601b411b363SPhilipp Reisner break; 4602b411b363SPhilipp Reisner } 4603b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 460489e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->no_cork) 4605e42325a5SPhilipp Reisner drbd_tcp_uncork(mdev->tconn->meta.socket); 4606b411b363SPhilipp Reisner 4607b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4608b411b363SPhilipp Reisner if (signal_pending(current)) 4609b411b363SPhilipp Reisner continue; 4610b411b363SPhilipp Reisner 4611dbd9eea0SPhilipp Reisner rv = drbd_recv_short(mdev->tconn->meta.socket, buf, expect-received, 0); 4612808e37b8SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->tconn->flags); 4613b411b363SPhilipp Reisner 4614b411b363SPhilipp Reisner flush_signals(current); 4615b411b363SPhilipp Reisner 4616b411b363SPhilipp Reisner /* Note: 4617b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4618b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4619b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4620b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4621b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4622b411b363SPhilipp Reisner * rv == expected: full header or command 4623b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4624b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4625b411b363SPhilipp Reisner */ 4626b411b363SPhilipp Reisner if (likely(rv > 0)) { 4627b411b363SPhilipp Reisner received += rv; 4628b411b363SPhilipp Reisner buf += rv; 4629b411b363SPhilipp Reisner } else if (rv == 0) { 4630b411b363SPhilipp Reisner dev_err(DEV, "meta connection shut down by peer.\n"); 4631b411b363SPhilipp Reisner goto reconnect; 4632b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4633cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 4634cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 463531890f4aSPhilipp Reisner if (time_after(mdev->tconn->last_received, 4636e42325a5SPhilipp Reisner jiffies - mdev->tconn->meta.socket->sk->sk_rcvtimeo)) 4637cb6518cbSLars Ellenberg continue; 4638f36af18cSLars Ellenberg if (ping_timeout_active) { 4639b411b363SPhilipp Reisner dev_err(DEV, "PingAck did not arrive in time.\n"); 4640b411b363SPhilipp Reisner goto reconnect; 4641b411b363SPhilipp Reisner } 4642e43ef195SPhilipp Reisner set_bit(SEND_PING, &mdev->tconn->flags); 4643b411b363SPhilipp Reisner continue; 4644b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4645b411b363SPhilipp Reisner continue; 4646b411b363SPhilipp Reisner } else { 4647b411b363SPhilipp Reisner dev_err(DEV, "sock_recvmsg returned %d\n", rv); 4648b411b363SPhilipp Reisner goto reconnect; 4649b411b363SPhilipp Reisner } 4650b411b363SPhilipp Reisner 4651b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 4652ce243853SPhilipp Reisner if (!decode_header(mdev->tconn, h, &pi)) 4653b411b363SPhilipp Reisner goto reconnect; 465477351055SPhilipp Reisner cmd = get_asender_cmd(pi.cmd); 4655b411b363SPhilipp Reisner if (unlikely(cmd == NULL)) { 4656257d0af6SPhilipp Reisner dev_err(DEV, "unknown command %d on meta (l: %d)\n", 465777351055SPhilipp Reisner pi.cmd, pi.size); 4658b411b363SPhilipp Reisner goto disconnect; 4659b411b363SPhilipp Reisner } 4660b411b363SPhilipp Reisner expect = cmd->pkt_size; 466177351055SPhilipp Reisner if (pi.size != expect - sizeof(struct p_header)) { 4662257d0af6SPhilipp Reisner dev_err(DEV, "Wrong packet size on meta (c: %d, l: %d)\n", 466377351055SPhilipp Reisner pi.cmd, pi.size); 4664b411b363SPhilipp Reisner goto reconnect; 4665b411b363SPhilipp Reisner } 4666257d0af6SPhilipp Reisner } 4667b411b363SPhilipp Reisner if (received == expect) { 466831890f4aSPhilipp Reisner mdev->tconn->last_received = jiffies; 4669b411b363SPhilipp Reisner D_ASSERT(cmd != NULL); 467077351055SPhilipp Reisner if (!cmd->process(mdev, pi.cmd)) 4671b411b363SPhilipp Reisner goto reconnect; 4672b411b363SPhilipp Reisner 4673f36af18cSLars Ellenberg /* the idle_timeout (ping-int) 4674f36af18cSLars Ellenberg * has been restored in got_PingAck() */ 4675f36af18cSLars Ellenberg if (cmd == get_asender_cmd(P_PING_ACK)) 4676f36af18cSLars Ellenberg ping_timeout_active = 0; 4677f36af18cSLars Ellenberg 4678b411b363SPhilipp Reisner buf = h; 4679b411b363SPhilipp Reisner received = 0; 4680257d0af6SPhilipp Reisner expect = sizeof(struct p_header); 4681b411b363SPhilipp Reisner cmd = NULL; 4682b411b363SPhilipp Reisner } 4683b411b363SPhilipp Reisner } 4684b411b363SPhilipp Reisner 4685b411b363SPhilipp Reisner if (0) { 4686b411b363SPhilipp Reisner reconnect: 4687b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_NETWORK_FAILURE)); 4688856c50c7SLars Ellenberg drbd_md_sync(mdev); 4689b411b363SPhilipp Reisner } 4690b411b363SPhilipp Reisner if (0) { 4691b411b363SPhilipp Reisner disconnect: 4692b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 4693856c50c7SLars Ellenberg drbd_md_sync(mdev); 4694b411b363SPhilipp Reisner } 4695808e37b8SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->tconn->flags); 4696b411b363SPhilipp Reisner 4697b411b363SPhilipp Reisner D_ASSERT(mdev->state.conn < C_CONNECTED); 4698b411b363SPhilipp Reisner dev_info(DEV, "asender terminated\n"); 4699b411b363SPhilipp Reisner 4700b411b363SPhilipp Reisner return 0; 4701b411b363SPhilipp Reisner } 4702