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; 53e2857216SAndreas Gruenbacher unsigned int size; 54e2857216SAndreas Gruenbacher unsigned int vnr; 55e658983aSAndreas Gruenbacher void *data; 5677351055SPhilipp Reisner }; 5777351055SPhilipp Reisner 58b411b363SPhilipp Reisner enum finish_epoch { 59b411b363SPhilipp Reisner FE_STILL_LIVE, 60b411b363SPhilipp Reisner FE_DESTROYED, 61b411b363SPhilipp Reisner FE_RECYCLED, 62b411b363SPhilipp Reisner }; 63b411b363SPhilipp Reisner 646038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn); 6513e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn); 66c141ebdaSPhilipp Reisner static int drbd_disconnected(struct drbd_conf *mdev); 67b411b363SPhilipp Reisner 681e9dd291SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_tconn *, struct drbd_epoch *, enum epoch_event); 6999920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *, int); 70b411b363SPhilipp Reisner 71b411b363SPhilipp Reisner 72b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 73b411b363SPhilipp Reisner 7445bb912bSLars Ellenberg /* 7545bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 7645bb912bSLars Ellenberg * page->private being our "next" pointer. 7745bb912bSLars Ellenberg */ 7845bb912bSLars Ellenberg 7945bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 8045bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8145bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8245bb912bSLars Ellenberg */ 8345bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8445bb912bSLars Ellenberg { 8545bb912bSLars Ellenberg struct page *page; 8645bb912bSLars Ellenberg struct page *tmp; 8745bb912bSLars Ellenberg 8845bb912bSLars Ellenberg BUG_ON(!n); 8945bb912bSLars Ellenberg BUG_ON(!head); 9045bb912bSLars Ellenberg 9145bb912bSLars Ellenberg page = *head; 9223ce4227SPhilipp Reisner 9323ce4227SPhilipp Reisner if (!page) 9423ce4227SPhilipp Reisner return NULL; 9523ce4227SPhilipp Reisner 9645bb912bSLars Ellenberg while (page) { 9745bb912bSLars Ellenberg tmp = page_chain_next(page); 9845bb912bSLars Ellenberg if (--n == 0) 9945bb912bSLars Ellenberg break; /* found sufficient pages */ 10045bb912bSLars Ellenberg if (tmp == NULL) 10145bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10245bb912bSLars Ellenberg return NULL; 10345bb912bSLars Ellenberg page = tmp; 10445bb912bSLars Ellenberg } 10545bb912bSLars Ellenberg 10645bb912bSLars Ellenberg /* add end of list marker for the returned list */ 10745bb912bSLars Ellenberg set_page_private(page, 0); 10845bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 10945bb912bSLars Ellenberg page = *head; 11045bb912bSLars Ellenberg *head = tmp; 11145bb912bSLars Ellenberg return page; 11245bb912bSLars Ellenberg } 11345bb912bSLars Ellenberg 11445bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11545bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 11645bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 11745bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 11845bb912bSLars Ellenberg { 11945bb912bSLars Ellenberg struct page *tmp; 12045bb912bSLars Ellenberg int i = 1; 12145bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12245bb912bSLars Ellenberg ++i, page = tmp; 12345bb912bSLars Ellenberg if (len) 12445bb912bSLars Ellenberg *len = i; 12545bb912bSLars Ellenberg return page; 12645bb912bSLars Ellenberg } 12745bb912bSLars Ellenberg 12845bb912bSLars Ellenberg static int page_chain_free(struct page *page) 12945bb912bSLars Ellenberg { 13045bb912bSLars Ellenberg struct page *tmp; 13145bb912bSLars Ellenberg int i = 0; 13245bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13345bb912bSLars Ellenberg put_page(page); 13445bb912bSLars Ellenberg ++i; 13545bb912bSLars Ellenberg } 13645bb912bSLars Ellenberg return i; 13745bb912bSLars Ellenberg } 13845bb912bSLars Ellenberg 13945bb912bSLars Ellenberg static void page_chain_add(struct page **head, 14045bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14145bb912bSLars Ellenberg { 14245bb912bSLars Ellenberg #if 1 14345bb912bSLars Ellenberg struct page *tmp; 14445bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14545bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 14645bb912bSLars Ellenberg #endif 14745bb912bSLars Ellenberg 14845bb912bSLars Ellenberg /* add chain to head */ 14945bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 15045bb912bSLars Ellenberg *head = chain_first; 15145bb912bSLars Ellenberg } 15245bb912bSLars Ellenberg 15318c2d522SAndreas Gruenbacher static struct page *__drbd_alloc_pages(struct drbd_conf *mdev, 15418c2d522SAndreas Gruenbacher unsigned int number) 155b411b363SPhilipp Reisner { 156b411b363SPhilipp Reisner struct page *page = NULL; 15745bb912bSLars Ellenberg struct page *tmp = NULL; 15818c2d522SAndreas Gruenbacher unsigned int i = 0; 159b411b363SPhilipp Reisner 160b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 161b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16245bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 163b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16445bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16545bb912bSLars Ellenberg if (page) 16645bb912bSLars Ellenberg drbd_pp_vacant -= number; 167b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 16845bb912bSLars Ellenberg if (page) 16945bb912bSLars Ellenberg return page; 170b411b363SPhilipp Reisner } 17145bb912bSLars Ellenberg 172b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 173b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 174b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17545bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17645bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 17745bb912bSLars Ellenberg if (!tmp) 17845bb912bSLars Ellenberg break; 17945bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 18045bb912bSLars Ellenberg page = tmp; 18145bb912bSLars Ellenberg } 18245bb912bSLars Ellenberg 18345bb912bSLars Ellenberg if (i == number) 184b411b363SPhilipp Reisner return page; 18545bb912bSLars Ellenberg 18645bb912bSLars Ellenberg /* Not enough pages immediately available this time. 187c37c8ecfSAndreas Gruenbacher * No need to jump around here, drbd_alloc_pages will retry this 18845bb912bSLars Ellenberg * function "soon". */ 18945bb912bSLars Ellenberg if (page) { 19045bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 19145bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19245bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19345bb912bSLars Ellenberg drbd_pp_vacant += i; 19445bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19545bb912bSLars Ellenberg } 19645bb912bSLars Ellenberg return NULL; 197b411b363SPhilipp Reisner } 198b411b363SPhilipp Reisner 199a990be46SAndreas Gruenbacher static void reclaim_finished_net_peer_reqs(struct drbd_conf *mdev, 200a990be46SAndreas Gruenbacher struct list_head *to_be_freed) 201b411b363SPhilipp Reisner { 202db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 203b411b363SPhilipp Reisner struct list_head *le, *tle; 204b411b363SPhilipp Reisner 205b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 206b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 207b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 208b411b363SPhilipp Reisner stop to examine the list... */ 209b411b363SPhilipp Reisner 210b411b363SPhilipp Reisner list_for_each_safe(le, tle, &mdev->net_ee) { 211db830c46SAndreas Gruenbacher peer_req = list_entry(le, struct drbd_peer_request, w.list); 212045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) 213b411b363SPhilipp Reisner break; 214b411b363SPhilipp Reisner list_move(le, to_be_freed); 215b411b363SPhilipp Reisner } 216b411b363SPhilipp Reisner } 217b411b363SPhilipp Reisner 218b411b363SPhilipp Reisner static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev) 219b411b363SPhilipp Reisner { 220b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 221db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 222b411b363SPhilipp Reisner 22387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 224a990be46SAndreas Gruenbacher reclaim_finished_net_peer_reqs(mdev, &reclaimed); 22587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 226b411b363SPhilipp Reisner 227db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 2283967deb1SAndreas Gruenbacher drbd_free_net_peer_req(mdev, peer_req); 229b411b363SPhilipp Reisner } 230b411b363SPhilipp Reisner 231b411b363SPhilipp Reisner /** 232c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages() - Returns @number pages, retries forever (or until signalled) 233b411b363SPhilipp Reisner * @mdev: DRBD device. 23445bb912bSLars Ellenberg * @number: number of pages requested 23545bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 236b411b363SPhilipp Reisner * 23745bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 23845bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 23945bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 24045bb912bSLars Ellenberg * 24145bb912bSLars Ellenberg * Returns a page chain linked via page->private. 242b411b363SPhilipp Reisner */ 243c37c8ecfSAndreas Gruenbacher struct page *drbd_alloc_pages(struct drbd_conf *mdev, unsigned int number, 244c37c8ecfSAndreas Gruenbacher bool retry) 245b411b363SPhilipp Reisner { 246b411b363SPhilipp Reisner struct page *page = NULL; 24744ed167dSPhilipp Reisner struct net_conf *nc; 248b411b363SPhilipp Reisner DEFINE_WAIT(wait); 24944ed167dSPhilipp Reisner int mxb; 250b411b363SPhilipp Reisner 25145bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 25245bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 25344ed167dSPhilipp Reisner rcu_read_lock(); 25444ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 25544ed167dSPhilipp Reisner mxb = nc ? nc->max_buffers : 1000000; 25644ed167dSPhilipp Reisner rcu_read_unlock(); 25744ed167dSPhilipp Reisner 25844ed167dSPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mxb) 25918c2d522SAndreas Gruenbacher page = __drbd_alloc_pages(mdev, number); 260b411b363SPhilipp Reisner 26145bb912bSLars Ellenberg while (page == NULL) { 262b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 263b411b363SPhilipp Reisner 264b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 265b411b363SPhilipp Reisner 26644ed167dSPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mxb) { 26718c2d522SAndreas Gruenbacher page = __drbd_alloc_pages(mdev, number); 268b411b363SPhilipp Reisner if (page) 269b411b363SPhilipp Reisner break; 270b411b363SPhilipp Reisner } 271b411b363SPhilipp Reisner 272b411b363SPhilipp Reisner if (!retry) 273b411b363SPhilipp Reisner break; 274b411b363SPhilipp Reisner 275b411b363SPhilipp Reisner if (signal_pending(current)) { 276c37c8ecfSAndreas Gruenbacher dev_warn(DEV, "drbd_alloc_pages interrupted!\n"); 277b411b363SPhilipp Reisner break; 278b411b363SPhilipp Reisner } 279b411b363SPhilipp Reisner 280b411b363SPhilipp Reisner schedule(); 281b411b363SPhilipp Reisner } 282b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 283b411b363SPhilipp Reisner 28445bb912bSLars Ellenberg if (page) 28545bb912bSLars Ellenberg atomic_add(number, &mdev->pp_in_use); 286b411b363SPhilipp Reisner return page; 287b411b363SPhilipp Reisner } 288b411b363SPhilipp Reisner 289c37c8ecfSAndreas Gruenbacher /* Must not be used from irq, as that may deadlock: see drbd_alloc_pages. 29087eeee41SPhilipp Reisner * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock); 29145bb912bSLars Ellenberg * Either links the page chain back to the global pool, 29245bb912bSLars Ellenberg * or returns all pages to the system. */ 2935cc287e0SAndreas Gruenbacher static void drbd_free_pages(struct drbd_conf *mdev, struct page *page, int is_net) 294b411b363SPhilipp Reisner { 295435f0740SLars Ellenberg atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use; 296b411b363SPhilipp Reisner int i; 297435f0740SLars Ellenberg 298a73ff323SLars Ellenberg if (page == NULL) 299a73ff323SLars Ellenberg return; 300a73ff323SLars Ellenberg 3011816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 30245bb912bSLars Ellenberg i = page_chain_free(page); 30345bb912bSLars Ellenberg else { 30445bb912bSLars Ellenberg struct page *tmp; 30545bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 306b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 30745bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 30845bb912bSLars Ellenberg drbd_pp_vacant += i; 309b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 310b411b363SPhilipp Reisner } 311435f0740SLars Ellenberg i = atomic_sub_return(i, a); 31245bb912bSLars Ellenberg if (i < 0) 313435f0740SLars Ellenberg dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n", 314435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 315b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 316b411b363SPhilipp Reisner } 317b411b363SPhilipp Reisner 318b411b363SPhilipp Reisner /* 319b411b363SPhilipp Reisner You need to hold the req_lock: 320b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 321b411b363SPhilipp Reisner 322b411b363SPhilipp Reisner You must not have the req_lock: 3233967deb1SAndreas Gruenbacher drbd_free_peer_req() 3240db55363SAndreas Gruenbacher drbd_alloc_peer_req() 3257721f567SAndreas Gruenbacher drbd_free_peer_reqs() 326b411b363SPhilipp Reisner drbd_ee_fix_bhs() 327a990be46SAndreas Gruenbacher drbd_finish_peer_reqs() 328b411b363SPhilipp Reisner drbd_clear_done_ee() 329b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 330b411b363SPhilipp Reisner */ 331b411b363SPhilipp Reisner 332f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 3330db55363SAndreas Gruenbacher drbd_alloc_peer_req(struct drbd_conf *mdev, u64 id, sector_t sector, 334f6ffca9fSAndreas Gruenbacher unsigned int data_size, gfp_t gfp_mask) __must_hold(local) 335b411b363SPhilipp Reisner { 336db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 337a73ff323SLars Ellenberg struct page *page = NULL; 33845bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 339b411b363SPhilipp Reisner 3400cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE)) 341b411b363SPhilipp Reisner return NULL; 342b411b363SPhilipp Reisner 343db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 344db830c46SAndreas Gruenbacher if (!peer_req) { 345b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 3460db55363SAndreas Gruenbacher dev_err(DEV, "%s: allocation failed\n", __func__); 347b411b363SPhilipp Reisner return NULL; 348b411b363SPhilipp Reisner } 349b411b363SPhilipp Reisner 350a73ff323SLars Ellenberg if (data_size) { 351c37c8ecfSAndreas Gruenbacher page = drbd_alloc_pages(mdev, nr_pages, (gfp_mask & __GFP_WAIT)); 35245bb912bSLars Ellenberg if (!page) 35345bb912bSLars Ellenberg goto fail; 354a73ff323SLars Ellenberg } 355b411b363SPhilipp Reisner 356db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 357db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 358db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 359db830c46SAndreas Gruenbacher peer_req->i.local = false; 360db830c46SAndreas Gruenbacher peer_req->i.waiting = false; 361b411b363SPhilipp Reisner 362db830c46SAndreas Gruenbacher peer_req->epoch = NULL; 363a21e9298SPhilipp Reisner peer_req->w.mdev = mdev; 364db830c46SAndreas Gruenbacher peer_req->pages = page; 365db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, 0); 366db830c46SAndreas Gruenbacher peer_req->flags = 0; 3679a8e7753SAndreas Gruenbacher /* 3689a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3699a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3709a8e7753SAndreas Gruenbacher */ 371db830c46SAndreas Gruenbacher peer_req->block_id = id; 372b411b363SPhilipp Reisner 373db830c46SAndreas Gruenbacher return peer_req; 374b411b363SPhilipp Reisner 37545bb912bSLars Ellenberg fail: 376db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 377b411b363SPhilipp Reisner return NULL; 378b411b363SPhilipp Reisner } 379b411b363SPhilipp Reisner 3803967deb1SAndreas Gruenbacher void __drbd_free_peer_req(struct drbd_conf *mdev, struct drbd_peer_request *peer_req, 381f6ffca9fSAndreas Gruenbacher int is_net) 382b411b363SPhilipp Reisner { 383db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 384db830c46SAndreas Gruenbacher kfree(peer_req->digest); 3855cc287e0SAndreas Gruenbacher drbd_free_pages(mdev, peer_req->pages, is_net); 386db830c46SAndreas Gruenbacher D_ASSERT(atomic_read(&peer_req->pending_bios) == 0); 387db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 388db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 389b411b363SPhilipp Reisner } 390b411b363SPhilipp Reisner 3917721f567SAndreas Gruenbacher int drbd_free_peer_reqs(struct drbd_conf *mdev, struct list_head *list) 392b411b363SPhilipp Reisner { 393b411b363SPhilipp Reisner LIST_HEAD(work_list); 394db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 395b411b363SPhilipp Reisner int count = 0; 396435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 397b411b363SPhilipp Reisner 39887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 399b411b363SPhilipp Reisner list_splice_init(list, &work_list); 40087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 401b411b363SPhilipp Reisner 402db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 4033967deb1SAndreas Gruenbacher __drbd_free_peer_req(mdev, peer_req, is_net); 404b411b363SPhilipp Reisner count++; 405b411b363SPhilipp Reisner } 406b411b363SPhilipp Reisner return count; 407b411b363SPhilipp Reisner } 408b411b363SPhilipp Reisner 409b411b363SPhilipp Reisner /* 410a990be46SAndreas Gruenbacher * See also comments in _req_mod(,BARRIER_ACKED) and receive_Barrier. 411b411b363SPhilipp Reisner */ 412a990be46SAndreas Gruenbacher static int drbd_finish_peer_reqs(struct drbd_conf *mdev) 413b411b363SPhilipp Reisner { 414b411b363SPhilipp Reisner LIST_HEAD(work_list); 415b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 416db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 417e2b3032bSAndreas Gruenbacher int err = 0; 418b411b363SPhilipp Reisner 41987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 420a990be46SAndreas Gruenbacher reclaim_finished_net_peer_reqs(mdev, &reclaimed); 421b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 42287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 423b411b363SPhilipp Reisner 424db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 4253967deb1SAndreas Gruenbacher drbd_free_net_peer_req(mdev, peer_req); 426b411b363SPhilipp Reisner 427b411b363SPhilipp Reisner /* possible callbacks here: 428d4dabbe2SLars Ellenberg * e_end_block, and e_end_resync_block, e_send_superseded. 429b411b363SPhilipp Reisner * all ignore the last argument. 430b411b363SPhilipp Reisner */ 431db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 432e2b3032bSAndreas Gruenbacher int err2; 433e2b3032bSAndreas Gruenbacher 434b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 435e2b3032bSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 436e2b3032bSAndreas Gruenbacher if (!err) 437e2b3032bSAndreas Gruenbacher err = err2; 4383967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 439b411b363SPhilipp Reisner } 440b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 441b411b363SPhilipp Reisner 442e2b3032bSAndreas Gruenbacher return err; 443b411b363SPhilipp Reisner } 444b411b363SPhilipp Reisner 445d4da1537SAndreas Gruenbacher static void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, 446d4da1537SAndreas Gruenbacher struct list_head *head) 447b411b363SPhilipp Reisner { 448b411b363SPhilipp Reisner DEFINE_WAIT(wait); 449b411b363SPhilipp Reisner 450b411b363SPhilipp Reisner /* avoids spin_lock/unlock 451b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 452b411b363SPhilipp Reisner while (!list_empty(head)) { 453b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 45487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4557eaceaccSJens Axboe io_schedule(); 456b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 45787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 458b411b363SPhilipp Reisner } 459b411b363SPhilipp Reisner } 460b411b363SPhilipp Reisner 461d4da1537SAndreas Gruenbacher static void drbd_wait_ee_list_empty(struct drbd_conf *mdev, 462d4da1537SAndreas Gruenbacher struct list_head *head) 463b411b363SPhilipp Reisner { 46487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 465b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 46687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 467b411b363SPhilipp Reisner } 468b411b363SPhilipp Reisner 469dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 470b411b363SPhilipp Reisner { 471b411b363SPhilipp Reisner mm_segment_t oldfs; 472b411b363SPhilipp Reisner struct kvec iov = { 473b411b363SPhilipp Reisner .iov_base = buf, 474b411b363SPhilipp Reisner .iov_len = size, 475b411b363SPhilipp Reisner }; 476b411b363SPhilipp Reisner struct msghdr msg = { 477b411b363SPhilipp Reisner .msg_iovlen = 1, 478b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 479b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 480b411b363SPhilipp Reisner }; 481b411b363SPhilipp Reisner int rv; 482b411b363SPhilipp Reisner 483b411b363SPhilipp Reisner oldfs = get_fs(); 484b411b363SPhilipp Reisner set_fs(KERNEL_DS); 485b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 486b411b363SPhilipp Reisner set_fs(oldfs); 487b411b363SPhilipp Reisner 488b411b363SPhilipp Reisner return rv; 489b411b363SPhilipp Reisner } 490b411b363SPhilipp Reisner 491de0ff338SPhilipp Reisner static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size) 492b411b363SPhilipp Reisner { 493b411b363SPhilipp Reisner int rv; 494b411b363SPhilipp Reisner 4951393b59fSPhilipp Reisner rv = drbd_recv_short(tconn->data.socket, buf, size, 0); 496b411b363SPhilipp Reisner 497b411b363SPhilipp Reisner if (rv < 0) { 498b411b363SPhilipp Reisner if (rv == -ECONNRESET) 499de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 500b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 501de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 502b411b363SPhilipp Reisner } else if (rv == 0) { 503b66623e3SPhilipp Reisner if (test_bit(DISCONNECT_SENT, &tconn->flags)) { 504b66623e3SPhilipp Reisner long t; 505b66623e3SPhilipp Reisner rcu_read_lock(); 506b66623e3SPhilipp Reisner t = rcu_dereference(tconn->net_conf)->ping_timeo * HZ/10; 507b66623e3SPhilipp Reisner rcu_read_unlock(); 508b66623e3SPhilipp Reisner 509b66623e3SPhilipp Reisner t = wait_event_timeout(tconn->ping_wait, tconn->cstate < C_WF_REPORT_PARAMS, t); 510b66623e3SPhilipp Reisner 511599377acSPhilipp Reisner if (t) 512599377acSPhilipp Reisner goto out; 513599377acSPhilipp Reisner } 514b66623e3SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 515599377acSPhilipp Reisner } 516599377acSPhilipp Reisner 517b411b363SPhilipp Reisner if (rv != size) 518bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 519b411b363SPhilipp Reisner 520599377acSPhilipp Reisner out: 521b411b363SPhilipp Reisner return rv; 522b411b363SPhilipp Reisner } 523b411b363SPhilipp Reisner 524c6967746SAndreas Gruenbacher static int drbd_recv_all(struct drbd_tconn *tconn, void *buf, size_t size) 525c6967746SAndreas Gruenbacher { 526c6967746SAndreas Gruenbacher int err; 527c6967746SAndreas Gruenbacher 528c6967746SAndreas Gruenbacher err = drbd_recv(tconn, buf, size); 529c6967746SAndreas Gruenbacher if (err != size) { 530c6967746SAndreas Gruenbacher if (err >= 0) 531c6967746SAndreas Gruenbacher err = -EIO; 532c6967746SAndreas Gruenbacher } else 533c6967746SAndreas Gruenbacher err = 0; 534c6967746SAndreas Gruenbacher return err; 535c6967746SAndreas Gruenbacher } 536c6967746SAndreas Gruenbacher 537a5c31904SAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_tconn *tconn, void *buf, size_t size) 538a5c31904SAndreas Gruenbacher { 539a5c31904SAndreas Gruenbacher int err; 540a5c31904SAndreas Gruenbacher 541a5c31904SAndreas Gruenbacher err = drbd_recv_all(tconn, buf, size); 542a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 543a5c31904SAndreas Gruenbacher conn_warn(tconn, "short read (expected size %d)\n", (int)size); 544a5c31904SAndreas Gruenbacher return err; 545a5c31904SAndreas Gruenbacher } 546a5c31904SAndreas Gruenbacher 5475dbf1673SLars Ellenberg /* quoting tcp(7): 5485dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5495dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5505dbf1673SLars Ellenberg * This is our wrapper to do so. 5515dbf1673SLars Ellenberg */ 5525dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5535dbf1673SLars Ellenberg unsigned int rcv) 5545dbf1673SLars Ellenberg { 5555dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5565dbf1673SLars Ellenberg if (snd) { 5575dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5585dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5595dbf1673SLars Ellenberg } 5605dbf1673SLars Ellenberg if (rcv) { 5615dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5625dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5635dbf1673SLars Ellenberg } 5645dbf1673SLars Ellenberg } 5655dbf1673SLars Ellenberg 566eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 567b411b363SPhilipp Reisner { 568b411b363SPhilipp Reisner const char *what; 569b411b363SPhilipp Reisner struct socket *sock; 570b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 57144ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 57244ed167dSPhilipp Reisner struct net_conf *nc; 57344ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 57469ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 575b411b363SPhilipp Reisner int disconnect_on_error = 1; 576b411b363SPhilipp Reisner 57744ed167dSPhilipp Reisner rcu_read_lock(); 57844ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 57944ed167dSPhilipp Reisner if (!nc) { 58044ed167dSPhilipp Reisner rcu_read_unlock(); 581b411b363SPhilipp Reisner return NULL; 58244ed167dSPhilipp Reisner } 58344ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 58444ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 58569ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 586089c075dSAndreas Gruenbacher rcu_read_unlock(); 58744ed167dSPhilipp Reisner 588089c075dSAndreas Gruenbacher my_addr_len = min_t(int, tconn->my_addr_len, sizeof(src_in6)); 589089c075dSAndreas Gruenbacher memcpy(&src_in6, &tconn->my_addr, my_addr_len); 59044ed167dSPhilipp Reisner 591089c075dSAndreas Gruenbacher if (((struct sockaddr *)&tconn->my_addr)->sa_family == AF_INET6) 59244ed167dSPhilipp Reisner src_in6.sin6_port = 0; 59344ed167dSPhilipp Reisner else 59444ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 59544ed167dSPhilipp Reisner 596089c075dSAndreas Gruenbacher peer_addr_len = min_t(int, tconn->peer_addr_len, sizeof(src_in6)); 597089c075dSAndreas Gruenbacher memcpy(&peer_in6, &tconn->peer_addr, peer_addr_len); 598b411b363SPhilipp Reisner 599b411b363SPhilipp Reisner what = "sock_create_kern"; 60044ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family, 601b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 602b411b363SPhilipp Reisner if (err < 0) { 603b411b363SPhilipp Reisner sock = NULL; 604b411b363SPhilipp Reisner goto out; 605b411b363SPhilipp Reisner } 606b411b363SPhilipp Reisner 607b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 60869ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 60944ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 610b411b363SPhilipp Reisner 611b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 612b411b363SPhilipp Reisner * for the outgoing connections. 613b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 614b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 615b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 616b411b363SPhilipp Reisner * a free one dynamically. 617b411b363SPhilipp Reisner */ 618b411b363SPhilipp Reisner what = "bind before connect"; 61944ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 620b411b363SPhilipp Reisner if (err < 0) 621b411b363SPhilipp Reisner goto out; 622b411b363SPhilipp Reisner 623b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 624b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 625b411b363SPhilipp Reisner disconnect_on_error = 0; 626b411b363SPhilipp Reisner what = "connect"; 62744ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 628b411b363SPhilipp Reisner 629b411b363SPhilipp Reisner out: 630b411b363SPhilipp Reisner if (err < 0) { 631b411b363SPhilipp Reisner if (sock) { 632b411b363SPhilipp Reisner sock_release(sock); 633b411b363SPhilipp Reisner sock = NULL; 634b411b363SPhilipp Reisner } 635b411b363SPhilipp Reisner switch (-err) { 636b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 637b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 638b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 639b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 640b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 641b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 642b411b363SPhilipp Reisner disconnect_on_error = 0; 643b411b363SPhilipp Reisner break; 644b411b363SPhilipp Reisner default: 645eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 646b411b363SPhilipp Reisner } 647b411b363SPhilipp Reisner if (disconnect_on_error) 648bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 649b411b363SPhilipp Reisner } 65044ed167dSPhilipp Reisner 651b411b363SPhilipp Reisner return sock; 652b411b363SPhilipp Reisner } 653b411b363SPhilipp Reisner 6547a426fd8SPhilipp Reisner struct accept_wait_data { 6557a426fd8SPhilipp Reisner struct drbd_tconn *tconn; 6567a426fd8SPhilipp Reisner struct socket *s_listen; 6577a426fd8SPhilipp Reisner struct completion door_bell; 6587a426fd8SPhilipp Reisner void (*original_sk_state_change)(struct sock *sk); 6597a426fd8SPhilipp Reisner 6607a426fd8SPhilipp Reisner }; 6617a426fd8SPhilipp Reisner 662715306f6SAndreas Gruenbacher static void drbd_incoming_connection(struct sock *sk) 663b411b363SPhilipp Reisner { 6647a426fd8SPhilipp Reisner struct accept_wait_data *ad = sk->sk_user_data; 665715306f6SAndreas Gruenbacher void (*state_change)(struct sock *sk); 6667a426fd8SPhilipp Reisner 667715306f6SAndreas Gruenbacher state_change = ad->original_sk_state_change; 668715306f6SAndreas Gruenbacher if (sk->sk_state == TCP_ESTABLISHED) 6697a426fd8SPhilipp Reisner complete(&ad->door_bell); 670715306f6SAndreas Gruenbacher state_change(sk); 6717a426fd8SPhilipp Reisner } 6727a426fd8SPhilipp Reisner 6737a426fd8SPhilipp Reisner static int prepare_listen_socket(struct drbd_tconn *tconn, struct accept_wait_data *ad) 674b411b363SPhilipp Reisner { 6751f3e509bSPhilipp Reisner int err, sndbuf_size, rcvbuf_size, my_addr_len; 67644ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 6771f3e509bSPhilipp Reisner struct socket *s_listen; 67844ed167dSPhilipp Reisner struct net_conf *nc; 679b411b363SPhilipp Reisner const char *what; 680b411b363SPhilipp Reisner 68144ed167dSPhilipp Reisner rcu_read_lock(); 68244ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 68344ed167dSPhilipp Reisner if (!nc) { 68444ed167dSPhilipp Reisner rcu_read_unlock(); 6857a426fd8SPhilipp Reisner return -EIO; 68644ed167dSPhilipp Reisner } 68744ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 68844ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 68944ed167dSPhilipp Reisner rcu_read_unlock(); 690b411b363SPhilipp Reisner 691089c075dSAndreas Gruenbacher my_addr_len = min_t(int, tconn->my_addr_len, sizeof(struct sockaddr_in6)); 692089c075dSAndreas Gruenbacher memcpy(&my_addr, &tconn->my_addr, my_addr_len); 693b411b363SPhilipp Reisner 694b411b363SPhilipp Reisner what = "sock_create_kern"; 69544ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family, 696b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 697b411b363SPhilipp Reisner if (err) { 698b411b363SPhilipp Reisner s_listen = NULL; 699b411b363SPhilipp Reisner goto out; 700b411b363SPhilipp Reisner } 701b411b363SPhilipp Reisner 7024a17fd52SPavel Emelyanov s_listen->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 70344ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 704b411b363SPhilipp Reisner 705b411b363SPhilipp Reisner what = "bind before listen"; 70644ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 707b411b363SPhilipp Reisner if (err < 0) 708b411b363SPhilipp Reisner goto out; 709b411b363SPhilipp Reisner 7107a426fd8SPhilipp Reisner ad->s_listen = s_listen; 7117a426fd8SPhilipp Reisner write_lock_bh(&s_listen->sk->sk_callback_lock); 7127a426fd8SPhilipp Reisner ad->original_sk_state_change = s_listen->sk->sk_state_change; 713715306f6SAndreas Gruenbacher s_listen->sk->sk_state_change = drbd_incoming_connection; 7147a426fd8SPhilipp Reisner s_listen->sk->sk_user_data = ad; 7157a426fd8SPhilipp Reisner write_unlock_bh(&s_listen->sk->sk_callback_lock); 716b411b363SPhilipp Reisner 7172820fd39SPhilipp Reisner what = "listen"; 7182820fd39SPhilipp Reisner err = s_listen->ops->listen(s_listen, 5); 7192820fd39SPhilipp Reisner if (err < 0) 7202820fd39SPhilipp Reisner goto out; 7212820fd39SPhilipp Reisner 7227a426fd8SPhilipp Reisner return 0; 723b411b363SPhilipp Reisner out: 724b411b363SPhilipp Reisner if (s_listen) 725b411b363SPhilipp Reisner sock_release(s_listen); 726b411b363SPhilipp Reisner if (err < 0) { 727b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7281f3e509bSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 7291f3e509bSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 730b411b363SPhilipp Reisner } 731b411b363SPhilipp Reisner } 7321f3e509bSPhilipp Reisner 7337a426fd8SPhilipp Reisner return -EIO; 7341f3e509bSPhilipp Reisner } 7351f3e509bSPhilipp Reisner 736715306f6SAndreas Gruenbacher static void unregister_state_change(struct sock *sk, struct accept_wait_data *ad) 737715306f6SAndreas Gruenbacher { 738715306f6SAndreas Gruenbacher write_lock_bh(&sk->sk_callback_lock); 739715306f6SAndreas Gruenbacher sk->sk_state_change = ad->original_sk_state_change; 740715306f6SAndreas Gruenbacher sk->sk_user_data = NULL; 741715306f6SAndreas Gruenbacher write_unlock_bh(&sk->sk_callback_lock); 742715306f6SAndreas Gruenbacher } 743715306f6SAndreas Gruenbacher 7447a426fd8SPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn, struct accept_wait_data *ad) 7451f3e509bSPhilipp Reisner { 7461f3e509bSPhilipp Reisner int timeo, connect_int, err = 0; 7471f3e509bSPhilipp Reisner struct socket *s_estab = NULL; 7481f3e509bSPhilipp Reisner struct net_conf *nc; 7491f3e509bSPhilipp Reisner 7501f3e509bSPhilipp Reisner rcu_read_lock(); 7511f3e509bSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 7521f3e509bSPhilipp Reisner if (!nc) { 7531f3e509bSPhilipp Reisner rcu_read_unlock(); 7541f3e509bSPhilipp Reisner return NULL; 7551f3e509bSPhilipp Reisner } 7561f3e509bSPhilipp Reisner connect_int = nc->connect_int; 7571f3e509bSPhilipp Reisner rcu_read_unlock(); 7581f3e509bSPhilipp Reisner 7591f3e509bSPhilipp Reisner timeo = connect_int * HZ; 76038b682b2SAkinobu Mita /* 28.5% random jitter */ 76138b682b2SAkinobu Mita timeo += (prandom_u32() & 1) ? timeo / 7 : -timeo / 7; 7621f3e509bSPhilipp Reisner 7637a426fd8SPhilipp Reisner err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); 7647a426fd8SPhilipp Reisner if (err <= 0) 7657a426fd8SPhilipp Reisner return NULL; 7661f3e509bSPhilipp Reisner 7677a426fd8SPhilipp Reisner err = kernel_accept(ad->s_listen, &s_estab, 0); 768b411b363SPhilipp Reisner if (err < 0) { 769b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7701f3e509bSPhilipp Reisner conn_err(tconn, "accept failed, err = %d\n", err); 771bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 772b411b363SPhilipp Reisner } 773b411b363SPhilipp Reisner } 774b411b363SPhilipp Reisner 775715306f6SAndreas Gruenbacher if (s_estab) 776715306f6SAndreas Gruenbacher unregister_state_change(s_estab->sk, ad); 777b411b363SPhilipp Reisner 778b411b363SPhilipp Reisner return s_estab; 779b411b363SPhilipp Reisner } 780b411b363SPhilipp Reisner 781e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *, void *, struct packet_info *); 782b411b363SPhilipp Reisner 7839f5bdc33SAndreas Gruenbacher static int send_first_packet(struct drbd_tconn *tconn, struct drbd_socket *sock, 7849f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7859f5bdc33SAndreas Gruenbacher { 7869f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) 7879f5bdc33SAndreas Gruenbacher return -EIO; 788e658983aSAndreas Gruenbacher return conn_send_command(tconn, sock, cmd, 0, NULL, 0); 789b411b363SPhilipp Reisner } 790b411b363SPhilipp Reisner 7919f5bdc33SAndreas Gruenbacher static int receive_first_packet(struct drbd_tconn *tconn, struct socket *sock) 792b411b363SPhilipp Reisner { 7939f5bdc33SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 7949f5bdc33SAndreas Gruenbacher struct packet_info pi; 7959f5bdc33SAndreas Gruenbacher int err; 796b411b363SPhilipp Reisner 7979f5bdc33SAndreas Gruenbacher err = drbd_recv_short(sock, tconn->data.rbuf, header_size, 0); 7989f5bdc33SAndreas Gruenbacher if (err != header_size) { 7999f5bdc33SAndreas Gruenbacher if (err >= 0) 8009f5bdc33SAndreas Gruenbacher err = -EIO; 8019f5bdc33SAndreas Gruenbacher return err; 8029f5bdc33SAndreas Gruenbacher } 8039f5bdc33SAndreas Gruenbacher err = decode_header(tconn, tconn->data.rbuf, &pi); 8049f5bdc33SAndreas Gruenbacher if (err) 8059f5bdc33SAndreas Gruenbacher return err; 8069f5bdc33SAndreas Gruenbacher return pi.cmd; 807b411b363SPhilipp Reisner } 808b411b363SPhilipp Reisner 809b411b363SPhilipp Reisner /** 810b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 811b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 812b411b363SPhilipp Reisner */ 813dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 814b411b363SPhilipp Reisner { 815b411b363SPhilipp Reisner int rr; 816b411b363SPhilipp Reisner char tb[4]; 817b411b363SPhilipp Reisner 818b411b363SPhilipp Reisner if (!*sock) 81981e84650SAndreas Gruenbacher return false; 820b411b363SPhilipp Reisner 821dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 822b411b363SPhilipp Reisner 823b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 82481e84650SAndreas Gruenbacher return true; 825b411b363SPhilipp Reisner } else { 826b411b363SPhilipp Reisner sock_release(*sock); 827b411b363SPhilipp Reisner *sock = NULL; 82881e84650SAndreas Gruenbacher return false; 829b411b363SPhilipp Reisner } 830b411b363SPhilipp Reisner } 8312325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8322325eb66SPhilipp Reisner in a connection */ 833c141ebdaSPhilipp Reisner int drbd_connected(struct drbd_conf *mdev) 834907599e0SPhilipp Reisner { 8350829f5edSAndreas Gruenbacher int err; 836907599e0SPhilipp Reisner 837907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 838907599e0SPhilipp Reisner mdev->peer_seq = 0; 839907599e0SPhilipp Reisner 8408410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 8418410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 8428410da8fSPhilipp Reisner &mdev->own_state_mutex; 8438410da8fSPhilipp Reisner 8440829f5edSAndreas Gruenbacher err = drbd_send_sync_param(mdev); 8450829f5edSAndreas Gruenbacher if (!err) 8460829f5edSAndreas Gruenbacher err = drbd_send_sizes(mdev, 0, 0); 8470829f5edSAndreas Gruenbacher if (!err) 8480829f5edSAndreas Gruenbacher err = drbd_send_uuids(mdev); 8490829f5edSAndreas Gruenbacher if (!err) 85043de7c85SPhilipp Reisner err = drbd_send_current_state(mdev); 851907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 852907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 8532d56a974SPhilipp Reisner atomic_set(&mdev->ap_in_flight, 0); 8548b924f1dSPhilipp Reisner mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */ 8550829f5edSAndreas Gruenbacher return err; 856907599e0SPhilipp Reisner } 857b411b363SPhilipp Reisner 858b411b363SPhilipp Reisner /* 859b411b363SPhilipp Reisner * return values: 860b411b363SPhilipp Reisner * 1 yes, we have a valid connection 861b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 862b411b363SPhilipp Reisner * -1 peer talks different language, 863b411b363SPhilipp Reisner * no point in trying again, please go standalone. 864b411b363SPhilipp Reisner * -2 We do not have a network config... 865b411b363SPhilipp Reisner */ 86681fa2e67SPhilipp Reisner static int conn_connect(struct drbd_tconn *tconn) 867b411b363SPhilipp Reisner { 8687da35862SPhilipp Reisner struct drbd_socket sock, msock; 869c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 87044ed167dSPhilipp Reisner struct net_conf *nc; 87192f14951SPhilipp Reisner int vnr, timeout, h, ok; 87208b165baSPhilipp Reisner bool discard_my_data; 873197296ffSPhilipp Reisner enum drbd_state_rv rv; 8747a426fd8SPhilipp Reisner struct accept_wait_data ad = { 8757a426fd8SPhilipp Reisner .tconn = tconn, 8767a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 8777a426fd8SPhilipp Reisner }; 878b411b363SPhilipp Reisner 879b66623e3SPhilipp Reisner clear_bit(DISCONNECT_SENT, &tconn->flags); 880bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 881b411b363SPhilipp Reisner return -2; 882b411b363SPhilipp Reisner 8837da35862SPhilipp Reisner mutex_init(&sock.mutex); 8847da35862SPhilipp Reisner sock.sbuf = tconn->data.sbuf; 8857da35862SPhilipp Reisner sock.rbuf = tconn->data.rbuf; 8867da35862SPhilipp Reisner sock.socket = NULL; 8877da35862SPhilipp Reisner mutex_init(&msock.mutex); 8887da35862SPhilipp Reisner msock.sbuf = tconn->meta.sbuf; 8897da35862SPhilipp Reisner msock.rbuf = tconn->meta.rbuf; 8907da35862SPhilipp Reisner msock.socket = NULL; 8917da35862SPhilipp Reisner 8920916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 8930916e0e3SAndreas Gruenbacher tconn->agreed_pro_version = 80; 894b411b363SPhilipp Reisner 8957a426fd8SPhilipp Reisner if (prepare_listen_socket(tconn, &ad)) 8967a426fd8SPhilipp Reisner return 0; 897b411b363SPhilipp Reisner 898b411b363SPhilipp Reisner do { 8992bf89621SAndreas Gruenbacher struct socket *s; 900b411b363SPhilipp Reisner 901907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 902b411b363SPhilipp Reisner if (s) { 9037da35862SPhilipp Reisner if (!sock.socket) { 9047da35862SPhilipp Reisner sock.socket = s; 9057da35862SPhilipp Reisner send_first_packet(tconn, &sock, P_INITIAL_DATA); 9067da35862SPhilipp Reisner } else if (!msock.socket) { 907427c0434SLars Ellenberg clear_bit(RESOLVE_CONFLICTS, &tconn->flags); 9087da35862SPhilipp Reisner msock.socket = s; 9097da35862SPhilipp Reisner send_first_packet(tconn, &msock, P_INITIAL_META); 910b411b363SPhilipp Reisner } else { 91181fa2e67SPhilipp Reisner conn_err(tconn, "Logic error in conn_connect()\n"); 912b411b363SPhilipp Reisner goto out_release_sockets; 913b411b363SPhilipp Reisner } 914b411b363SPhilipp Reisner } 915b411b363SPhilipp Reisner 9167da35862SPhilipp Reisner if (sock.socket && msock.socket) { 9177da35862SPhilipp Reisner rcu_read_lock(); 9187da35862SPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 9197da35862SPhilipp Reisner timeout = nc->ping_timeo * HZ / 10; 9207da35862SPhilipp Reisner rcu_read_unlock(); 9217da35862SPhilipp Reisner schedule_timeout_interruptible(timeout); 9227da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9237da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 924b411b363SPhilipp Reisner if (ok) 925b411b363SPhilipp Reisner break; 926b411b363SPhilipp Reisner } 927b411b363SPhilipp Reisner 928b411b363SPhilipp Reisner retry: 9297a426fd8SPhilipp Reisner s = drbd_wait_for_connect(tconn, &ad); 930b411b363SPhilipp Reisner if (s) { 93192f14951SPhilipp Reisner int fp = receive_first_packet(tconn, s); 9327da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9337da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 93492f14951SPhilipp Reisner switch (fp) { 935e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9367da35862SPhilipp Reisner if (sock.socket) { 937907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 9387da35862SPhilipp Reisner sock_release(sock.socket); 93980c6eed4SPhilipp Reisner sock.socket = s; 94080c6eed4SPhilipp Reisner goto randomize; 941b411b363SPhilipp Reisner } 9427da35862SPhilipp Reisner sock.socket = s; 943b411b363SPhilipp Reisner break; 944e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 945427c0434SLars Ellenberg set_bit(RESOLVE_CONFLICTS, &tconn->flags); 9467da35862SPhilipp Reisner if (msock.socket) { 947907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 9487da35862SPhilipp Reisner sock_release(msock.socket); 94980c6eed4SPhilipp Reisner msock.socket = s; 95080c6eed4SPhilipp Reisner goto randomize; 951b411b363SPhilipp Reisner } 9527da35862SPhilipp Reisner msock.socket = s; 953b411b363SPhilipp Reisner break; 954b411b363SPhilipp Reisner default: 955907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 956b411b363SPhilipp Reisner sock_release(s); 95780c6eed4SPhilipp Reisner randomize: 95838b682b2SAkinobu Mita if (prandom_u32() & 1) 959b411b363SPhilipp Reisner goto retry; 960b411b363SPhilipp Reisner } 961b411b363SPhilipp Reisner } 962b411b363SPhilipp Reisner 963bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 964b411b363SPhilipp Reisner goto out_release_sockets; 965b411b363SPhilipp Reisner if (signal_pending(current)) { 966b411b363SPhilipp Reisner flush_signals(current); 967b411b363SPhilipp Reisner smp_rmb(); 968907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 969b411b363SPhilipp Reisner goto out_release_sockets; 970b411b363SPhilipp Reisner } 971b411b363SPhilipp Reisner 9727da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9737da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 974b666dbf8SPhilipp Reisner } while (!ok); 975b411b363SPhilipp Reisner 9767a426fd8SPhilipp Reisner if (ad.s_listen) 9777a426fd8SPhilipp Reisner sock_release(ad.s_listen); 978b411b363SPhilipp Reisner 97998683650SPhilipp Reisner sock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 98098683650SPhilipp Reisner msock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 981b411b363SPhilipp Reisner 9827da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 9837da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 984b411b363SPhilipp Reisner 9857da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 9867da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 987b411b363SPhilipp Reisner 988b411b363SPhilipp Reisner /* NOT YET ... 9897da35862SPhilipp Reisner * sock.socket->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 9907da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 9916038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 992b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 99344ed167dSPhilipp Reisner rcu_read_lock(); 99444ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 995b411b363SPhilipp Reisner 9967da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 9977da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 99844ed167dSPhilipp Reisner 9997da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 100044ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 100108b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 100244ed167dSPhilipp Reisner rcu_read_unlock(); 100344ed167dSPhilipp Reisner 10047da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 1005b411b363SPhilipp Reisner 1006b411b363SPhilipp Reisner /* we don't want delays. 100725985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10087da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10097da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1010b411b363SPhilipp Reisner 10117da35862SPhilipp Reisner tconn->data.socket = sock.socket; 10127da35862SPhilipp Reisner tconn->meta.socket = msock.socket; 1013907599e0SPhilipp Reisner tconn->last_received = jiffies; 1014b411b363SPhilipp Reisner 10156038178eSAndreas Gruenbacher h = drbd_do_features(tconn); 1016b411b363SPhilipp Reisner if (h <= 0) 1017b411b363SPhilipp Reisner return h; 1018b411b363SPhilipp Reisner 1019907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 1020b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 1021907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 1022b10d96cbSJohannes Thoma case -1: 1023907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 1024b411b363SPhilipp Reisner return -1; 1025b10d96cbSJohannes Thoma case 0: 1026907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 1027b10d96cbSJohannes Thoma return 0; 1028b411b363SPhilipp Reisner } 1029b411b363SPhilipp Reisner } 1030b411b363SPhilipp Reisner 10317da35862SPhilipp Reisner tconn->data.socket->sk->sk_sndtimeo = timeout; 10327da35862SPhilipp Reisner tconn->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1033b411b363SPhilipp Reisner 1034387eb308SAndreas Gruenbacher if (drbd_send_protocol(tconn) == -EOPNOTSUPP) 10357e2455c1SPhilipp Reisner return -1; 10361e86ac48SPhilipp Reisner 1037a1096a6eSPhilipp Reisner set_bit(STATE_SENT, &tconn->flags); 1038197296ffSPhilipp Reisner 1039c141ebdaSPhilipp Reisner rcu_read_lock(); 1040c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 1041c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 104226ea8f92SAndreas Gruenbacher rcu_read_unlock(); 104326ea8f92SAndreas Gruenbacher 104413c76abaSPhilipp Reisner /* Prevent a race between resync-handshake and 104513c76abaSPhilipp Reisner * being promoted to Primary. 104613c76abaSPhilipp Reisner * 104713c76abaSPhilipp Reisner * Grab and release the state mutex, so we know that any current 104813c76abaSPhilipp Reisner * drbd_set_role() is finished, and any incoming drbd_set_role 104913c76abaSPhilipp Reisner * will see the STATE_SENT flag, and wait for it to be cleared. 105013c76abaSPhilipp Reisner */ 105113c76abaSPhilipp Reisner mutex_lock(mdev->state_mutex); 105213c76abaSPhilipp Reisner mutex_unlock(mdev->state_mutex); 105313c76abaSPhilipp Reisner 105408b165baSPhilipp Reisner if (discard_my_data) 105508b165baSPhilipp Reisner set_bit(DISCARD_MY_DATA, &mdev->flags); 105608b165baSPhilipp Reisner else 105708b165baSPhilipp Reisner clear_bit(DISCARD_MY_DATA, &mdev->flags); 105808b165baSPhilipp Reisner 1059c141ebdaSPhilipp Reisner drbd_connected(mdev); 1060c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 1061c141ebdaSPhilipp Reisner rcu_read_lock(); 1062c141ebdaSPhilipp Reisner } 1063c141ebdaSPhilipp Reisner rcu_read_unlock(); 1064c141ebdaSPhilipp Reisner 1065a1096a6eSPhilipp Reisner rv = conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1066ed635cb0SLars Ellenberg if (rv < SS_SUCCESS || tconn->cstate != C_WF_REPORT_PARAMS) { 1067a1096a6eSPhilipp Reisner clear_bit(STATE_SENT, &tconn->flags); 10681e86ac48SPhilipp Reisner return 0; 1069a1096a6eSPhilipp Reisner } 10701e86ac48SPhilipp Reisner 1071823bd832SPhilipp Reisner drbd_thread_start(&tconn->asender); 1072b411b363SPhilipp Reisner 107308b165baSPhilipp Reisner mutex_lock(&tconn->conf_update); 107408b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 107508b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 107608b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 107708b165baSPhilipp Reisner * just to clear a single value. */ 107808b165baSPhilipp Reisner tconn->net_conf->discard_my_data = 0; 107908b165baSPhilipp Reisner mutex_unlock(&tconn->conf_update); 108008b165baSPhilipp Reisner 1081d3fcb490SPhilipp Reisner return h; 1082b411b363SPhilipp Reisner 1083b411b363SPhilipp Reisner out_release_sockets: 10847a426fd8SPhilipp Reisner if (ad.s_listen) 10857a426fd8SPhilipp Reisner sock_release(ad.s_listen); 10867da35862SPhilipp Reisner if (sock.socket) 10877da35862SPhilipp Reisner sock_release(sock.socket); 10887da35862SPhilipp Reisner if (msock.socket) 10897da35862SPhilipp Reisner sock_release(msock.socket); 1090b411b363SPhilipp Reisner return -1; 1091b411b363SPhilipp Reisner } 1092b411b363SPhilipp Reisner 1093e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *tconn, void *header, struct packet_info *pi) 1094b411b363SPhilipp Reisner { 1095e658983aSAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 1096b411b363SPhilipp Reisner 10970c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 10980c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 10990c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 11000c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 11010c8e36d9SAndreas Gruenbacher conn_err(tconn, "Header padding is not zero\n"); 11020c8e36d9SAndreas Gruenbacher return -EINVAL; 110302918be2SPhilipp Reisner } 11040c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11050c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11060c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11070c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1108e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1109e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1110e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1111b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1112eefc2f7dSPhilipp Reisner pi->vnr = 0; 1113e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1114e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1115e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1116e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1117e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 111877351055SPhilipp Reisner pi->vnr = 0; 111902918be2SPhilipp Reisner } else { 1120e658983aSAndreas Gruenbacher conn_err(tconn, "Wrong magic value 0x%08x in protocol version %d\n", 1121e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1122e658983aSAndreas Gruenbacher tconn->agreed_pro_version); 11238172f3e9SAndreas Gruenbacher return -EINVAL; 1124b411b363SPhilipp Reisner } 1125e658983aSAndreas Gruenbacher pi->data = header + header_size; 11268172f3e9SAndreas Gruenbacher return 0; 1127b411b363SPhilipp Reisner } 1128b411b363SPhilipp Reisner 11299ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 1130257d0af6SPhilipp Reisner { 1131e658983aSAndreas Gruenbacher void *buffer = tconn->data.rbuf; 113269bc7bc3SAndreas Gruenbacher int err; 1133257d0af6SPhilipp Reisner 1134e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, buffer, drbd_header_size(tconn)); 1135a5c31904SAndreas Gruenbacher if (err) 113669bc7bc3SAndreas Gruenbacher return err; 1137257d0af6SPhilipp Reisner 1138e658983aSAndreas Gruenbacher err = decode_header(tconn, buffer, pi); 11399ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 1140b411b363SPhilipp Reisner 114169bc7bc3SAndreas Gruenbacher return err; 1142b411b363SPhilipp Reisner } 1143b411b363SPhilipp Reisner 11444b0007c0SPhilipp Reisner static void drbd_flush(struct drbd_tconn *tconn) 1145b411b363SPhilipp Reisner { 1146b411b363SPhilipp Reisner int rv; 11474b0007c0SPhilipp Reisner struct drbd_conf *mdev; 11484b0007c0SPhilipp Reisner int vnr; 1149b411b363SPhilipp Reisner 11504b0007c0SPhilipp Reisner if (tconn->write_ordering >= WO_bdev_flush) { 1151615e087fSLars Ellenberg rcu_read_lock(); 11524b0007c0SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 1153615e087fSLars Ellenberg if (!get_ldev(mdev)) 1154615e087fSLars Ellenberg continue; 1155615e087fSLars Ellenberg kref_get(&mdev->kref); 1156615e087fSLars Ellenberg rcu_read_unlock(); 11574b0007c0SPhilipp Reisner 1158615e087fSLars Ellenberg rv = blkdev_issue_flush(mdev->ldev->backing_bdev, 1159615e087fSLars Ellenberg GFP_NOIO, NULL); 1160b411b363SPhilipp Reisner if (rv) { 1161ebd2b0cdSPhilipp Reisner dev_info(DEV, "local disk flush failed with status %d\n", rv); 1162b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1163b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1164b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 11654b0007c0SPhilipp Reisner drbd_bump_write_ordering(tconn, WO_drain_io); 1166b411b363SPhilipp Reisner } 1167b411b363SPhilipp Reisner put_ldev(mdev); 1168615e087fSLars Ellenberg kref_put(&mdev->kref, &drbd_minor_destroy); 1169615e087fSLars Ellenberg 1170615e087fSLars Ellenberg rcu_read_lock(); 1171615e087fSLars Ellenberg if (rv) 11724b0007c0SPhilipp Reisner break; 1173b411b363SPhilipp Reisner } 1174615e087fSLars Ellenberg rcu_read_unlock(); 1175b411b363SPhilipp Reisner } 1176b411b363SPhilipp Reisner } 1177b411b363SPhilipp Reisner 1178b411b363SPhilipp Reisner /** 1179b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1180b411b363SPhilipp Reisner * @mdev: DRBD device. 1181b411b363SPhilipp Reisner * @epoch: Epoch object. 1182b411b363SPhilipp Reisner * @ev: Epoch event. 1183b411b363SPhilipp Reisner */ 11841e9dd291SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_tconn *tconn, 1185b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1186b411b363SPhilipp Reisner enum epoch_event ev) 1187b411b363SPhilipp Reisner { 11882451fc3bSPhilipp Reisner int epoch_size; 1189b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1190b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1191b411b363SPhilipp Reisner 119212038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 1193b411b363SPhilipp Reisner do { 1194b411b363SPhilipp Reisner next_epoch = NULL; 1195b411b363SPhilipp Reisner 1196b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1197b411b363SPhilipp Reisner 1198b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1199b411b363SPhilipp Reisner case EV_PUT: 1200b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1201b411b363SPhilipp Reisner break; 1202b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1203b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1204b411b363SPhilipp Reisner break; 1205b411b363SPhilipp Reisner case EV_BECAME_LAST: 1206b411b363SPhilipp Reisner /* nothing to do*/ 1207b411b363SPhilipp Reisner break; 1208b411b363SPhilipp Reisner } 1209b411b363SPhilipp Reisner 1210b411b363SPhilipp Reisner if (epoch_size != 0 && 1211b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 121280f9fd55SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1213b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 121412038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 12159ed57dcbSLars Ellenberg drbd_send_b_ack(epoch->tconn, epoch->barrier_nr, epoch_size); 121612038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 1217b411b363SPhilipp Reisner } 12189ed57dcbSLars Ellenberg #if 0 12199ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 12209ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 122180f9fd55SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 12229ed57dcbSLars Ellenberg dec_unacked(epoch->tconn); 12239ed57dcbSLars Ellenberg #endif 1224b411b363SPhilipp Reisner 122512038a3aSPhilipp Reisner if (tconn->current_epoch != epoch) { 1226b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1227b411b363SPhilipp Reisner list_del(&epoch->list); 1228b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 122912038a3aSPhilipp Reisner tconn->epochs--; 1230b411b363SPhilipp Reisner kfree(epoch); 1231b411b363SPhilipp Reisner 1232b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1233b411b363SPhilipp Reisner rv = FE_DESTROYED; 1234b411b363SPhilipp Reisner } else { 1235b411b363SPhilipp Reisner epoch->flags = 0; 1236b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1237698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1238b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1239b411b363SPhilipp Reisner rv = FE_RECYCLED; 1240b411b363SPhilipp Reisner } 1241b411b363SPhilipp Reisner } 1242b411b363SPhilipp Reisner 1243b411b363SPhilipp Reisner if (!next_epoch) 1244b411b363SPhilipp Reisner break; 1245b411b363SPhilipp Reisner 1246b411b363SPhilipp Reisner epoch = next_epoch; 1247b411b363SPhilipp Reisner } while (1); 1248b411b363SPhilipp Reisner 124912038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 1250b411b363SPhilipp Reisner 1251b411b363SPhilipp Reisner return rv; 1252b411b363SPhilipp Reisner } 1253b411b363SPhilipp Reisner 1254b411b363SPhilipp Reisner /** 1255b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 12564b0007c0SPhilipp Reisner * @tconn: DRBD connection. 1257b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1258b411b363SPhilipp Reisner */ 12594b0007c0SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_tconn *tconn, enum write_ordering_e wo) 1260b411b363SPhilipp Reisner { 1261daeda1ccSPhilipp Reisner struct disk_conf *dc; 12624b0007c0SPhilipp Reisner struct drbd_conf *mdev; 1263b411b363SPhilipp Reisner enum write_ordering_e pwo; 12644b0007c0SPhilipp Reisner int vnr; 1265b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1266b411b363SPhilipp Reisner [WO_none] = "none", 1267b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1268b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1269b411b363SPhilipp Reisner }; 1270b411b363SPhilipp Reisner 12714b0007c0SPhilipp Reisner pwo = tconn->write_ordering; 1272b411b363SPhilipp Reisner wo = min(pwo, wo); 1273daeda1ccSPhilipp Reisner rcu_read_lock(); 12744b0007c0SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 127527eb13e9SPhilipp Reisner if (!get_ldev_if_state(mdev, D_ATTACHING)) 12764b0007c0SPhilipp Reisner continue; 1277daeda1ccSPhilipp Reisner dc = rcu_dereference(mdev->ldev->disk_conf); 1278daeda1ccSPhilipp Reisner 127966b2f6b9SAndreas Gruenbacher if (wo == WO_bdev_flush && !dc->disk_flushes) 1280b411b363SPhilipp Reisner wo = WO_drain_io; 1281d0c980e2SAndreas Gruenbacher if (wo == WO_drain_io && !dc->disk_drain) 1282b411b363SPhilipp Reisner wo = WO_none; 12834b0007c0SPhilipp Reisner put_ldev(mdev); 12844b0007c0SPhilipp Reisner } 1285daeda1ccSPhilipp Reisner rcu_read_unlock(); 12864b0007c0SPhilipp Reisner tconn->write_ordering = wo; 12874b0007c0SPhilipp Reisner if (pwo != tconn->write_ordering || wo == WO_bdev_flush) 12884b0007c0SPhilipp Reisner conn_info(tconn, "Method to ensure write ordering: %s\n", write_ordering_str[tconn->write_ordering]); 1289b411b363SPhilipp Reisner } 1290b411b363SPhilipp Reisner 1291b411b363SPhilipp Reisner /** 1292fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 129345bb912bSLars Ellenberg * @mdev: DRBD device. 1294db830c46SAndreas Gruenbacher * @peer_req: peer request 129545bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 129610f6d992SLars Ellenberg * 129710f6d992SLars Ellenberg * May spread the pages to multiple bios, 129810f6d992SLars Ellenberg * depending on bio_add_page restrictions. 129910f6d992SLars Ellenberg * 130010f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 130110f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 130210f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 130310f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 130410f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 130510f6d992SLars Ellenberg * on certain Xen deployments. 130645bb912bSLars Ellenberg */ 130745bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1308fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1309fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 131045bb912bSLars Ellenberg const unsigned rw, const int fault_type) 131145bb912bSLars Ellenberg { 131245bb912bSLars Ellenberg struct bio *bios = NULL; 131345bb912bSLars Ellenberg struct bio *bio; 1314db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1315db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1316db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 131745bb912bSLars Ellenberg unsigned n_bios = 0; 131845bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 131910f6d992SLars Ellenberg int err = -ENOMEM; 132045bb912bSLars Ellenberg 132145bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 132245bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 132345bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 13249476f39dSLars Ellenberg * request in more than one bio. 13259476f39dSLars Ellenberg * 13269476f39dSLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 13279476f39dSLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 13289476f39dSLars Ellenberg */ 132945bb912bSLars Ellenberg next_bio: 133045bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 133145bb912bSLars Ellenberg if (!bio) { 133245bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 133345bb912bSLars Ellenberg goto fail; 133445bb912bSLars Ellenberg } 1335db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 133645bb912bSLars Ellenberg bio->bi_sector = sector; 133745bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 133845bb912bSLars Ellenberg bio->bi_rw = rw; 1339db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1340fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 134145bb912bSLars Ellenberg 134245bb912bSLars Ellenberg bio->bi_next = bios; 134345bb912bSLars Ellenberg bios = bio; 134445bb912bSLars Ellenberg ++n_bios; 134545bb912bSLars Ellenberg 134645bb912bSLars Ellenberg page_chain_for_each(page) { 134745bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 134845bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 134910f6d992SLars Ellenberg /* A single page must always be possible! 135010f6d992SLars Ellenberg * But in case it fails anyways, 135110f6d992SLars Ellenberg * we deal with it, and complain (below). */ 135210f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 135310f6d992SLars Ellenberg dev_err(DEV, 135410f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 135510f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 135610f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 135710f6d992SLars Ellenberg err = -ENOSPC; 135810f6d992SLars Ellenberg goto fail; 135910f6d992SLars Ellenberg } 136045bb912bSLars Ellenberg goto next_bio; 136145bb912bSLars Ellenberg } 136245bb912bSLars Ellenberg ds -= len; 136345bb912bSLars Ellenberg sector += len >> 9; 136445bb912bSLars Ellenberg --nr_pages; 136545bb912bSLars Ellenberg } 136645bb912bSLars Ellenberg D_ASSERT(page == NULL); 136745bb912bSLars Ellenberg D_ASSERT(ds == 0); 136845bb912bSLars Ellenberg 1369db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 137045bb912bSLars Ellenberg do { 137145bb912bSLars Ellenberg bio = bios; 137245bb912bSLars Ellenberg bios = bios->bi_next; 137345bb912bSLars Ellenberg bio->bi_next = NULL; 137445bb912bSLars Ellenberg 137545bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 137645bb912bSLars Ellenberg } while (bios); 137745bb912bSLars Ellenberg return 0; 137845bb912bSLars Ellenberg 137945bb912bSLars Ellenberg fail: 138045bb912bSLars Ellenberg while (bios) { 138145bb912bSLars Ellenberg bio = bios; 138245bb912bSLars Ellenberg bios = bios->bi_next; 138345bb912bSLars Ellenberg bio_put(bio); 138445bb912bSLars Ellenberg } 138510f6d992SLars Ellenberg return err; 138645bb912bSLars Ellenberg } 138745bb912bSLars Ellenberg 138853840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1389db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 139053840641SAndreas Gruenbacher { 1391db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 139253840641SAndreas Gruenbacher 139353840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 139453840641SAndreas Gruenbacher drbd_clear_interval(i); 139553840641SAndreas Gruenbacher 13966c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 139753840641SAndreas Gruenbacher if (i->waiting) 139853840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 139953840641SAndreas Gruenbacher } 140053840641SAndreas Gruenbacher 140177fede51SPhilipp Reisner void conn_wait_active_ee_empty(struct drbd_tconn *tconn) 140277fede51SPhilipp Reisner { 140377fede51SPhilipp Reisner struct drbd_conf *mdev; 140477fede51SPhilipp Reisner int vnr; 140577fede51SPhilipp Reisner 140677fede51SPhilipp Reisner rcu_read_lock(); 140777fede51SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 140877fede51SPhilipp Reisner kref_get(&mdev->kref); 140977fede51SPhilipp Reisner rcu_read_unlock(); 141077fede51SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 141177fede51SPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 141277fede51SPhilipp Reisner rcu_read_lock(); 141377fede51SPhilipp Reisner } 141477fede51SPhilipp Reisner rcu_read_unlock(); 141577fede51SPhilipp Reisner } 141677fede51SPhilipp Reisner 14174a76b161SAndreas Gruenbacher static int receive_Barrier(struct drbd_tconn *tconn, struct packet_info *pi) 1418b411b363SPhilipp Reisner { 14192451fc3bSPhilipp Reisner int rv; 1420e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1421b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1422b411b363SPhilipp Reisner 14239ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 14249ed57dcbSLars Ellenberg * not a specific (peer)device. 14259ed57dcbSLars Ellenberg */ 142612038a3aSPhilipp Reisner tconn->current_epoch->barrier_nr = p->barrier; 14279ed57dcbSLars Ellenberg tconn->current_epoch->tconn = tconn; 14281e9dd291SPhilipp Reisner rv = drbd_may_finish_epoch(tconn, tconn->current_epoch, EV_GOT_BARRIER_NR); 1429b411b363SPhilipp Reisner 1430b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1431b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1432b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1433b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1434b411b363SPhilipp Reisner * completed. */ 14354b0007c0SPhilipp Reisner switch (tconn->write_ordering) { 1436b411b363SPhilipp Reisner case WO_none: 1437b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 143882bc0194SAndreas Gruenbacher return 0; 1439b411b363SPhilipp Reisner 1440b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1441b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1442b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14432451fc3bSPhilipp Reisner if (epoch) 14442451fc3bSPhilipp Reisner break; 14452451fc3bSPhilipp Reisner else 14469ed57dcbSLars Ellenberg conn_warn(tconn, "Allocation of an epoch failed, slowing down\n"); 14472451fc3bSPhilipp Reisner /* Fall through */ 14482451fc3bSPhilipp Reisner 14492451fc3bSPhilipp Reisner case WO_bdev_flush: 14502451fc3bSPhilipp Reisner case WO_drain_io: 145177fede51SPhilipp Reisner conn_wait_active_ee_empty(tconn); 14524b0007c0SPhilipp Reisner drbd_flush(tconn); 14532451fc3bSPhilipp Reisner 145412038a3aSPhilipp Reisner if (atomic_read(&tconn->current_epoch->epoch_size)) { 14552451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14562451fc3bSPhilipp Reisner if (epoch) 14572451fc3bSPhilipp Reisner break; 1458b411b363SPhilipp Reisner } 1459b411b363SPhilipp Reisner 146082bc0194SAndreas Gruenbacher return 0; 14612451fc3bSPhilipp Reisner default: 14629ed57dcbSLars Ellenberg conn_err(tconn, "Strangeness in tconn->write_ordering %d\n", tconn->write_ordering); 146382bc0194SAndreas Gruenbacher return -EIO; 1464b411b363SPhilipp Reisner } 1465b411b363SPhilipp Reisner 1466b411b363SPhilipp Reisner epoch->flags = 0; 1467b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1468b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1469b411b363SPhilipp Reisner 147012038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 147112038a3aSPhilipp Reisner if (atomic_read(&tconn->current_epoch->epoch_size)) { 147212038a3aSPhilipp Reisner list_add(&epoch->list, &tconn->current_epoch->list); 147312038a3aSPhilipp Reisner tconn->current_epoch = epoch; 147412038a3aSPhilipp Reisner tconn->epochs++; 1475b411b363SPhilipp Reisner } else { 1476b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1477b411b363SPhilipp Reisner kfree(epoch); 1478b411b363SPhilipp Reisner } 147912038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 1480b411b363SPhilipp Reisner 148182bc0194SAndreas Gruenbacher return 0; 1482b411b363SPhilipp Reisner } 1483b411b363SPhilipp Reisner 1484b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1485b411b363SPhilipp Reisner * and from receive_Data */ 1486f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1487f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1488f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1489b411b363SPhilipp Reisner { 14906666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1491db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1492b411b363SPhilipp Reisner struct page *page; 1493a5c31904SAndreas Gruenbacher int dgs, ds, err; 1494a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1495a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 14966b4388acSPhilipp Reisner unsigned long *data; 1497b411b363SPhilipp Reisner 149888104ca4SAndreas Gruenbacher dgs = 0; 149988104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 150088104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 15019f5bdc33SAndreas Gruenbacher /* 15029f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 15039f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 15049f5bdc33SAndreas Gruenbacher */ 1505a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1506a5c31904SAndreas Gruenbacher if (err) 1507b411b363SPhilipp Reisner return NULL; 1508b411b363SPhilipp Reisner data_size -= dgs; 150988104ca4SAndreas Gruenbacher } 1510b411b363SPhilipp Reisner 1511841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1512841ce241SAndreas Gruenbacher return NULL; 1513841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1514841ce241SAndreas Gruenbacher return NULL; 1515b411b363SPhilipp Reisner 15166666032aSLars Ellenberg /* even though we trust out peer, 15176666032aSLars Ellenberg * we sometimes have to double check. */ 15186666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1519fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1520fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 15216666032aSLars Ellenberg (unsigned long long)capacity, 15226666032aSLars Ellenberg (unsigned long long)sector, data_size); 15236666032aSLars Ellenberg return NULL; 15246666032aSLars Ellenberg } 15256666032aSLars Ellenberg 1526b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1527b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1528b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 15290db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, id, sector, data_size, GFP_NOIO); 1530db830c46SAndreas Gruenbacher if (!peer_req) 1531b411b363SPhilipp Reisner return NULL; 153245bb912bSLars Ellenberg 1533a73ff323SLars Ellenberg if (!data_size) 153481a3537aSLars Ellenberg return peer_req; 1535a73ff323SLars Ellenberg 1536b411b363SPhilipp Reisner ds = data_size; 1537db830c46SAndreas Gruenbacher page = peer_req->pages; 153845bb912bSLars Ellenberg page_chain_for_each(page) { 153945bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 15406b4388acSPhilipp Reisner data = kmap(page); 1541a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 15420cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 15436b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 15446b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 15456b4388acSPhilipp Reisner } 1546b411b363SPhilipp Reisner kunmap(page); 1547a5c31904SAndreas Gruenbacher if (err) { 15483967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1549b411b363SPhilipp Reisner return NULL; 1550b411b363SPhilipp Reisner } 1551a5c31904SAndreas Gruenbacher ds -= len; 1552b411b363SPhilipp Reisner } 1553b411b363SPhilipp Reisner 1554b411b363SPhilipp Reisner if (dgs) { 15555b614abeSAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->peer_integrity_tfm, peer_req, dig_vv); 1556b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1557470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1558470be44aSLars Ellenberg (unsigned long long)sector, data_size); 15593967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1560b411b363SPhilipp Reisner return NULL; 1561b411b363SPhilipp Reisner } 1562b411b363SPhilipp Reisner } 1563b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1564db830c46SAndreas Gruenbacher return peer_req; 1565b411b363SPhilipp Reisner } 1566b411b363SPhilipp Reisner 1567b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1568b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1569b411b363SPhilipp Reisner */ 1570b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1571b411b363SPhilipp Reisner { 1572b411b363SPhilipp Reisner struct page *page; 1573a5c31904SAndreas Gruenbacher int err = 0; 1574b411b363SPhilipp Reisner void *data; 1575b411b363SPhilipp Reisner 1576c3470cdeSLars Ellenberg if (!data_size) 1577fc5be839SAndreas Gruenbacher return 0; 1578c3470cdeSLars Ellenberg 1579c37c8ecfSAndreas Gruenbacher page = drbd_alloc_pages(mdev, 1, 1); 1580b411b363SPhilipp Reisner 1581b411b363SPhilipp Reisner data = kmap(page); 1582b411b363SPhilipp Reisner while (data_size) { 1583fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1584fc5be839SAndreas Gruenbacher 1585a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 1586a5c31904SAndreas Gruenbacher if (err) 1587b411b363SPhilipp Reisner break; 1588a5c31904SAndreas Gruenbacher data_size -= len; 1589b411b363SPhilipp Reisner } 1590b411b363SPhilipp Reisner kunmap(page); 15915cc287e0SAndreas Gruenbacher drbd_free_pages(mdev, page, 0); 1592fc5be839SAndreas Gruenbacher return err; 1593b411b363SPhilipp Reisner } 1594b411b363SPhilipp Reisner 1595b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1596b411b363SPhilipp Reisner sector_t sector, int data_size) 1597b411b363SPhilipp Reisner { 1598b411b363SPhilipp Reisner struct bio_vec *bvec; 1599b411b363SPhilipp Reisner struct bio *bio; 1600a5c31904SAndreas Gruenbacher int dgs, err, i, expect; 1601a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1602a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1603b411b363SPhilipp Reisner 160488104ca4SAndreas Gruenbacher dgs = 0; 160588104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 160688104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 1607a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1608a5c31904SAndreas Gruenbacher if (err) 1609a5c31904SAndreas Gruenbacher return err; 1610b411b363SPhilipp Reisner data_size -= dgs; 161188104ca4SAndreas Gruenbacher } 1612b411b363SPhilipp Reisner 1613b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1614b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1615b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1616b411b363SPhilipp Reisner 1617b411b363SPhilipp Reisner bio = req->master_bio; 1618b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1619b411b363SPhilipp Reisner 1620b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1621a5c31904SAndreas Gruenbacher void *mapped = kmap(bvec->bv_page) + bvec->bv_offset; 1622b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1623a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, mapped, expect); 1624b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1625a5c31904SAndreas Gruenbacher if (err) 1626a5c31904SAndreas Gruenbacher return err; 1627a5c31904SAndreas Gruenbacher data_size -= expect; 1628b411b363SPhilipp Reisner } 1629b411b363SPhilipp Reisner 1630b411b363SPhilipp Reisner if (dgs) { 16315b614abeSAndreas Gruenbacher drbd_csum_bio(mdev, mdev->tconn->peer_integrity_tfm, bio, dig_vv); 1632b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1633b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 163428284cefSAndreas Gruenbacher return -EINVAL; 1635b411b363SPhilipp Reisner } 1636b411b363SPhilipp Reisner } 1637b411b363SPhilipp Reisner 1638b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 163928284cefSAndreas Gruenbacher return 0; 1640b411b363SPhilipp Reisner } 1641b411b363SPhilipp Reisner 1642a990be46SAndreas Gruenbacher /* 1643a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1644a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1645a990be46SAndreas Gruenbacher */ 164699920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1647b411b363SPhilipp Reisner { 16488050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16498050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 165000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1651db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 165299920dc5SAndreas Gruenbacher int err; 1653b411b363SPhilipp Reisner 1654db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1655b411b363SPhilipp Reisner 1656db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1657db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 165899920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1659b411b363SPhilipp Reisner } else { 1660b411b363SPhilipp Reisner /* Record failure to sync */ 1661db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1662b411b363SPhilipp Reisner 166399920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1664b411b363SPhilipp Reisner } 1665b411b363SPhilipp Reisner dec_unacked(mdev); 1666b411b363SPhilipp Reisner 166799920dc5SAndreas Gruenbacher return err; 1668b411b363SPhilipp Reisner } 1669b411b363SPhilipp Reisner 1670b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1671b411b363SPhilipp Reisner { 1672db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1673b411b363SPhilipp Reisner 1674db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1675db830c46SAndreas Gruenbacher if (!peer_req) 167645bb912bSLars Ellenberg goto fail; 1677b411b363SPhilipp Reisner 1678b411b363SPhilipp Reisner dec_rs_pending(mdev); 1679b411b363SPhilipp Reisner 1680b411b363SPhilipp Reisner inc_unacked(mdev); 1681b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1682b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1683b411b363SPhilipp Reisner 1684db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 168545bb912bSLars Ellenberg 168687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1687db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 168887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1689b411b363SPhilipp Reisner 16900f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1691fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1692e1c1b0fcSAndreas Gruenbacher return 0; 169345bb912bSLars Ellenberg 169410f6d992SLars Ellenberg /* don't care for the reason here */ 169510f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 169687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1697db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 169887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 169922cc37a9SLars Ellenberg 17003967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 170145bb912bSLars Ellenberg fail: 170245bb912bSLars Ellenberg put_ldev(mdev); 1703e1c1b0fcSAndreas Gruenbacher return -EIO; 1704b411b363SPhilipp Reisner } 1705b411b363SPhilipp Reisner 1706668eebc6SAndreas Gruenbacher static struct drbd_request * 1707bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1708bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1709b411b363SPhilipp Reisner { 1710b411b363SPhilipp Reisner struct drbd_request *req; 1711668eebc6SAndreas Gruenbacher 1712bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1713bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 17145e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1715668eebc6SAndreas Gruenbacher return req; 1716c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 17175af172edSAndreas Gruenbacher dev_err(DEV, "%s: failed to find request 0x%lx, sector %llus\n", func, 1718c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1719c3afd8f5SAndreas Gruenbacher } 1720668eebc6SAndreas Gruenbacher return NULL; 1721668eebc6SAndreas Gruenbacher } 1722668eebc6SAndreas Gruenbacher 17234a76b161SAndreas Gruenbacher static int receive_DataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1724b411b363SPhilipp Reisner { 17254a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1726b411b363SPhilipp Reisner struct drbd_request *req; 1727b411b363SPhilipp Reisner sector_t sector; 172882bc0194SAndreas Gruenbacher int err; 1729e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17304a76b161SAndreas Gruenbacher 17314a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 17324a76b161SAndreas Gruenbacher if (!mdev) 17334a76b161SAndreas Gruenbacher return -EIO; 1734b411b363SPhilipp Reisner 1735b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1736b411b363SPhilipp Reisner 173787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1738bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 173987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1740c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 174182bc0194SAndreas Gruenbacher return -EIO; 1742b411b363SPhilipp Reisner 174324c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1744b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1745b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1746e2857216SAndreas Gruenbacher err = recv_dless_read(mdev, req, sector, pi->size); 174782bc0194SAndreas Gruenbacher if (!err) 17488554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1749b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1750b411b363SPhilipp Reisner * I don't think we may complete this just yet 1751b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1752b411b363SPhilipp Reisner 175382bc0194SAndreas Gruenbacher return err; 1754b411b363SPhilipp Reisner } 1755b411b363SPhilipp Reisner 17564a76b161SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1757b411b363SPhilipp Reisner { 17584a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1759b411b363SPhilipp Reisner sector_t sector; 176082bc0194SAndreas Gruenbacher int err; 1761e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17624a76b161SAndreas Gruenbacher 17634a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 17644a76b161SAndreas Gruenbacher if (!mdev) 17654a76b161SAndreas Gruenbacher return -EIO; 1766b411b363SPhilipp Reisner 1767b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1768b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1769b411b363SPhilipp Reisner 1770b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1771b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1772b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1773fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1774e2857216SAndreas Gruenbacher err = recv_resync_read(mdev, sector, pi->size); 1775b411b363SPhilipp Reisner } else { 1776b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1777b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1778b411b363SPhilipp Reisner 1779e2857216SAndreas Gruenbacher err = drbd_drain_block(mdev, pi->size); 1780b411b363SPhilipp Reisner 1781e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 1782b411b363SPhilipp Reisner } 1783b411b363SPhilipp Reisner 1784e2857216SAndreas Gruenbacher atomic_add(pi->size >> 9, &mdev->rs_sect_in); 1785778f271dSPhilipp Reisner 178682bc0194SAndreas Gruenbacher return err; 1787b411b363SPhilipp Reisner } 1788b411b363SPhilipp Reisner 17897be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 17907be8da07SAndreas Gruenbacher sector_t sector, int size) 1791b411b363SPhilipp Reisner { 17927be8da07SAndreas Gruenbacher struct drbd_interval *i; 17937be8da07SAndreas Gruenbacher struct drbd_request *req; 1794b411b363SPhilipp Reisner 17957be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 17967be8da07SAndreas Gruenbacher if (!i->local) 17977be8da07SAndreas Gruenbacher continue; 17987be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 17997be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 18007be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 18017be8da07SAndreas Gruenbacher continue; 18022312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 18032312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 1804d4dabbe2SLars Ellenberg __req_mod(req, CONFLICT_RESOLVED, NULL); 18057be8da07SAndreas Gruenbacher } 18067be8da07SAndreas Gruenbacher } 18077be8da07SAndreas Gruenbacher 1808a990be46SAndreas Gruenbacher /* 1809a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1810b411b363SPhilipp Reisner */ 181199920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1812b411b363SPhilipp Reisner { 18138050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 18148050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 181500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1816db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 181799920dc5SAndreas Gruenbacher int err = 0, pcmd; 1818b411b363SPhilipp Reisner 1819303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1820db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1821b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1822b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1823db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1824b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 182599920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, pcmd, peer_req); 1826b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1827db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1828b411b363SPhilipp Reisner } else { 182999920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1830b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1831b411b363SPhilipp Reisner * maybe assert this? */ 1832b411b363SPhilipp Reisner } 1833b411b363SPhilipp Reisner dec_unacked(mdev); 1834b411b363SPhilipp Reisner } 1835b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1836b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1837302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 183887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1839db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1840db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 18417be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 18427be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 184387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1844bb3bfe96SAndreas Gruenbacher } else 1845db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1846b411b363SPhilipp Reisner 18471e9dd291SPhilipp Reisner drbd_may_finish_epoch(mdev->tconn, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1848b411b363SPhilipp Reisner 184999920dc5SAndreas Gruenbacher return err; 1850b411b363SPhilipp Reisner } 1851b411b363SPhilipp Reisner 18527be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1853b411b363SPhilipp Reisner { 18547be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 18558050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 18568050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 185799920dc5SAndreas Gruenbacher int err; 1858b411b363SPhilipp Reisner 185999920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, ack, peer_req); 1860b411b363SPhilipp Reisner dec_unacked(mdev); 1861b411b363SPhilipp Reisner 186299920dc5SAndreas Gruenbacher return err; 1863b411b363SPhilipp Reisner } 1864b411b363SPhilipp Reisner 1865d4dabbe2SLars Ellenberg static int e_send_superseded(struct drbd_work *w, int unused) 1866b6a370baSPhilipp Reisner { 1867d4dabbe2SLars Ellenberg return e_send_ack(w, P_SUPERSEDED); 18687be8da07SAndreas Gruenbacher } 1869b6a370baSPhilipp Reisner 187099920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 18717be8da07SAndreas Gruenbacher { 18727be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 18737be8da07SAndreas Gruenbacher 18747be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 1875d4dabbe2SLars Ellenberg P_RETRY_WRITE : P_SUPERSEDED); 18767be8da07SAndreas Gruenbacher } 18777be8da07SAndreas Gruenbacher 18783e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 18793e394da1SAndreas Gruenbacher { 18803e394da1SAndreas Gruenbacher /* 18813e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 18823e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 18833e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 18843e394da1SAndreas Gruenbacher */ 18853e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 18863e394da1SAndreas Gruenbacher } 18873e394da1SAndreas Gruenbacher 18883e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 18893e394da1SAndreas Gruenbacher { 18903e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 18913e394da1SAndreas Gruenbacher } 18923e394da1SAndreas Gruenbacher 189343ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 18943e394da1SAndreas Gruenbacher { 18953c13b680SLars Ellenberg unsigned int newest_peer_seq; 18963e394da1SAndreas Gruenbacher 1897b874d231SPhilipp Reisner if (test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags)) { 18983e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 18993c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 19003c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 19013e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 19023c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 19033c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 19043e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 19053e394da1SAndreas Gruenbacher } 19067be8da07SAndreas Gruenbacher } 19073e394da1SAndreas Gruenbacher 1908d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 1909d93f6302SLars Ellenberg { 1910d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 1911d93f6302SLars Ellenberg } 1912d93f6302SLars Ellenberg 1913d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 19143ea35df8SPhilipp Reisner static bool overlapping_resync_write(struct drbd_conf *mdev, struct drbd_peer_request *peer_req) 1915d93f6302SLars Ellenberg { 1916d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 1917b6a370baSPhilipp Reisner bool rv = 0; 1918b6a370baSPhilipp Reisner 1919d93f6302SLars Ellenberg spin_lock_irq(&mdev->tconn->req_lock); 1920d93f6302SLars Ellenberg list_for_each_entry(rs_req, &mdev->sync_ee, w.list) { 1921d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 1922d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 1923b6a370baSPhilipp Reisner rv = 1; 1924b6a370baSPhilipp Reisner break; 1925b6a370baSPhilipp Reisner } 1926b6a370baSPhilipp Reisner } 1927d93f6302SLars Ellenberg spin_unlock_irq(&mdev->tconn->req_lock); 1928b6a370baSPhilipp Reisner 1929b6a370baSPhilipp Reisner return rv; 1930b6a370baSPhilipp Reisner } 1931b6a370baSPhilipp Reisner 1932b411b363SPhilipp Reisner /* Called from receive_Data. 1933b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1934b411b363SPhilipp Reisner * 1935b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1936b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1937b411b363SPhilipp Reisner * been sent. 1938b411b363SPhilipp Reisner * 1939b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1940b411b363SPhilipp Reisner * 1941b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1942b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1943b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1944b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1945b411b363SPhilipp Reisner * 1946b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1947b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1948b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1949b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1950b411b363SPhilipp Reisner * 1951b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1952b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 19537be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1954b411b363SPhilipp Reisner { 1955b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1956b411b363SPhilipp Reisner long timeout; 1957b874d231SPhilipp Reisner int ret = 0, tp; 19587be8da07SAndreas Gruenbacher 1959b874d231SPhilipp Reisner if (!test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags)) 19607be8da07SAndreas Gruenbacher return 0; 19617be8da07SAndreas Gruenbacher 1962b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1963b411b363SPhilipp Reisner for (;;) { 19647be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 19657be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 1966b411b363SPhilipp Reisner break; 19677be8da07SAndreas Gruenbacher } 1968b874d231SPhilipp Reisner 1969b411b363SPhilipp Reisner if (signal_pending(current)) { 1970b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1971b411b363SPhilipp Reisner break; 1972b411b363SPhilipp Reisner } 1973b874d231SPhilipp Reisner 1974b874d231SPhilipp Reisner rcu_read_lock(); 1975b874d231SPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 1976b874d231SPhilipp Reisner rcu_read_unlock(); 1977b874d231SPhilipp Reisner 1978b874d231SPhilipp Reisner if (!tp) 1979b874d231SPhilipp Reisner break; 1980b874d231SPhilipp Reisner 1981b874d231SPhilipp Reisner /* Only need to wait if two_primaries is enabled */ 19827be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1983b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 198444ed167dSPhilipp Reisner rcu_read_lock(); 198544ed167dSPhilipp Reisner timeout = rcu_dereference(mdev->tconn->net_conf)->ping_timeo*HZ/10; 198644ed167dSPhilipp Reisner rcu_read_unlock(); 198771b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1988b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 19897be8da07SAndreas Gruenbacher if (!timeout) { 1990b411b363SPhilipp Reisner ret = -ETIMEDOUT; 199171b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1992b411b363SPhilipp Reisner break; 1993b411b363SPhilipp Reisner } 1994b411b363SPhilipp Reisner } 1995b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 19967be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 1997b411b363SPhilipp Reisner return ret; 1998b411b363SPhilipp Reisner } 1999b411b363SPhilipp Reisner 2000688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2001688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2002688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 2003688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 200476d2e7ecSPhilipp Reisner { 200576d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 200676d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 2007688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 200876d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 200976d2e7ecSPhilipp Reisner } 201076d2e7ecSPhilipp Reisner 20117be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 20127be8da07SAndreas Gruenbacher unsigned int size) 2013b411b363SPhilipp Reisner { 20147be8da07SAndreas Gruenbacher struct drbd_interval *i; 20157be8da07SAndreas Gruenbacher 20167be8da07SAndreas Gruenbacher repeat: 20177be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 20187be8da07SAndreas Gruenbacher struct drbd_request *req; 20197be8da07SAndreas Gruenbacher struct bio_and_error m; 20207be8da07SAndreas Gruenbacher 20217be8da07SAndreas Gruenbacher if (!i->local) 20227be8da07SAndreas Gruenbacher continue; 20237be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 20247be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 20257be8da07SAndreas Gruenbacher continue; 20267be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 20277be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 20287be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 20297be8da07SAndreas Gruenbacher if (m.bio) 20307be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 20317be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 20327be8da07SAndreas Gruenbacher goto repeat; 20337be8da07SAndreas Gruenbacher } 20347be8da07SAndreas Gruenbacher } 20357be8da07SAndreas Gruenbacher 20367be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 20377be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 20387be8da07SAndreas Gruenbacher { 20397be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 2040427c0434SLars Ellenberg bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &tconn->flags); 20417be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 20427be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 20437be8da07SAndreas Gruenbacher struct drbd_interval *i; 20447be8da07SAndreas Gruenbacher bool equal; 20457be8da07SAndreas Gruenbacher int err; 20467be8da07SAndreas Gruenbacher 20477be8da07SAndreas Gruenbacher /* 20487be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 20497be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 20507be8da07SAndreas Gruenbacher */ 20517be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 20527be8da07SAndreas Gruenbacher 20537be8da07SAndreas Gruenbacher repeat: 20547be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 20557be8da07SAndreas Gruenbacher if (i == &peer_req->i) 20567be8da07SAndreas Gruenbacher continue; 20577be8da07SAndreas Gruenbacher 20587be8da07SAndreas Gruenbacher if (!i->local) { 20597be8da07SAndreas Gruenbacher /* 20607be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 20617be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 20627be8da07SAndreas Gruenbacher * earlier peer request to complete. 20637be8da07SAndreas Gruenbacher */ 20647be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 20657be8da07SAndreas Gruenbacher if (err) 20667be8da07SAndreas Gruenbacher goto out; 20677be8da07SAndreas Gruenbacher goto repeat; 20687be8da07SAndreas Gruenbacher } 20697be8da07SAndreas Gruenbacher 20707be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 20717be8da07SAndreas Gruenbacher if (resolve_conflicts) { 20727be8da07SAndreas Gruenbacher /* 20737be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 2074d4dabbe2SLars Ellenberg * overlapping request, it can be considered overwritten 2075d4dabbe2SLars Ellenberg * and thus superseded; otherwise, it will be retried 2076d4dabbe2SLars Ellenberg * once all overlapping requests have completed. 20777be8da07SAndreas Gruenbacher */ 2078d4dabbe2SLars Ellenberg bool superseded = i->sector <= sector && i->sector + 20797be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 20807be8da07SAndreas Gruenbacher 20817be8da07SAndreas Gruenbacher if (!equal) 20827be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 20837be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 20847be8da07SAndreas Gruenbacher "assuming %s came first\n", 20857be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 20867be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 2087d4dabbe2SLars Ellenberg superseded ? "local" : "remote"); 20887be8da07SAndreas Gruenbacher 20897be8da07SAndreas Gruenbacher inc_unacked(mdev); 2090d4dabbe2SLars Ellenberg peer_req->w.cb = superseded ? e_send_superseded : 20917be8da07SAndreas Gruenbacher e_send_retry_write; 20927be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 20937be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 20947be8da07SAndreas Gruenbacher 20957be8da07SAndreas Gruenbacher err = -ENOENT; 20967be8da07SAndreas Gruenbacher goto out; 20977be8da07SAndreas Gruenbacher } else { 20987be8da07SAndreas Gruenbacher struct drbd_request *req = 20997be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 21007be8da07SAndreas Gruenbacher 21017be8da07SAndreas Gruenbacher if (!equal) 21027be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 21037be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 21047be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 21057be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 21067be8da07SAndreas Gruenbacher 21077be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 21087be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 21097be8da07SAndreas Gruenbacher /* 21107be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 2111d4dabbe2SLars Ellenberg * decide if this request has been superseded 2112d4dabbe2SLars Ellenberg * or needs to be retried. 2113d4dabbe2SLars Ellenberg * Requests that have been superseded will 21147be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 21157be8da07SAndreas Gruenbacher * 21167be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 21177be8da07SAndreas Gruenbacher * request to finish locally before submitting 21187be8da07SAndreas Gruenbacher * the conflicting peer request. 21197be8da07SAndreas Gruenbacher */ 21207be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 21217be8da07SAndreas Gruenbacher if (err) { 21227be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 21237be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 21247be8da07SAndreas Gruenbacher CS_HARD); 21257be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 21267be8da07SAndreas Gruenbacher goto out; 21277be8da07SAndreas Gruenbacher } 21287be8da07SAndreas Gruenbacher goto repeat; 21297be8da07SAndreas Gruenbacher } 21307be8da07SAndreas Gruenbacher /* 21317be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 21327be8da07SAndreas Gruenbacher * the new peer request has completed. 21337be8da07SAndreas Gruenbacher */ 21347be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 21357be8da07SAndreas Gruenbacher } 21367be8da07SAndreas Gruenbacher } 21377be8da07SAndreas Gruenbacher err = 0; 21387be8da07SAndreas Gruenbacher 21397be8da07SAndreas Gruenbacher out: 21407be8da07SAndreas Gruenbacher if (err) 21417be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 21427be8da07SAndreas Gruenbacher return err; 21437be8da07SAndreas Gruenbacher } 21447be8da07SAndreas Gruenbacher 2145b411b363SPhilipp Reisner /* mirrored write */ 21464a76b161SAndreas Gruenbacher static int receive_Data(struct drbd_tconn *tconn, struct packet_info *pi) 2147b411b363SPhilipp Reisner { 21484a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2149b411b363SPhilipp Reisner sector_t sector; 2150db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2151e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 21527be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2153b411b363SPhilipp Reisner int rw = WRITE; 2154b411b363SPhilipp Reisner u32 dp_flags; 2155302bdeaeSPhilipp Reisner int err, tp; 21567be8da07SAndreas Gruenbacher 21574a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 21584a76b161SAndreas Gruenbacher if (!mdev) 21594a76b161SAndreas Gruenbacher return -EIO; 2160b411b363SPhilipp Reisner 2161b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 216282bc0194SAndreas Gruenbacher int err2; 2163b411b363SPhilipp Reisner 21647be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 2165e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 216612038a3aSPhilipp Reisner atomic_inc(&tconn->current_epoch->epoch_size); 2167e2857216SAndreas Gruenbacher err2 = drbd_drain_block(mdev, pi->size); 216882bc0194SAndreas Gruenbacher if (!err) 216982bc0194SAndreas Gruenbacher err = err2; 217082bc0194SAndreas Gruenbacher return err; 2171b411b363SPhilipp Reisner } 2172b411b363SPhilipp Reisner 2173fcefa62eSAndreas Gruenbacher /* 2174fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2175fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2176fcefa62eSAndreas Gruenbacher * end of this function. 2177fcefa62eSAndreas Gruenbacher */ 2178b411b363SPhilipp Reisner 2179b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2180e2857216SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, pi->size); 2181db830c46SAndreas Gruenbacher if (!peer_req) { 2182b411b363SPhilipp Reisner put_ldev(mdev); 218382bc0194SAndreas Gruenbacher return -EIO; 2184b411b363SPhilipp Reisner } 2185b411b363SPhilipp Reisner 2186db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 2187b411b363SPhilipp Reisner 2188688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2189688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 219081a3537aSLars Ellenberg if (peer_req->pages == NULL) { 219181a3537aSLars Ellenberg D_ASSERT(peer_req->i.size == 0); 2192a73ff323SLars Ellenberg D_ASSERT(dp_flags & DP_FLUSH); 2193a73ff323SLars Ellenberg } 2194688593c5SLars Ellenberg 2195688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2196db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2197688593c5SLars Ellenberg 219812038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 219912038a3aSPhilipp Reisner peer_req->epoch = tconn->current_epoch; 2200db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2201db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 220212038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 2203b411b363SPhilipp Reisner 2204302bdeaeSPhilipp Reisner rcu_read_lock(); 2205302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 2206302bdeaeSPhilipp Reisner rcu_read_unlock(); 2207302bdeaeSPhilipp Reisner if (tp) { 2208302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 22097be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 22107be8da07SAndreas Gruenbacher if (err) 2211b411b363SPhilipp Reisner goto out_interrupted; 221287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 22137be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 22147be8da07SAndreas Gruenbacher if (err) { 221587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 22167be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2217b411b363SPhilipp Reisner put_ldev(mdev); 221882bc0194SAndreas Gruenbacher return 0; 2219b411b363SPhilipp Reisner } 2220b411b363SPhilipp Reisner goto out_interrupted; 2221b411b363SPhilipp Reisner } 2222b874d231SPhilipp Reisner } else { 2223b874d231SPhilipp Reisner update_peer_seq(mdev, peer_seq); 222487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2225b874d231SPhilipp Reisner } 2226db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 222787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2228b411b363SPhilipp Reisner 2229b6a370baSPhilipp Reisner if (mdev->state.conn == C_SYNC_TARGET) 22303ea35df8SPhilipp Reisner wait_event(mdev->ee_wait, !overlapping_resync_write(mdev, peer_req)); 2231b6a370baSPhilipp Reisner 2232303d1448SPhilipp Reisner if (mdev->tconn->agreed_pro_version < 100) { 223344ed167dSPhilipp Reisner rcu_read_lock(); 223444ed167dSPhilipp Reisner switch (rcu_dereference(mdev->tconn->net_conf)->wire_protocol) { 2235b411b363SPhilipp Reisner case DRBD_PROT_C: 2236303d1448SPhilipp Reisner dp_flags |= DP_SEND_WRITE_ACK; 2237303d1448SPhilipp Reisner break; 2238303d1448SPhilipp Reisner case DRBD_PROT_B: 2239303d1448SPhilipp Reisner dp_flags |= DP_SEND_RECEIVE_ACK; 2240303d1448SPhilipp Reisner break; 2241303d1448SPhilipp Reisner } 224244ed167dSPhilipp Reisner rcu_read_unlock(); 2243303d1448SPhilipp Reisner } 2244303d1448SPhilipp Reisner 2245303d1448SPhilipp Reisner if (dp_flags & DP_SEND_WRITE_ACK) { 2246303d1448SPhilipp Reisner peer_req->flags |= EE_SEND_WRITE_ACK; 2247b411b363SPhilipp Reisner inc_unacked(mdev); 2248b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2249b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2250303d1448SPhilipp Reisner } 2251303d1448SPhilipp Reisner 2252303d1448SPhilipp Reisner if (dp_flags & DP_SEND_RECEIVE_ACK) { 2253b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2254b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2255db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2256b411b363SPhilipp Reisner } 2257b411b363SPhilipp Reisner 22586719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2259b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2260db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2261db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2262db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 226356392d2fSLars Ellenberg drbd_al_begin_io(mdev, &peer_req->i, true); 2264b411b363SPhilipp Reisner } 2265b411b363SPhilipp Reisner 226682bc0194SAndreas Gruenbacher err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR); 226782bc0194SAndreas Gruenbacher if (!err) 226882bc0194SAndreas Gruenbacher return 0; 2269b411b363SPhilipp Reisner 227010f6d992SLars Ellenberg /* don't care for the reason here */ 227110f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 227287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2273db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2274db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 227587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2276db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2277181286adSLars Ellenberg drbd_al_complete_io(mdev, &peer_req->i); 227822cc37a9SLars Ellenberg 2279b411b363SPhilipp Reisner out_interrupted: 22801e9dd291SPhilipp Reisner drbd_may_finish_epoch(tconn, peer_req->epoch, EV_PUT + EV_CLEANUP); 2281b411b363SPhilipp Reisner put_ldev(mdev); 22823967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 228382bc0194SAndreas Gruenbacher return err; 2284b411b363SPhilipp Reisner } 2285b411b363SPhilipp Reisner 22860f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 22870f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 22880f0601f4SLars Ellenberg * 22890f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 22900f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 22910f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 22920f0601f4SLars Ellenberg * activity, it obviously is "busy". 22930f0601f4SLars Ellenberg * 22940f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 22950f0601f4SLars Ellenberg * to have a short time average so we can react faster. 22960f0601f4SLars Ellenberg */ 2297e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 22980f0601f4SLars Ellenberg { 22990f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 23000f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2301e3555d85SPhilipp Reisner struct lc_element *tmp; 23020f0601f4SLars Ellenberg int curr_events; 23030f0601f4SLars Ellenberg int throttle = 0; 2304daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2305daeda1ccSPhilipp Reisner 2306daeda1ccSPhilipp Reisner rcu_read_lock(); 2307daeda1ccSPhilipp Reisner c_min_rate = rcu_dereference(mdev->ldev->disk_conf)->c_min_rate; 2308daeda1ccSPhilipp Reisner rcu_read_unlock(); 23090f0601f4SLars Ellenberg 23100f0601f4SLars Ellenberg /* feature disabled? */ 2311daeda1ccSPhilipp Reisner if (c_min_rate == 0) 23120f0601f4SLars Ellenberg return 0; 23130f0601f4SLars Ellenberg 2314e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2315e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2316e3555d85SPhilipp Reisner if (tmp) { 2317e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2318e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2319e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2320e3555d85SPhilipp Reisner return 0; 2321e3555d85SPhilipp Reisner } 2322e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2323e3555d85SPhilipp Reisner } 2324e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2325e3555d85SPhilipp Reisner 23260f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 23270f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 23280f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2329e3555d85SPhilipp Reisner 23300f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 23310f0601f4SLars Ellenberg unsigned long rs_left; 23320f0601f4SLars Ellenberg int i; 23330f0601f4SLars Ellenberg 23340f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 23350f0601f4SLars Ellenberg 23360f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 23370f0601f4SLars Ellenberg * approx. */ 23382649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 23392649f080SLars Ellenberg 23402649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 23412649f080SLars Ellenberg rs_left = mdev->ov_left; 23422649f080SLars Ellenberg else 23430f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 23440f0601f4SLars Ellenberg 23450f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 23460f0601f4SLars Ellenberg if (!dt) 23470f0601f4SLars Ellenberg dt++; 23480f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 23490f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 23500f0601f4SLars Ellenberg 2351daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 23520f0601f4SLars Ellenberg throttle = 1; 23530f0601f4SLars Ellenberg } 23540f0601f4SLars Ellenberg return throttle; 23550f0601f4SLars Ellenberg } 23560f0601f4SLars Ellenberg 23570f0601f4SLars Ellenberg 23584a76b161SAndreas Gruenbacher static int receive_DataRequest(struct drbd_tconn *tconn, struct packet_info *pi) 2359b411b363SPhilipp Reisner { 23604a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2361b411b363SPhilipp Reisner sector_t sector; 23624a76b161SAndreas Gruenbacher sector_t capacity; 2363db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2364b411b363SPhilipp Reisner struct digest_info *di = NULL; 2365b18b37beSPhilipp Reisner int size, verb; 2366b411b363SPhilipp Reisner unsigned int fault_type; 2367e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 23684a76b161SAndreas Gruenbacher 23694a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 23704a76b161SAndreas Gruenbacher if (!mdev) 23714a76b161SAndreas Gruenbacher return -EIO; 23724a76b161SAndreas Gruenbacher capacity = drbd_get_capacity(mdev->this_bdev); 2373b411b363SPhilipp Reisner 2374b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2375b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2376b411b363SPhilipp Reisner 2377c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2378b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2379b411b363SPhilipp Reisner (unsigned long long)sector, size); 238082bc0194SAndreas Gruenbacher return -EINVAL; 2381b411b363SPhilipp Reisner } 2382b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2383b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2384b411b363SPhilipp Reisner (unsigned long long)sector, size); 238582bc0194SAndreas Gruenbacher return -EINVAL; 2386b411b363SPhilipp Reisner } 2387b411b363SPhilipp Reisner 2388b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2389b18b37beSPhilipp Reisner verb = 1; 2390e2857216SAndreas Gruenbacher switch (pi->cmd) { 2391b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2392b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2393b18b37beSPhilipp Reisner break; 2394b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2395b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2396b18b37beSPhilipp Reisner case P_OV_REQUEST: 2397b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2398b18b37beSPhilipp Reisner break; 2399b18b37beSPhilipp Reisner case P_OV_REPLY: 2400b18b37beSPhilipp Reisner verb = 0; 2401b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2402b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2403b18b37beSPhilipp Reisner break; 2404b18b37beSPhilipp Reisner default: 240549ba9b1bSAndreas Gruenbacher BUG(); 2406b18b37beSPhilipp Reisner } 2407b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2408b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2409b411b363SPhilipp Reisner "no local data.\n"); 2410b18b37beSPhilipp Reisner 2411a821cc4aSLars Ellenberg /* drain possibly payload */ 2412e2857216SAndreas Gruenbacher return drbd_drain_block(mdev, pi->size); 2413b411b363SPhilipp Reisner } 2414b411b363SPhilipp Reisner 2415b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2416b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2417b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 24180db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, p->block_id, sector, size, GFP_NOIO); 2419db830c46SAndreas Gruenbacher if (!peer_req) { 2420b411b363SPhilipp Reisner put_ldev(mdev); 242182bc0194SAndreas Gruenbacher return -ENOMEM; 2422b411b363SPhilipp Reisner } 2423b411b363SPhilipp Reisner 2424e2857216SAndreas Gruenbacher switch (pi->cmd) { 2425b411b363SPhilipp Reisner case P_DATA_REQUEST: 2426db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2427b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 242880a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 242980a40e43SLars Ellenberg goto submit; 243080a40e43SLars Ellenberg 2431b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2432db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2433b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 24345f9915bbSLars Ellenberg /* used in the sector offset progress display */ 24355f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2436b411b363SPhilipp Reisner break; 2437b411b363SPhilipp Reisner 2438b411b363SPhilipp Reisner case P_OV_REPLY: 2439b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2440b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2441e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2442b411b363SPhilipp Reisner if (!di) 2443b411b363SPhilipp Reisner goto out_free_e; 2444b411b363SPhilipp Reisner 2445e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2446b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2447b411b363SPhilipp Reisner 2448db830c46SAndreas Gruenbacher peer_req->digest = di; 2449db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2450c36c3cedSLars Ellenberg 2451e2857216SAndreas Gruenbacher if (drbd_recv_all(mdev->tconn, di->digest, pi->size)) 2452b411b363SPhilipp Reisner goto out_free_e; 2453b411b363SPhilipp Reisner 2454e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 245531890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2456db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 24575f9915bbSLars Ellenberg /* used in the sector offset progress display */ 24585f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2459e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 24602649f080SLars Ellenberg /* track progress, we may need to throttle */ 24612649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2462db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2463b411b363SPhilipp Reisner dec_rs_pending(mdev); 24640f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 24650f0601f4SLars Ellenberg * but accounting still needs to be done. */ 24660f0601f4SLars Ellenberg goto submit_for_resync; 2467b411b363SPhilipp Reisner } 2468b411b363SPhilipp Reisner break; 2469b411b363SPhilipp Reisner 2470b411b363SPhilipp Reisner case P_OV_REQUEST: 2471b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 247231890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2473de228bbaSLars Ellenberg unsigned long now = jiffies; 2474de228bbaSLars Ellenberg int i; 2475b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2476b411b363SPhilipp Reisner mdev->ov_position = sector; 247730b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 247830b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2479de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2480de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2481de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2482de228bbaSLars Ellenberg } 2483b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2484b411b363SPhilipp Reisner (unsigned long long)sector); 2485b411b363SPhilipp Reisner } 2486db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2487b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2488b411b363SPhilipp Reisner break; 2489b411b363SPhilipp Reisner 2490b411b363SPhilipp Reisner default: 249149ba9b1bSAndreas Gruenbacher BUG(); 2492b411b363SPhilipp Reisner } 2493b411b363SPhilipp Reisner 24940f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 24950f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 24960f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 24970f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 24980f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 24990f0601f4SLars Ellenberg * 25000f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 25010f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 25020f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 25030f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 25040f0601f4SLars Ellenberg * a while, anyways. 25050f0601f4SLars Ellenberg */ 2506b411b363SPhilipp Reisner 25070f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 25080f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 25090f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 25100f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 25110f0601f4SLars Ellenberg * 25120f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 25130f0601f4SLars Ellenberg * we would also throttle its application reads. 25140f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 25150f0601f4SLars Ellenberg */ 2516e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2517e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2518e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 251980a40e43SLars Ellenberg goto out_free_e; 2520b411b363SPhilipp Reisner 25210f0601f4SLars Ellenberg submit_for_resync: 25220f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 25230f0601f4SLars Ellenberg 252480a40e43SLars Ellenberg submit: 2525b411b363SPhilipp Reisner inc_unacked(mdev); 252687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2527db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 252887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2529b411b363SPhilipp Reisner 2530fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 253182bc0194SAndreas Gruenbacher return 0; 2532b411b363SPhilipp Reisner 253310f6d992SLars Ellenberg /* don't care for the reason here */ 253410f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 253587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2536db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 253787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 253822cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 253922cc37a9SLars Ellenberg 2540b411b363SPhilipp Reisner out_free_e: 2541b411b363SPhilipp Reisner put_ldev(mdev); 25423967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 254382bc0194SAndreas Gruenbacher return -EIO; 2544b411b363SPhilipp Reisner } 2545b411b363SPhilipp Reisner 2546b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2547b411b363SPhilipp Reisner { 2548b411b363SPhilipp Reisner int self, peer, rv = -100; 2549b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 255044ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2551b411b363SPhilipp Reisner 2552b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2553b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2554b411b363SPhilipp Reisner 2555b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2556b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2557b411b363SPhilipp Reisner 255844ed167dSPhilipp Reisner rcu_read_lock(); 255944ed167dSPhilipp Reisner after_sb_0p = rcu_dereference(mdev->tconn->net_conf)->after_sb_0p; 256044ed167dSPhilipp Reisner rcu_read_unlock(); 256144ed167dSPhilipp Reisner switch (after_sb_0p) { 2562b411b363SPhilipp Reisner case ASB_CONSENSUS: 2563b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2564b411b363SPhilipp Reisner case ASB_CALL_HELPER: 256544ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2566b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2567b411b363SPhilipp Reisner break; 2568b411b363SPhilipp Reisner case ASB_DISCONNECT: 2569b411b363SPhilipp Reisner break; 2570b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2571b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2572b411b363SPhilipp Reisner rv = -1; 2573b411b363SPhilipp Reisner break; 2574b411b363SPhilipp Reisner } 2575b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2576b411b363SPhilipp Reisner rv = 1; 2577b411b363SPhilipp Reisner break; 2578b411b363SPhilipp Reisner } 2579b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2580b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2581b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2582b411b363SPhilipp Reisner rv = 1; 2583b411b363SPhilipp Reisner break; 2584b411b363SPhilipp Reisner } 2585b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2586b411b363SPhilipp Reisner rv = -1; 2587b411b363SPhilipp Reisner break; 2588b411b363SPhilipp Reisner } 2589b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2590ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2591b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2592b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2593b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 2594427c0434SLars Ellenberg rv = test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags) 2595b411b363SPhilipp Reisner ? -1 : 1; 2596b411b363SPhilipp Reisner break; 2597b411b363SPhilipp Reisner } else { 2598b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2599b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2600b411b363SPhilipp Reisner } 260144ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2602b411b363SPhilipp Reisner break; 2603b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2604b411b363SPhilipp Reisner if (ch_self < ch_peer) 2605b411b363SPhilipp Reisner rv = -1; 2606b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2607b411b363SPhilipp Reisner rv = 1; 2608b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2609b411b363SPhilipp Reisner /* Well, then use something else. */ 2610427c0434SLars Ellenberg rv = test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags) 2611b411b363SPhilipp Reisner ? -1 : 1; 2612b411b363SPhilipp Reisner break; 2613b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2614b411b363SPhilipp Reisner rv = -1; 2615b411b363SPhilipp Reisner break; 2616b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2617b411b363SPhilipp Reisner rv = 1; 2618b411b363SPhilipp Reisner } 2619b411b363SPhilipp Reisner 2620b411b363SPhilipp Reisner return rv; 2621b411b363SPhilipp Reisner } 2622b411b363SPhilipp Reisner 2623b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2624b411b363SPhilipp Reisner { 26256184ea21SAndreas Gruenbacher int hg, rv = -100; 262644ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2627b411b363SPhilipp Reisner 262844ed167dSPhilipp Reisner rcu_read_lock(); 262944ed167dSPhilipp Reisner after_sb_1p = rcu_dereference(mdev->tconn->net_conf)->after_sb_1p; 263044ed167dSPhilipp Reisner rcu_read_unlock(); 263144ed167dSPhilipp Reisner switch (after_sb_1p) { 2632b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2633b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2634b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2635b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2636b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 263744ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2638b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2639b411b363SPhilipp Reisner break; 2640b411b363SPhilipp Reisner case ASB_DISCONNECT: 2641b411b363SPhilipp Reisner break; 2642b411b363SPhilipp Reisner case ASB_CONSENSUS: 2643b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2644b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2645b411b363SPhilipp Reisner rv = hg; 2646b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2647b411b363SPhilipp Reisner rv = hg; 2648b411b363SPhilipp Reisner break; 2649b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2650b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2651b411b363SPhilipp Reisner break; 2652b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2653b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2654b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2655b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2656b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2657bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2658bb437946SAndreas Gruenbacher 2659b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2660b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2661b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2662bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2663bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2664b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2665b411b363SPhilipp Reisner } else { 2666b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2667b411b363SPhilipp Reisner rv = hg; 2668b411b363SPhilipp Reisner } 2669b411b363SPhilipp Reisner } else 2670b411b363SPhilipp Reisner rv = hg; 2671b411b363SPhilipp Reisner } 2672b411b363SPhilipp Reisner 2673b411b363SPhilipp Reisner return rv; 2674b411b363SPhilipp Reisner } 2675b411b363SPhilipp Reisner 2676b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2677b411b363SPhilipp Reisner { 26786184ea21SAndreas Gruenbacher int hg, rv = -100; 267944ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2680b411b363SPhilipp Reisner 268144ed167dSPhilipp Reisner rcu_read_lock(); 268244ed167dSPhilipp Reisner after_sb_2p = rcu_dereference(mdev->tconn->net_conf)->after_sb_2p; 268344ed167dSPhilipp Reisner rcu_read_unlock(); 268444ed167dSPhilipp Reisner switch (after_sb_2p) { 2685b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2686b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2687b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2688b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2689b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2690b411b363SPhilipp Reisner case ASB_CONSENSUS: 2691b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 269244ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2693b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2694b411b363SPhilipp Reisner break; 2695b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2696b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2697b411b363SPhilipp Reisner break; 2698b411b363SPhilipp Reisner case ASB_DISCONNECT: 2699b411b363SPhilipp Reisner break; 2700b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2701b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2702b411b363SPhilipp Reisner if (hg == -1) { 2703bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2704bb437946SAndreas Gruenbacher 2705b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2706b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2707b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2708bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2709bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2710b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2711b411b363SPhilipp Reisner } else { 2712b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2713b411b363SPhilipp Reisner rv = hg; 2714b411b363SPhilipp Reisner } 2715b411b363SPhilipp Reisner } else 2716b411b363SPhilipp Reisner rv = hg; 2717b411b363SPhilipp Reisner } 2718b411b363SPhilipp Reisner 2719b411b363SPhilipp Reisner return rv; 2720b411b363SPhilipp Reisner } 2721b411b363SPhilipp Reisner 2722b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2723b411b363SPhilipp Reisner u64 bits, u64 flags) 2724b411b363SPhilipp Reisner { 2725b411b363SPhilipp Reisner if (!uuid) { 2726b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2727b411b363SPhilipp Reisner return; 2728b411b363SPhilipp Reisner } 2729b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2730b411b363SPhilipp Reisner text, 2731b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2732b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2733b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2734b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2735b411b363SPhilipp Reisner (unsigned long long)bits, 2736b411b363SPhilipp Reisner (unsigned long long)flags); 2737b411b363SPhilipp Reisner } 2738b411b363SPhilipp Reisner 2739b411b363SPhilipp Reisner /* 2740b411b363SPhilipp Reisner 100 after split brain try auto recover 2741b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2742b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2743b411b363SPhilipp Reisner 0 no Sync 2744b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2745b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2746b411b363SPhilipp Reisner -100 after split brain, disconnect 2747b411b363SPhilipp Reisner -1000 unrelated data 27484a23f264SPhilipp Reisner -1091 requires proto 91 27494a23f264SPhilipp Reisner -1096 requires proto 96 2750b411b363SPhilipp Reisner */ 2751b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2752b411b363SPhilipp Reisner { 2753b411b363SPhilipp Reisner u64 self, peer; 2754b411b363SPhilipp Reisner int i, j; 2755b411b363SPhilipp Reisner 2756b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2757b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2758b411b363SPhilipp Reisner 2759b411b363SPhilipp Reisner *rule_nr = 10; 2760b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2761b411b363SPhilipp Reisner return 0; 2762b411b363SPhilipp Reisner 2763b411b363SPhilipp Reisner *rule_nr = 20; 2764b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2765b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2766b411b363SPhilipp Reisner return -2; 2767b411b363SPhilipp Reisner 2768b411b363SPhilipp Reisner *rule_nr = 30; 2769b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2770b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2771b411b363SPhilipp Reisner return 2; 2772b411b363SPhilipp Reisner 2773b411b363SPhilipp Reisner if (self == peer) { 2774b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2775b411b363SPhilipp Reisner 2776b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2777b411b363SPhilipp Reisner 277831890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27794a23f264SPhilipp Reisner return -1091; 2780b411b363SPhilipp Reisner 2781b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2782b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2783b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 27849f2247bbSPhilipp Reisner drbd_uuid_move_history(mdev); 27859f2247bbSPhilipp Reisner mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[UI_BITMAP]; 27869f2247bbSPhilipp Reisner mdev->ldev->md.uuid[UI_BITMAP] = 0; 2787b411b363SPhilipp Reisner 2788b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2789b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2790b411b363SPhilipp Reisner *rule_nr = 34; 2791b411b363SPhilipp Reisner } else { 2792b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2793b411b363SPhilipp Reisner *rule_nr = 36; 2794b411b363SPhilipp Reisner } 2795b411b363SPhilipp Reisner 2796b411b363SPhilipp Reisner return 1; 2797b411b363SPhilipp Reisner } 2798b411b363SPhilipp Reisner 2799b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2800b411b363SPhilipp Reisner 280131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28024a23f264SPhilipp Reisner return -1091; 2803b411b363SPhilipp Reisner 2804b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2805b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2806b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2807b411b363SPhilipp Reisner 2808b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2809b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2810b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2811b411b363SPhilipp Reisner 2812b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2813b411b363SPhilipp Reisner *rule_nr = 35; 2814b411b363SPhilipp Reisner } else { 2815b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2816b411b363SPhilipp Reisner *rule_nr = 37; 2817b411b363SPhilipp Reisner } 2818b411b363SPhilipp Reisner 2819b411b363SPhilipp Reisner return -1; 2820b411b363SPhilipp Reisner } 2821b411b363SPhilipp Reisner 2822b411b363SPhilipp Reisner /* Common power [off|failure] */ 2823b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2824b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2825b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2826b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2827b411b363SPhilipp Reisner *rule_nr = 40; 2828b411b363SPhilipp Reisner 2829b411b363SPhilipp Reisner switch (rct) { 2830b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2831b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2832b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2833b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 2834427c0434SLars Ellenberg dc = test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags); 2835b411b363SPhilipp Reisner return dc ? -1 : 1; 2836b411b363SPhilipp Reisner } 2837b411b363SPhilipp Reisner } 2838b411b363SPhilipp Reisner 2839b411b363SPhilipp Reisner *rule_nr = 50; 2840b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2841b411b363SPhilipp Reisner if (self == peer) 2842b411b363SPhilipp Reisner return -1; 2843b411b363SPhilipp Reisner 2844b411b363SPhilipp Reisner *rule_nr = 51; 2845b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2846b411b363SPhilipp Reisner if (self == peer) { 284731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 28484a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 28494a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 28504a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2851b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2852b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2853b411b363SPhilipp Reisner 285431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28554a23f264SPhilipp Reisner return -1091; 2856b411b363SPhilipp Reisner 2857b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2858b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 28594a23f264SPhilipp Reisner 286092b4ca29SLars Ellenberg dev_info(DEV, "Lost last syncUUID packet, corrected:\n"); 28614a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 28624a23f264SPhilipp Reisner 2863b411b363SPhilipp Reisner return -1; 2864b411b363SPhilipp Reisner } 2865b411b363SPhilipp Reisner } 2866b411b363SPhilipp Reisner 2867b411b363SPhilipp Reisner *rule_nr = 60; 2868b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2869b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2870b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2871b411b363SPhilipp Reisner if (self == peer) 2872b411b363SPhilipp Reisner return -2; 2873b411b363SPhilipp Reisner } 2874b411b363SPhilipp Reisner 2875b411b363SPhilipp Reisner *rule_nr = 70; 2876b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2877b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2878b411b363SPhilipp Reisner if (self == peer) 2879b411b363SPhilipp Reisner return 1; 2880b411b363SPhilipp Reisner 2881b411b363SPhilipp Reisner *rule_nr = 71; 2882b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2883b411b363SPhilipp Reisner if (self == peer) { 288431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 28854a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 28864a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 28874a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2888b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2889b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2890b411b363SPhilipp Reisner 289131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28924a23f264SPhilipp Reisner return -1091; 2893b411b363SPhilipp Reisner 28949f2247bbSPhilipp Reisner __drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 28959f2247bbSPhilipp Reisner __drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2896b411b363SPhilipp Reisner 28974a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2898b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2899b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2900b411b363SPhilipp Reisner 2901b411b363SPhilipp Reisner return 1; 2902b411b363SPhilipp Reisner } 2903b411b363SPhilipp Reisner } 2904b411b363SPhilipp Reisner 2905b411b363SPhilipp Reisner 2906b411b363SPhilipp Reisner *rule_nr = 80; 2907d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2908b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2909b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2910b411b363SPhilipp Reisner if (self == peer) 2911b411b363SPhilipp Reisner return 2; 2912b411b363SPhilipp Reisner } 2913b411b363SPhilipp Reisner 2914b411b363SPhilipp Reisner *rule_nr = 90; 2915b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2916b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2917b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2918b411b363SPhilipp Reisner return 100; 2919b411b363SPhilipp Reisner 2920b411b363SPhilipp Reisner *rule_nr = 100; 2921b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2922b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2923b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2924b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2925b411b363SPhilipp Reisner if (self == peer) 2926b411b363SPhilipp Reisner return -100; 2927b411b363SPhilipp Reisner } 2928b411b363SPhilipp Reisner } 2929b411b363SPhilipp Reisner 2930b411b363SPhilipp Reisner return -1000; 2931b411b363SPhilipp Reisner } 2932b411b363SPhilipp Reisner 2933b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2934b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2935b411b363SPhilipp Reisner */ 2936b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2937b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2938b411b363SPhilipp Reisner { 2939b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2940b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 294144ed167dSPhilipp Reisner struct net_conf *nc; 29426dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 2943b411b363SPhilipp Reisner 2944b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2945b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2946b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2947b411b363SPhilipp Reisner 2948b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 29499f2247bbSPhilipp Reisner 29509f2247bbSPhilipp Reisner spin_lock_irq(&mdev->ldev->md.uuid_lock); 2951b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2952b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2953b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2954b411b363SPhilipp Reisner 2955b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 29569f2247bbSPhilipp Reisner spin_unlock_irq(&mdev->ldev->md.uuid_lock); 2957b411b363SPhilipp Reisner 2958b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2959b411b363SPhilipp Reisner 2960b411b363SPhilipp Reisner if (hg == -1000) { 2961b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2962b411b363SPhilipp Reisner return C_MASK; 2963b411b363SPhilipp Reisner } 29644a23f264SPhilipp Reisner if (hg < -1000) { 29654a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2966b411b363SPhilipp Reisner return C_MASK; 2967b411b363SPhilipp Reisner } 2968b411b363SPhilipp Reisner 2969b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2970b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2971b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2972b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2973b411b363SPhilipp Reisner if (f) 2974b411b363SPhilipp Reisner hg = hg*2; 2975b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2976b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2977b411b363SPhilipp Reisner } 2978b411b363SPhilipp Reisner 29793a11a487SAdam Gandelman if (abs(hg) == 100) 29803a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 29813a11a487SAdam Gandelman 298244ed167dSPhilipp Reisner rcu_read_lock(); 298344ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 298444ed167dSPhilipp Reisner 298544ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 2986b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2987b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2988b411b363SPhilipp Reisner int forced = (hg == -100); 2989b411b363SPhilipp Reisner 2990b411b363SPhilipp Reisner switch (pcount) { 2991b411b363SPhilipp Reisner case 0: 2992b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2993b411b363SPhilipp Reisner break; 2994b411b363SPhilipp Reisner case 1: 2995b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2996b411b363SPhilipp Reisner break; 2997b411b363SPhilipp Reisner case 2: 2998b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2999b411b363SPhilipp Reisner break; 3000b411b363SPhilipp Reisner } 3001b411b363SPhilipp Reisner if (abs(hg) < 100) { 3002b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 3003b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3004b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3005b411b363SPhilipp Reisner if (forced) { 3006b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 3007b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3008b411b363SPhilipp Reisner hg = hg*2; 3009b411b363SPhilipp Reisner } 3010b411b363SPhilipp Reisner } 3011b411b363SPhilipp Reisner } 3012b411b363SPhilipp Reisner 3013b411b363SPhilipp Reisner if (hg == -100) { 301408b165baSPhilipp Reisner if (test_bit(DISCARD_MY_DATA, &mdev->flags) && !(mdev->p_uuid[UI_FLAGS]&1)) 3015b411b363SPhilipp Reisner hg = -1; 301608b165baSPhilipp Reisner if (!test_bit(DISCARD_MY_DATA, &mdev->flags) && (mdev->p_uuid[UI_FLAGS]&1)) 3017b411b363SPhilipp Reisner hg = 1; 3018b411b363SPhilipp Reisner 3019b411b363SPhilipp Reisner if (abs(hg) < 100) 3020b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 3021b411b363SPhilipp Reisner "Sync from %s node\n", 3022b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3023b411b363SPhilipp Reisner } 302444ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 30256dff2902SAndreas Gruenbacher tentative = nc->tentative; 302644ed167dSPhilipp Reisner rcu_read_unlock(); 3027b411b363SPhilipp Reisner 3028b411b363SPhilipp Reisner if (hg == -100) { 3029580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3030580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3031580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3032580b9767SLars Ellenberg * to that disk, in a way... */ 30333a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 3034b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 3035b411b363SPhilipp Reisner return C_MASK; 3036b411b363SPhilipp Reisner } 3037b411b363SPhilipp Reisner 3038b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3039b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 3040b411b363SPhilipp Reisner return C_MASK; 3041b411b363SPhilipp Reisner } 3042b411b363SPhilipp Reisner 3043b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3044b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 304544ed167dSPhilipp Reisner switch (rr_conflict) { 3046b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3047b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 3048b411b363SPhilipp Reisner /* fall through */ 3049b411b363SPhilipp Reisner case ASB_DISCONNECT: 3050b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 3051b411b363SPhilipp Reisner return C_MASK; 3052b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3053b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 3054b411b363SPhilipp Reisner "assumption\n"); 3055b411b363SPhilipp Reisner } 3056b411b363SPhilipp Reisner } 3057b411b363SPhilipp Reisner 30586dff2902SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 3059cf14c2e9SPhilipp Reisner if (hg == 0) 3060cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 3061cf14c2e9SPhilipp Reisner else 3062cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 3063cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3064cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3065cf14c2e9SPhilipp Reisner return C_MASK; 3066cf14c2e9SPhilipp Reisner } 3067cf14c2e9SPhilipp Reisner 3068b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3069b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 307020ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 307120ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3072b411b363SPhilipp Reisner return C_MASK; 3073b411b363SPhilipp Reisner } 3074b411b363SPhilipp Reisner 3075b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3076b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3077b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3078b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3079b411b363SPhilipp Reisner } else { 3080b411b363SPhilipp Reisner rv = C_CONNECTED; 3081b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 3082b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 3083b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 3084b411b363SPhilipp Reisner } 3085b411b363SPhilipp Reisner } 3086b411b363SPhilipp Reisner 3087b411b363SPhilipp Reisner return rv; 3088b411b363SPhilipp Reisner } 3089b411b363SPhilipp Reisner 3090f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3091b411b363SPhilipp Reisner { 3092b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3093f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3094f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3095b411b363SPhilipp Reisner 3096b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3097f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3098f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3099b411b363SPhilipp Reisner 3100b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3101f179d76dSPhilipp Reisner return peer; 3102b411b363SPhilipp Reisner } 3103b411b363SPhilipp Reisner 3104e2857216SAndreas Gruenbacher static int receive_protocol(struct drbd_tconn *tconn, struct packet_info *pi) 3105b411b363SPhilipp Reisner { 3106e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3107036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3108036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3109036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3110036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 3111accdbcc5SAndreas Gruenbacher struct crypto_hash *peer_integrity_tfm = NULL; 31127aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3113b411b363SPhilipp Reisner 3114b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3115b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3116b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3117b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3118b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3119cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 31206139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3121cf14c2e9SPhilipp Reisner 312286db0618SAndreas Gruenbacher if (tconn->agreed_pro_version >= 87) { 312386db0618SAndreas Gruenbacher int err; 312486db0618SAndreas Gruenbacher 312588104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 312686db0618SAndreas Gruenbacher return -EIO; 312788104ca4SAndreas Gruenbacher err = drbd_recv_all(tconn, integrity_alg, pi->size); 312886db0618SAndreas Gruenbacher if (err) 312986db0618SAndreas Gruenbacher return err; 313088104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3131036b17eaSPhilipp Reisner } 313286db0618SAndreas Gruenbacher 31337d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 31347204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 3135cf14c2e9SPhilipp Reisner 3136cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 31377204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 3138b411b363SPhilipp Reisner 313944ed167dSPhilipp Reisner rcu_read_lock(); 314044ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 314144ed167dSPhilipp Reisner 3142036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 3143d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "protocol"); 314444ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3145b411b363SPhilipp Reisner } 3146b411b363SPhilipp Reisner 3147f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 3148d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-0pri"); 314944ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3150b411b363SPhilipp Reisner } 3151b411b363SPhilipp Reisner 3152f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 3153d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-1pri"); 315444ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3155b411b363SPhilipp Reisner } 3156b411b363SPhilipp Reisner 3157f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 3158d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-2pri"); 315944ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3160b411b363SPhilipp Reisner } 3161b411b363SPhilipp Reisner 31626139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 3163d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "discard-my-data"); 316444ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3165b411b363SPhilipp Reisner } 3166b411b363SPhilipp Reisner 316744ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 3168d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "allow-two-primaries"); 316944ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3170b411b363SPhilipp Reisner } 3171b411b363SPhilipp Reisner 3172036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 3173d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "data-integrity-alg"); 3174036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3175036b17eaSPhilipp Reisner } 3176036b17eaSPhilipp Reisner 317786db0618SAndreas Gruenbacher rcu_read_unlock(); 3178fbc12f45SAndreas Gruenbacher } 31797d4c782cSAndreas Gruenbacher 31807d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 31817d4c782cSAndreas Gruenbacher int hash_size; 31827d4c782cSAndreas Gruenbacher 31837d4c782cSAndreas Gruenbacher /* 31847d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 31857d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 31867d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 31877d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 31887d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 31897d4c782cSAndreas Gruenbacher * change. 31907d4c782cSAndreas Gruenbacher */ 31917d4c782cSAndreas Gruenbacher 31927d4c782cSAndreas Gruenbacher peer_integrity_tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 31937d4c782cSAndreas Gruenbacher if (!peer_integrity_tfm) { 31947d4c782cSAndreas Gruenbacher conn_err(tconn, "peer data-integrity-alg %s not supported\n", 31957d4c782cSAndreas Gruenbacher integrity_alg); 3196b411b363SPhilipp Reisner goto disconnect; 3197b411b363SPhilipp Reisner } 3198b411b363SPhilipp Reisner 31997d4c782cSAndreas Gruenbacher hash_size = crypto_hash_digestsize(peer_integrity_tfm); 32007d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 32017d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 32027d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 32037d4c782cSAndreas Gruenbacher conn_err(tconn, "Allocation of buffers for data integrity checking failed\n"); 32047d4c782cSAndreas Gruenbacher goto disconnect; 32057d4c782cSAndreas Gruenbacher } 32067d4c782cSAndreas Gruenbacher } 32077d4c782cSAndreas Gruenbacher 32087d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 32097d4c782cSAndreas Gruenbacher if (!new_net_conf) { 32107d4c782cSAndreas Gruenbacher conn_err(tconn, "Allocation of new net_conf failed\n"); 3211b411b363SPhilipp Reisner goto disconnect; 3212b411b363SPhilipp Reisner } 3213b411b363SPhilipp Reisner 32147d4c782cSAndreas Gruenbacher mutex_lock(&tconn->data.mutex); 32157d4c782cSAndreas Gruenbacher mutex_lock(&tconn->conf_update); 32167d4c782cSAndreas Gruenbacher old_net_conf = tconn->net_conf; 32177d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 3218b411b363SPhilipp Reisner 32197d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 32207d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 32217d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 32227d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 32237d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 3224b411b363SPhilipp Reisner 32257d4c782cSAndreas Gruenbacher rcu_assign_pointer(tconn->net_conf, new_net_conf); 32267d4c782cSAndreas Gruenbacher mutex_unlock(&tconn->conf_update); 32277d4c782cSAndreas Gruenbacher mutex_unlock(&tconn->data.mutex); 3228b411b363SPhilipp Reisner 32297d4c782cSAndreas Gruenbacher crypto_free_hash(tconn->peer_integrity_tfm); 32307d4c782cSAndreas Gruenbacher kfree(tconn->int_dig_in); 32317d4c782cSAndreas Gruenbacher kfree(tconn->int_dig_vv); 32327d4c782cSAndreas Gruenbacher tconn->peer_integrity_tfm = peer_integrity_tfm; 32337d4c782cSAndreas Gruenbacher tconn->int_dig_in = int_dig_in; 32347d4c782cSAndreas Gruenbacher tconn->int_dig_vv = int_dig_vv; 3235b411b363SPhilipp Reisner 32367d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 32377d4c782cSAndreas Gruenbacher conn_info(tconn, "peer data-integrity-alg: %s\n", 32387d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 3239b411b363SPhilipp Reisner 32407d4c782cSAndreas Gruenbacher synchronize_rcu(); 32417d4c782cSAndreas Gruenbacher kfree(old_net_conf); 324282bc0194SAndreas Gruenbacher return 0; 3243b411b363SPhilipp Reisner 324444ed167dSPhilipp Reisner disconnect_rcu_unlock: 324544ed167dSPhilipp Reisner rcu_read_unlock(); 3246b411b363SPhilipp Reisner disconnect: 3247b792c35cSAndreas Gruenbacher crypto_free_hash(peer_integrity_tfm); 3248036b17eaSPhilipp Reisner kfree(int_dig_in); 3249036b17eaSPhilipp Reisner kfree(int_dig_vv); 32507204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 325182bc0194SAndreas Gruenbacher return -EIO; 3252b411b363SPhilipp Reisner } 3253b411b363SPhilipp Reisner 3254b411b363SPhilipp Reisner /* helper function 3255b411b363SPhilipp Reisner * input: alg name, feature name 3256b411b363SPhilipp Reisner * return: NULL (alg name was "") 3257b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3258b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 3259b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 3260b411b363SPhilipp Reisner const char *alg, const char *name) 3261b411b363SPhilipp Reisner { 3262b411b363SPhilipp Reisner struct crypto_hash *tfm; 3263b411b363SPhilipp Reisner 3264b411b363SPhilipp Reisner if (!alg[0]) 3265b411b363SPhilipp Reisner return NULL; 3266b411b363SPhilipp Reisner 3267b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3268b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3269b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3270b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3271b411b363SPhilipp Reisner return tfm; 3272b411b363SPhilipp Reisner } 3273b411b363SPhilipp Reisner return tfm; 3274b411b363SPhilipp Reisner } 3275b411b363SPhilipp Reisner 32764a76b161SAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_tconn *tconn, struct packet_info *pi) 3277b411b363SPhilipp Reisner { 32784a76b161SAndreas Gruenbacher void *buffer = tconn->data.rbuf; 32794a76b161SAndreas Gruenbacher int size = pi->size; 32804a76b161SAndreas Gruenbacher 32814a76b161SAndreas Gruenbacher while (size) { 32824a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 32834a76b161SAndreas Gruenbacher s = drbd_recv(tconn, buffer, s); 32844a76b161SAndreas Gruenbacher if (s <= 0) { 32854a76b161SAndreas Gruenbacher if (s < 0) 32864a76b161SAndreas Gruenbacher return s; 32874a76b161SAndreas Gruenbacher break; 32884a76b161SAndreas Gruenbacher } 32894a76b161SAndreas Gruenbacher size -= s; 32904a76b161SAndreas Gruenbacher } 32914a76b161SAndreas Gruenbacher if (size) 32924a76b161SAndreas Gruenbacher return -EIO; 32934a76b161SAndreas Gruenbacher return 0; 32944a76b161SAndreas Gruenbacher } 32954a76b161SAndreas Gruenbacher 32964a76b161SAndreas Gruenbacher /* 32974a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 32984a76b161SAndreas Gruenbacher * 32994a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 33004a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 33014a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 33024a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 33034a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 33044a76b161SAndreas Gruenbacher * 33054a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 33064a76b161SAndreas Gruenbacher */ 33074a76b161SAndreas Gruenbacher static int config_unknown_volume(struct drbd_tconn *tconn, struct packet_info *pi) 33084a76b161SAndreas Gruenbacher { 33092fcb8f30SAndreas Gruenbacher conn_warn(tconn, "%s packet received for volume %u, which is not configured locally\n", 33102fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 33114a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 33124a76b161SAndreas Gruenbacher } 33134a76b161SAndreas Gruenbacher 33144a76b161SAndreas Gruenbacher static int receive_SyncParam(struct drbd_tconn *tconn, struct packet_info *pi) 33154a76b161SAndreas Gruenbacher { 33164a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3317e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3318b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3319b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3320b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 33212ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3322813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 33234a76b161SAndreas Gruenbacher const int apv = tconn->agreed_pro_version; 3324813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3325778f271dSPhilipp Reisner int fifo_size = 0; 332682bc0194SAndreas Gruenbacher int err; 3327b411b363SPhilipp Reisner 33284a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 33294a76b161SAndreas Gruenbacher if (!mdev) 33304a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 3331b411b363SPhilipp Reisner 3332b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3333b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3334b411b363SPhilipp Reisner + SHARED_SECRET_MAX 33358e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 33368e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3337b411b363SPhilipp Reisner 3338e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3339b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3340e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 334182bc0194SAndreas Gruenbacher return -EIO; 3342b411b363SPhilipp Reisner } 3343b411b363SPhilipp Reisner 3344b411b363SPhilipp Reisner if (apv <= 88) { 3345e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3346e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 33478e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3348e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3349e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3350b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 33518e26f9ccSPhilipp Reisner } else { 3352e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3353e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3354b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 3355b411b363SPhilipp Reisner } 3356b411b363SPhilipp Reisner 3357b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3358e658983aSAndreas Gruenbacher p = pi->data; 3359b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3360b411b363SPhilipp Reisner 3361e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, header_size); 336282bc0194SAndreas Gruenbacher if (err) 336382bc0194SAndreas Gruenbacher return err; 3364b411b363SPhilipp Reisner 3365813472ceSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3366813472ceSPhilipp Reisner old_net_conf = mdev->tconn->net_conf; 3367813472ceSPhilipp Reisner if (get_ldev(mdev)) { 3368daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3369daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3370813472ceSPhilipp Reisner put_ldev(mdev); 3371813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3372daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3373daeda1ccSPhilipp Reisner return -ENOMEM; 3374f399002eSLars Ellenberg } 3375b411b363SPhilipp Reisner 3376daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3377daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3378daeda1ccSPhilipp Reisner 33796394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3380813472ceSPhilipp Reisner } 3381b411b363SPhilipp Reisner 3382b411b363SPhilipp Reisner if (apv >= 88) { 3383b411b363SPhilipp Reisner if (apv == 88) { 33845de73827SPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 33855de73827SPhilipp Reisner dev_err(DEV, "verify-alg of wrong size, " 33865de73827SPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3387b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3388813472ceSPhilipp Reisner err = -EIO; 3389813472ceSPhilipp Reisner goto reconnect; 3390b411b363SPhilipp Reisner } 3391b411b363SPhilipp Reisner 339282bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size); 3393813472ceSPhilipp Reisner if (err) 3394813472ceSPhilipp Reisner goto reconnect; 3395b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3396b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3397b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3398b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3399b411b363SPhilipp Reisner 3400b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3401b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3402b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3403b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3404b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3405b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3406b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3407b411b363SPhilipp Reisner } 3408b411b363SPhilipp Reisner 34092ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3410b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3411b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 34122ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3413b411b363SPhilipp Reisner goto disconnect; 3414b411b363SPhilipp Reisner } 3415b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3416b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3417b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3418b411b363SPhilipp Reisner verify_tfm = NULL; 3419b411b363SPhilipp Reisner goto disconnect; 3420b411b363SPhilipp Reisner } 3421b411b363SPhilipp Reisner } 3422b411b363SPhilipp Reisner 34232ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3424b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3425b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 34262ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3427b411b363SPhilipp Reisner goto disconnect; 3428b411b363SPhilipp Reisner } 3429b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3430b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3431b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3432b411b363SPhilipp Reisner csums_tfm = NULL; 3433b411b363SPhilipp Reisner goto disconnect; 3434b411b363SPhilipp Reisner } 3435b411b363SPhilipp Reisner } 3436b411b363SPhilipp Reisner 3437813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3438daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3439daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3440daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3441daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3442778f271dSPhilipp Reisner 3443daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 34449958c857SPhilipp Reisner if (fifo_size != mdev->rs_plan_s->size) { 3445813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3446813472ceSPhilipp Reisner if (!new_plan) { 3447778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3448f399002eSLars Ellenberg put_ldev(mdev); 3449778f271dSPhilipp Reisner goto disconnect; 3450778f271dSPhilipp Reisner } 3451778f271dSPhilipp Reisner } 34528e26f9ccSPhilipp Reisner } 3453b411b363SPhilipp Reisner 345491fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 34552ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 34562ec91e0eSPhilipp Reisner if (!new_net_conf) { 345791fd4dadSPhilipp Reisner dev_err(DEV, "Allocation of new net_conf failed\n"); 345891fd4dadSPhilipp Reisner goto disconnect; 345991fd4dadSPhilipp Reisner } 346091fd4dadSPhilipp Reisner 34612ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 346291fd4dadSPhilipp Reisner 3463b411b363SPhilipp Reisner if (verify_tfm) { 34642ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 34652ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3466f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3467f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3468b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3469b411b363SPhilipp Reisner } 3470b411b363SPhilipp Reisner if (csums_tfm) { 34712ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 34722ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3473f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3474f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3475b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3476b411b363SPhilipp Reisner } 34772ec91e0eSPhilipp Reisner rcu_assign_pointer(tconn->net_conf, new_net_conf); 3478778f271dSPhilipp Reisner } 3479b411b363SPhilipp Reisner } 3480b411b363SPhilipp Reisner 3481813472ceSPhilipp Reisner if (new_disk_conf) { 3482daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3483813472ceSPhilipp Reisner put_ldev(mdev); 3484b411b363SPhilipp Reisner } 3485813472ceSPhilipp Reisner 3486813472ceSPhilipp Reisner if (new_plan) { 3487813472ceSPhilipp Reisner old_plan = mdev->rs_plan_s; 3488813472ceSPhilipp Reisner rcu_assign_pointer(mdev->rs_plan_s, new_plan); 3489813472ceSPhilipp Reisner } 3490daeda1ccSPhilipp Reisner 3491daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3492daeda1ccSPhilipp Reisner synchronize_rcu(); 3493daeda1ccSPhilipp Reisner if (new_net_conf) 3494daeda1ccSPhilipp Reisner kfree(old_net_conf); 3495daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3496813472ceSPhilipp Reisner kfree(old_plan); 3497daeda1ccSPhilipp Reisner 349882bc0194SAndreas Gruenbacher return 0; 3499b411b363SPhilipp Reisner 3500813472ceSPhilipp Reisner reconnect: 3501813472ceSPhilipp Reisner if (new_disk_conf) { 3502813472ceSPhilipp Reisner put_ldev(mdev); 3503813472ceSPhilipp Reisner kfree(new_disk_conf); 3504813472ceSPhilipp Reisner } 3505813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3506813472ceSPhilipp Reisner return -EIO; 3507813472ceSPhilipp Reisner 3508b411b363SPhilipp Reisner disconnect: 3509813472ceSPhilipp Reisner kfree(new_plan); 3510813472ceSPhilipp Reisner if (new_disk_conf) { 3511813472ceSPhilipp Reisner put_ldev(mdev); 3512813472ceSPhilipp Reisner kfree(new_disk_conf); 3513813472ceSPhilipp Reisner } 3514a0095508SPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3515b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3516b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3517b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3518b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3519b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 352038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 352182bc0194SAndreas Gruenbacher return -EIO; 3522b411b363SPhilipp Reisner } 3523b411b363SPhilipp Reisner 3524b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3525b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3526b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3527b411b363SPhilipp Reisner { 3528b411b363SPhilipp Reisner sector_t d; 3529b411b363SPhilipp Reisner if (a == 0 || b == 0) 3530b411b363SPhilipp Reisner return; 3531b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3532b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3533b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3534b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3535b411b363SPhilipp Reisner } 3536b411b363SPhilipp Reisner 35374a76b161SAndreas Gruenbacher static int receive_sizes(struct drbd_tconn *tconn, struct packet_info *pi) 3538b411b363SPhilipp Reisner { 35394a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3540e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3541e96c9633SPhilipp Reisner enum determine_dev_size dd = DS_UNCHANGED; 3542b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3543b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3544e89b591cSPhilipp Reisner enum dds_flags ddsf; 3545b411b363SPhilipp Reisner 35464a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 35474a76b161SAndreas Gruenbacher if (!mdev) 35484a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 35494a76b161SAndreas Gruenbacher 3550b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3551b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3552b411b363SPhilipp Reisner 3553b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3554b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3555b411b363SPhilipp Reisner mdev->p_size = p_size; 3556b411b363SPhilipp Reisner 3557b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3558daeda1ccSPhilipp Reisner rcu_read_lock(); 3559daeda1ccSPhilipp Reisner my_usize = rcu_dereference(mdev->ldev->disk_conf)->disk_size; 3560daeda1ccSPhilipp Reisner rcu_read_unlock(); 3561daeda1ccSPhilipp Reisner 3562b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3563b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3564b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3565daeda1ccSPhilipp Reisner p_usize, my_usize); 3566b411b363SPhilipp Reisner 3567b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3568b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3569b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3570daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3571b411b363SPhilipp Reisner 3572b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3573b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3574ef5e44a6SPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, p_usize, 0) < 3575b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3576b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3577b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3578b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 357938fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3580b411b363SPhilipp Reisner put_ldev(mdev); 358182bc0194SAndreas Gruenbacher return -EIO; 3582b411b363SPhilipp Reisner } 3583daeda1ccSPhilipp Reisner 3584daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3585daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3586daeda1ccSPhilipp Reisner 3587daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3588daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3589daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3590daeda1ccSPhilipp Reisner put_ldev(mdev); 3591daeda1ccSPhilipp Reisner return -ENOMEM; 3592daeda1ccSPhilipp Reisner } 3593daeda1ccSPhilipp Reisner 3594daeda1ccSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3595daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3596daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3597daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3598daeda1ccSPhilipp Reisner 3599daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3600daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3601daeda1ccSPhilipp Reisner synchronize_rcu(); 3602daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3603daeda1ccSPhilipp Reisner 3604daeda1ccSPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3605daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3606daeda1ccSPhilipp Reisner } 3607daeda1ccSPhilipp Reisner 3608b411b363SPhilipp Reisner put_ldev(mdev); 3609b411b363SPhilipp Reisner } 3610b411b363SPhilipp Reisner 3611e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3612b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3613d752b269SPhilipp Reisner dd = drbd_determine_dev_size(mdev, ddsf, NULL); 3614b411b363SPhilipp Reisner put_ldev(mdev); 3615e96c9633SPhilipp Reisner if (dd == DS_ERROR) 361682bc0194SAndreas Gruenbacher return -EIO; 3617b411b363SPhilipp Reisner drbd_md_sync(mdev); 3618b411b363SPhilipp Reisner } else { 3619b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3620b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3621b411b363SPhilipp Reisner } 3622b411b363SPhilipp Reisner 362399432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 362499432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 362599432fccSPhilipp Reisner 3626b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3627b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3628b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3629b411b363SPhilipp Reisner ldsc = 1; 3630b411b363SPhilipp Reisner } 3631b411b363SPhilipp Reisner 3632b411b363SPhilipp Reisner put_ldev(mdev); 3633b411b363SPhilipp Reisner } 3634b411b363SPhilipp Reisner 3635b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3636b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3637b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3638b411b363SPhilipp Reisner /* we have different sizes, probably peer 3639b411b363SPhilipp Reisner * needs to know my new size... */ 3640e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3641b411b363SPhilipp Reisner } 3642b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3643e96c9633SPhilipp Reisner (dd == DS_GREW && mdev->state.conn == C_CONNECTED)) { 3644b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3645e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3646e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3647e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3648b411b363SPhilipp Reisner else 3649e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3650e89b591cSPhilipp Reisner } else 3651b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3652b411b363SPhilipp Reisner } 3653b411b363SPhilipp Reisner } 3654b411b363SPhilipp Reisner 365582bc0194SAndreas Gruenbacher return 0; 3656b411b363SPhilipp Reisner } 3657b411b363SPhilipp Reisner 36584a76b161SAndreas Gruenbacher static int receive_uuids(struct drbd_tconn *tconn, struct packet_info *pi) 3659b411b363SPhilipp Reisner { 36604a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3661e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3662b411b363SPhilipp Reisner u64 *p_uuid; 366362b0da3aSLars Ellenberg int i, updated_uuids = 0; 3664b411b363SPhilipp Reisner 36654a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 36664a76b161SAndreas Gruenbacher if (!mdev) 36674a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 36684a76b161SAndreas Gruenbacher 3669b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3670063eacf8SJing Wang if (!p_uuid) { 3671063eacf8SJing Wang dev_err(DEV, "kmalloc of p_uuid failed\n"); 3672063eacf8SJing Wang return false; 3673063eacf8SJing Wang } 3674b411b363SPhilipp Reisner 3675b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3676b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3677b411b363SPhilipp Reisner 3678b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3679b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3680b411b363SPhilipp Reisner 3681b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3682b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3683b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3684b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3685b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3686b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 368738fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 368882bc0194SAndreas Gruenbacher return -EIO; 3689b411b363SPhilipp Reisner } 3690b411b363SPhilipp Reisner 3691b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3692b411b363SPhilipp Reisner int skip_initial_sync = 3693b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 369431890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3695b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3696b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3697b411b363SPhilipp Reisner if (skip_initial_sync) { 3698b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3699b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 370020ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 370120ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3702b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3703b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3704b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3705b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3706b411b363SPhilipp Reisner drbd_md_sync(mdev); 370762b0da3aSLars Ellenberg updated_uuids = 1; 3708b411b363SPhilipp Reisner } 3709b411b363SPhilipp Reisner put_ldev(mdev); 371018a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 371118a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 371218a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 371318a50fa2SPhilipp Reisner for me. */ 371462b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3715b411b363SPhilipp Reisner } 3716b411b363SPhilipp Reisner 3717b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3718b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3719b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3720b411b363SPhilipp Reisner new disk state... */ 37218410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 37228410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3723b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 372462b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 372562b0da3aSLars Ellenberg 372662b0da3aSLars Ellenberg if (updated_uuids) 372762b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3728b411b363SPhilipp Reisner 372982bc0194SAndreas Gruenbacher return 0; 3730b411b363SPhilipp Reisner } 3731b411b363SPhilipp Reisner 3732b411b363SPhilipp Reisner /** 3733b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3734b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3735b411b363SPhilipp Reisner */ 3736b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3737b411b363SPhilipp Reisner { 3738b411b363SPhilipp Reisner union drbd_state ms; 3739b411b363SPhilipp Reisner 3740b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3741369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 3742b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3743b411b363SPhilipp Reisner 3744b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3745b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3746b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3747b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3748b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3749b411b363SPhilipp Reisner }; 3750b411b363SPhilipp Reisner 3751b411b363SPhilipp Reisner ms.i = ps.i; 3752b411b363SPhilipp Reisner 3753b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3754b411b363SPhilipp Reisner ms.peer = ps.role; 3755b411b363SPhilipp Reisner ms.role = ps.peer; 3756b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3757b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3758b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3759b411b363SPhilipp Reisner 3760b411b363SPhilipp Reisner return ms; 3761b411b363SPhilipp Reisner } 3762b411b363SPhilipp Reisner 37634a76b161SAndreas Gruenbacher static int receive_req_state(struct drbd_tconn *tconn, struct packet_info *pi) 3764b411b363SPhilipp Reisner { 37654a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3766e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3767b411b363SPhilipp Reisner union drbd_state mask, val; 3768bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3769b411b363SPhilipp Reisner 37704a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 37714a76b161SAndreas Gruenbacher if (!mdev) 37724a76b161SAndreas Gruenbacher return -EIO; 37734a76b161SAndreas Gruenbacher 3774b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3775b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3776b411b363SPhilipp Reisner 3777427c0434SLars Ellenberg if (test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags) && 37788410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3779b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 378082bc0194SAndreas Gruenbacher return 0; 3781b411b363SPhilipp Reisner } 3782b411b363SPhilipp Reisner 3783b411b363SPhilipp Reisner mask = convert_state(mask); 3784b411b363SPhilipp Reisner val = convert_state(val); 3785b411b363SPhilipp Reisner 3786b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3787b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3788047cd4a6SPhilipp Reisner 3789b411b363SPhilipp Reisner drbd_md_sync(mdev); 3790b411b363SPhilipp Reisner 379182bc0194SAndreas Gruenbacher return 0; 3792b411b363SPhilipp Reisner } 3793b411b363SPhilipp Reisner 3794e2857216SAndreas Gruenbacher static int receive_req_conn_state(struct drbd_tconn *tconn, struct packet_info *pi) 3795b411b363SPhilipp Reisner { 3796e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3797dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3798dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3799dfafcc8aSPhilipp Reisner 3800dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3801dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3802dfafcc8aSPhilipp Reisner 3803427c0434SLars Ellenberg if (test_bit(RESOLVE_CONFLICTS, &tconn->flags) && 3804dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3805dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 380682bc0194SAndreas Gruenbacher return 0; 3807dfafcc8aSPhilipp Reisner } 3808dfafcc8aSPhilipp Reisner 3809dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3810dfafcc8aSPhilipp Reisner val = convert_state(val); 3811dfafcc8aSPhilipp Reisner 3812778bcf2eSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3813dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3814dfafcc8aSPhilipp Reisner 381582bc0194SAndreas Gruenbacher return 0; 3816dfafcc8aSPhilipp Reisner } 3817dfafcc8aSPhilipp Reisner 38184a76b161SAndreas Gruenbacher static int receive_state(struct drbd_tconn *tconn, struct packet_info *pi) 3819b411b363SPhilipp Reisner { 38204a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3821e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 38224ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3823b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 382465d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3825b411b363SPhilipp Reisner int rv; 3826b411b363SPhilipp Reisner 38274a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 38284a76b161SAndreas Gruenbacher if (!mdev) 38294a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 38304a76b161SAndreas Gruenbacher 3831b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3832b411b363SPhilipp Reisner 3833b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3834b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3835b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3836b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3837b411b363SPhilipp Reisner } 3838b411b363SPhilipp Reisner 383987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3840b411b363SPhilipp Reisner retry: 384178bae59bSPhilipp Reisner os = ns = drbd_read_state(mdev); 384287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3843b411b363SPhilipp Reisner 3844545752d5SLars Ellenberg /* If some other part of the code (asender thread, timeout) 3845545752d5SLars Ellenberg * already decided to close the connection again, 3846545752d5SLars Ellenberg * we must not "re-establish" it here. */ 3847545752d5SLars Ellenberg if (os.conn <= C_TEAR_DOWN) 384858ffa580SLars Ellenberg return -ECONNRESET; 3849545752d5SLars Ellenberg 385040424e4aSLars Ellenberg /* If this is the "end of sync" confirmation, usually the peer disk 385140424e4aSLars Ellenberg * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 385240424e4aSLars Ellenberg * set) resync started in PausedSyncT, or if the timing of pause-/ 385340424e4aSLars Ellenberg * unpause-sync events has been "just right", the peer disk may 385440424e4aSLars Ellenberg * transition from D_CONSISTENT to D_UP_TO_DATE as well. 385540424e4aSLars Ellenberg */ 385640424e4aSLars Ellenberg if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 385740424e4aSLars Ellenberg real_peer_disk == D_UP_TO_DATE && 3858e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3859e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3860e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3861e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3862e9ef7bb6SLars Ellenberg * syncing states. 3863e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3864e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3865e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3866e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3867e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3868e9ef7bb6SLars Ellenberg 3869e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3870e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3871e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3872e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3873e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3874e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3875e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 387682bc0194SAndreas Gruenbacher return 0; 3877e9ef7bb6SLars Ellenberg } 3878e9ef7bb6SLars Ellenberg } 3879e9ef7bb6SLars Ellenberg 388002b91b55SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 388102b91b55SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 388202b91b55SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 388358ffa580SLars Ellenberg ov_out_of_sync_print(mdev); 388402b91b55SLars Ellenberg drbd_resync_finished(mdev); 388558ffa580SLars Ellenberg return 0; 388602b91b55SLars Ellenberg } 388702b91b55SLars Ellenberg 3888e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3889e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3890e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3891e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3892e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3893e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3894e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3895e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3896e9ef7bb6SLars Ellenberg 38974ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 38984ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3899b411b363SPhilipp Reisner 390067531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 390167531718SPhilipp Reisner ns.conn = C_BEHIND; 390267531718SPhilipp Reisner 3903b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3904b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3905b411b363SPhilipp Reisner int cr; /* consider resync */ 3906b411b363SPhilipp Reisner 3907b411b363SPhilipp Reisner /* if we established a new connection */ 39084ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3909b411b363SPhilipp Reisner /* if we had an established connection 3910b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 39114ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3912b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 39134ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3914b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3915b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3916b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3917b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3918b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 39194ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3920b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3921b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3922b411b363SPhilipp Reisner 3923b411b363SPhilipp Reisner if (cr) 39244ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3925b411b363SPhilipp Reisner 3926b411b363SPhilipp Reisner put_ldev(mdev); 39274ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 39284ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3929b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 393082f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3931b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3932b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3933b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3934580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3935b411b363SPhilipp Reisner } else { 39368169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 393782bc0194SAndreas Gruenbacher return -EIO; 39384ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 393938fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 394082bc0194SAndreas Gruenbacher return -EIO; 3941b411b363SPhilipp Reisner } 3942b411b363SPhilipp Reisner } 3943b411b363SPhilipp Reisner } 3944b411b363SPhilipp Reisner 394587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 394678bae59bSPhilipp Reisner if (os.i != drbd_read_state(mdev).i) 3947b411b363SPhilipp Reisner goto retry; 3948b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3949b411b363SPhilipp Reisner ns.peer = peer_state.role; 3950b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3951b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 39524ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3953b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 39544ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 39552aebfabbSPhilipp Reisner if (ns.pdsk == D_CONSISTENT && drbd_suspended(mdev) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3956481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 39578554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3958481c6f50SPhilipp Reisner for temporal network outages! */ 395987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3960481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 39612f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3962481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3963481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 396438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 396582bc0194SAndreas Gruenbacher return -EIO; 3966481c6f50SPhilipp Reisner } 396765d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 396878bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 396987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3970b411b363SPhilipp Reisner 3971b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 397238fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 397382bc0194SAndreas Gruenbacher return -EIO; 3974b411b363SPhilipp Reisner } 3975b411b363SPhilipp Reisner 39764ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 39774ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3978b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3979b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3980b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3981b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3982b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3983f479ea06SLars Ellenberg drbd_send_current_state(mdev); 3984b411b363SPhilipp Reisner } 3985b411b363SPhilipp Reisner } 3986b411b363SPhilipp Reisner 398708b165baSPhilipp Reisner clear_bit(DISCARD_MY_DATA, &mdev->flags); 3988b411b363SPhilipp Reisner 3989cccac985SLars Ellenberg drbd_md_sync(mdev); /* update connected indicator, la_size_sect, ... */ 3990b411b363SPhilipp Reisner 399182bc0194SAndreas Gruenbacher return 0; 3992b411b363SPhilipp Reisner } 3993b411b363SPhilipp Reisner 39944a76b161SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_tconn *tconn, struct packet_info *pi) 3995b411b363SPhilipp Reisner { 39964a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3997e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 39984a76b161SAndreas Gruenbacher 39994a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 40004a76b161SAndreas Gruenbacher if (!mdev) 40014a76b161SAndreas Gruenbacher return -EIO; 4002b411b363SPhilipp Reisner 4003b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 4004b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 4005c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 4006b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 4007b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 4008b411b363SPhilipp Reisner 4009b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 4010b411b363SPhilipp Reisner 4011b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4012b411b363SPhilipp Reisner _not_ be rotated into the history */ 4013b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 4014b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 4015b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 4016b411b363SPhilipp Reisner 401762b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 4018b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 4019b411b363SPhilipp Reisner 4020b411b363SPhilipp Reisner put_ldev(mdev); 4021b411b363SPhilipp Reisner } else 4022b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 4023b411b363SPhilipp Reisner 402482bc0194SAndreas Gruenbacher return 0; 4025b411b363SPhilipp Reisner } 4026b411b363SPhilipp Reisner 40272c46407dSAndreas Gruenbacher /** 40282c46407dSAndreas Gruenbacher * receive_bitmap_plain 40292c46407dSAndreas Gruenbacher * 40302c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40312c46407dSAndreas Gruenbacher * code upon failure. 40322c46407dSAndreas Gruenbacher */ 40332c46407dSAndreas Gruenbacher static int 403450d0b1adSAndreas Gruenbacher receive_bitmap_plain(struct drbd_conf *mdev, unsigned int size, 4035e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4036b411b363SPhilipp Reisner { 403750d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 403850d0b1adSAndreas Gruenbacher drbd_header_size(mdev->tconn); 4039e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 404050d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4041e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 40422c46407dSAndreas Gruenbacher int err; 4043b411b363SPhilipp Reisner 404450d0b1adSAndreas Gruenbacher if (want != size) { 404550d0b1adSAndreas Gruenbacher dev_err(DEV, "%s:want (%u) != size (%u)\n", __func__, want, size); 40462c46407dSAndreas Gruenbacher return -EIO; 4047b411b363SPhilipp Reisner } 4048b411b363SPhilipp Reisner if (want == 0) 40492c46407dSAndreas Gruenbacher return 0; 4050e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, want); 405182bc0194SAndreas Gruenbacher if (err) 40522c46407dSAndreas Gruenbacher return err; 4053b411b363SPhilipp Reisner 4054e658983aSAndreas Gruenbacher drbd_bm_merge_lel(mdev, c->word_offset, num_words, p); 4055b411b363SPhilipp Reisner 4056b411b363SPhilipp Reisner c->word_offset += num_words; 4057b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4058b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4059b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4060b411b363SPhilipp Reisner 40612c46407dSAndreas Gruenbacher return 1; 4062b411b363SPhilipp Reisner } 4063b411b363SPhilipp Reisner 4064a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4065a02d1240SAndreas Gruenbacher { 4066a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4067a02d1240SAndreas Gruenbacher } 4068a02d1240SAndreas Gruenbacher 4069a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4070a02d1240SAndreas Gruenbacher { 4071a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4072a02d1240SAndreas Gruenbacher } 4073a02d1240SAndreas Gruenbacher 4074a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4075a02d1240SAndreas Gruenbacher { 4076a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4077a02d1240SAndreas Gruenbacher } 4078a02d1240SAndreas Gruenbacher 40792c46407dSAndreas Gruenbacher /** 40802c46407dSAndreas Gruenbacher * recv_bm_rle_bits 40812c46407dSAndreas Gruenbacher * 40822c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40832c46407dSAndreas Gruenbacher * code upon failure. 40842c46407dSAndreas Gruenbacher */ 40852c46407dSAndreas Gruenbacher static int 4086b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 4087b411b363SPhilipp Reisner struct p_compressed_bm *p, 4088c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4089c6d25cfeSPhilipp Reisner unsigned int len) 4090b411b363SPhilipp Reisner { 4091b411b363SPhilipp Reisner struct bitstream bs; 4092b411b363SPhilipp Reisner u64 look_ahead; 4093b411b363SPhilipp Reisner u64 rl; 4094b411b363SPhilipp Reisner u64 tmp; 4095b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4096b411b363SPhilipp Reisner unsigned long e; 4097a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4098b411b363SPhilipp Reisner int have; 4099b411b363SPhilipp Reisner int bits; 4100b411b363SPhilipp Reisner 4101a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4102b411b363SPhilipp Reisner 4103b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4104b411b363SPhilipp Reisner if (bits < 0) 41052c46407dSAndreas Gruenbacher return -EIO; 4106b411b363SPhilipp Reisner 4107b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4108b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4109b411b363SPhilipp Reisner if (bits <= 0) 41102c46407dSAndreas Gruenbacher return -EIO; 4111b411b363SPhilipp Reisner 4112b411b363SPhilipp Reisner if (toggle) { 4113b411b363SPhilipp Reisner e = s + rl -1; 4114b411b363SPhilipp Reisner if (e >= c->bm_bits) { 4115b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 41162c46407dSAndreas Gruenbacher return -EIO; 4117b411b363SPhilipp Reisner } 4118b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 4119b411b363SPhilipp Reisner } 4120b411b363SPhilipp Reisner 4121b411b363SPhilipp Reisner if (have < bits) { 4122b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4123b411b363SPhilipp Reisner have, bits, look_ahead, 4124b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4125b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 41262c46407dSAndreas Gruenbacher return -EIO; 4127b411b363SPhilipp Reisner } 4128b411b363SPhilipp Reisner look_ahead >>= bits; 4129b411b363SPhilipp Reisner have -= bits; 4130b411b363SPhilipp Reisner 4131b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4132b411b363SPhilipp Reisner if (bits < 0) 41332c46407dSAndreas Gruenbacher return -EIO; 4134b411b363SPhilipp Reisner look_ahead |= tmp << have; 4135b411b363SPhilipp Reisner have += bits; 4136b411b363SPhilipp Reisner } 4137b411b363SPhilipp Reisner 4138b411b363SPhilipp Reisner c->bit_offset = s; 4139b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4140b411b363SPhilipp Reisner 41412c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4142b411b363SPhilipp Reisner } 4143b411b363SPhilipp Reisner 41442c46407dSAndreas Gruenbacher /** 41452c46407dSAndreas Gruenbacher * decode_bitmap_c 41462c46407dSAndreas Gruenbacher * 41472c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 41482c46407dSAndreas Gruenbacher * code upon failure. 41492c46407dSAndreas Gruenbacher */ 41502c46407dSAndreas Gruenbacher static int 4151b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 4152b411b363SPhilipp Reisner struct p_compressed_bm *p, 4153c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4154c6d25cfeSPhilipp Reisner unsigned int len) 4155b411b363SPhilipp Reisner { 4156a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 4157e658983aSAndreas Gruenbacher return recv_bm_rle_bits(mdev, p, c, len - sizeof(*p)); 4158b411b363SPhilipp Reisner 4159b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4160b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4161b411b363SPhilipp Reisner * during all our tests. */ 4162b411b363SPhilipp Reisner 4163b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 416438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 41652c46407dSAndreas Gruenbacher return -EIO; 4166b411b363SPhilipp Reisner } 4167b411b363SPhilipp Reisner 4168b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 4169b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4170b411b363SPhilipp Reisner { 4171b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 417250d0b1adSAndreas Gruenbacher unsigned int header_size = drbd_header_size(mdev->tconn); 417350d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 417450d0b1adSAndreas Gruenbacher unsigned int plain = 417550d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 417650d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 417750d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 417850d0b1adSAndreas Gruenbacher unsigned int r; 4179b411b363SPhilipp Reisner 4180b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4181b411b363SPhilipp Reisner if (total == 0) 4182b411b363SPhilipp Reisner return; 4183b411b363SPhilipp Reisner 4184b411b363SPhilipp Reisner /* don't report if not compressed */ 4185b411b363SPhilipp Reisner if (total >= plain) 4186b411b363SPhilipp Reisner return; 4187b411b363SPhilipp Reisner 4188b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4189b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4190b411b363SPhilipp Reisner : (1000 * total / plain); 4191b411b363SPhilipp Reisner 4192b411b363SPhilipp Reisner if (r > 1000) 4193b411b363SPhilipp Reisner r = 1000; 4194b411b363SPhilipp Reisner 4195b411b363SPhilipp Reisner r = 1000 - r; 4196b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4197b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4198b411b363SPhilipp Reisner direction, 4199b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4200b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4201b411b363SPhilipp Reisner total, r/10, r % 10); 4202b411b363SPhilipp Reisner } 4203b411b363SPhilipp Reisner 4204b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4205b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4206b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4207b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4208b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4209b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4210b411b363SPhilipp Reisner 4211b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 42124a76b161SAndreas Gruenbacher static int receive_bitmap(struct drbd_tconn *tconn, struct packet_info *pi) 4213b411b363SPhilipp Reisner { 42144a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4215b411b363SPhilipp Reisner struct bm_xfer_ctx c; 42162c46407dSAndreas Gruenbacher int err; 42174a76b161SAndreas Gruenbacher 42184a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 42194a76b161SAndreas Gruenbacher if (!mdev) 42204a76b161SAndreas Gruenbacher return -EIO; 4221b411b363SPhilipp Reisner 422220ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 422320ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 422420ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4225b411b363SPhilipp Reisner 4226b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4227b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 4228b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 4229b411b363SPhilipp Reisner }; 4230b411b363SPhilipp Reisner 42312c46407dSAndreas Gruenbacher for(;;) { 4232e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 4233e658983aSAndreas Gruenbacher err = receive_bitmap_plain(mdev, pi->size, pi->data, &c); 4234e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4235b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4236b411b363SPhilipp Reisner * and the feature is enabled! */ 4237e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4238b411b363SPhilipp Reisner 423950d0b1adSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(tconn)) { 4240b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 424182bc0194SAndreas Gruenbacher err = -EIO; 4242b411b363SPhilipp Reisner goto out; 4243b411b363SPhilipp Reisner } 4244e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4245e2857216SAndreas Gruenbacher dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", pi->size); 424682bc0194SAndreas Gruenbacher err = -EIO; 424778fcbdaeSAndreas Gruenbacher goto out; 4248b411b363SPhilipp Reisner } 4249e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, pi->size); 4250e658983aSAndreas Gruenbacher if (err) 4251e658983aSAndreas Gruenbacher goto out; 4252e2857216SAndreas Gruenbacher err = decode_bitmap_c(mdev, p, &c, pi->size); 4253b411b363SPhilipp Reisner } else { 4254e2857216SAndreas Gruenbacher dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 425582bc0194SAndreas Gruenbacher err = -EIO; 4256b411b363SPhilipp Reisner goto out; 4257b411b363SPhilipp Reisner } 4258b411b363SPhilipp Reisner 4259e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 426050d0b1adSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(tconn) + pi->size; 4261b411b363SPhilipp Reisner 42622c46407dSAndreas Gruenbacher if (err <= 0) { 42632c46407dSAndreas Gruenbacher if (err < 0) 42642c46407dSAndreas Gruenbacher goto out; 4265b411b363SPhilipp Reisner break; 42662c46407dSAndreas Gruenbacher } 4267e2857216SAndreas Gruenbacher err = drbd_recv_header(mdev->tconn, pi); 426882bc0194SAndreas Gruenbacher if (err) 4269b411b363SPhilipp Reisner goto out; 42702c46407dSAndreas Gruenbacher } 4271b411b363SPhilipp Reisner 4272b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 4273b411b363SPhilipp Reisner 4274b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 4275de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4276de1f8e4aSAndreas Gruenbacher 427782bc0194SAndreas Gruenbacher err = drbd_send_bitmap(mdev); 427882bc0194SAndreas Gruenbacher if (err) 4279b411b363SPhilipp Reisner goto out; 4280b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4281de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 4282de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 4283b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 4284b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4285b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4286b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 4287b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 4288b411b363SPhilipp Reisner } 428982bc0194SAndreas Gruenbacher err = 0; 4290b411b363SPhilipp Reisner 4291b411b363SPhilipp Reisner out: 429220ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 429382bc0194SAndreas Gruenbacher if (!err && mdev->state.conn == C_WF_BITMAP_S) 4294b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 429582bc0194SAndreas Gruenbacher return err; 4296b411b363SPhilipp Reisner } 4297b411b363SPhilipp Reisner 42984a76b161SAndreas Gruenbacher static int receive_skip(struct drbd_tconn *tconn, struct packet_info *pi) 4299b411b363SPhilipp Reisner { 43004a76b161SAndreas Gruenbacher conn_warn(tconn, "skipping unknown optional packet type %d, l: %d!\n", 4301e2857216SAndreas Gruenbacher pi->cmd, pi->size); 4302b411b363SPhilipp Reisner 43034a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 4304b411b363SPhilipp Reisner } 4305b411b363SPhilipp Reisner 43064a76b161SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_tconn *tconn, struct packet_info *pi) 4307b411b363SPhilipp Reisner { 4308b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4309b411b363SPhilipp Reisner * with the data requests being unplugged */ 43104a76b161SAndreas Gruenbacher drbd_tcp_quickack(tconn->data.socket); 4311b411b363SPhilipp Reisner 431282bc0194SAndreas Gruenbacher return 0; 4313b411b363SPhilipp Reisner } 4314b411b363SPhilipp Reisner 43154a76b161SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_tconn *tconn, struct packet_info *pi) 431673a01a18SPhilipp Reisner { 43174a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4318e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 43194a76b161SAndreas Gruenbacher 43204a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 43214a76b161SAndreas Gruenbacher if (!mdev) 43224a76b161SAndreas Gruenbacher return -EIO; 432373a01a18SPhilipp Reisner 4324f735e363SLars Ellenberg switch (mdev->state.conn) { 4325f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4326f735e363SLars Ellenberg case C_WF_BITMAP_T: 4327f735e363SLars Ellenberg case C_BEHIND: 4328f735e363SLars Ellenberg break; 4329f735e363SLars Ellenberg default: 4330f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4331f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 4332f735e363SLars Ellenberg } 4333f735e363SLars Ellenberg 433473a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 433573a01a18SPhilipp Reisner 433682bc0194SAndreas Gruenbacher return 0; 433773a01a18SPhilipp Reisner } 433873a01a18SPhilipp Reisner 433902918be2SPhilipp Reisner struct data_cmd { 434002918be2SPhilipp Reisner int expect_payload; 434102918be2SPhilipp Reisner size_t pkt_size; 43424a76b161SAndreas Gruenbacher int (*fn)(struct drbd_tconn *, struct packet_info *); 4343b411b363SPhilipp Reisner }; 4344b411b363SPhilipp Reisner 434502918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 434602918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 434702918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 434802918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 434902918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4350e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4351e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4352e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 435302918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 435402918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4355e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4356e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 435702918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 435802918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 435902918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 436002918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 436102918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 436202918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 436302918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 436402918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 436502918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 436602918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 436773a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 43684a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4369036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 437002918be2SPhilipp Reisner }; 437102918be2SPhilipp Reisner 4372eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 4373b411b363SPhilipp Reisner { 437477351055SPhilipp Reisner struct packet_info pi; 437502918be2SPhilipp Reisner size_t shs; /* sub header size */ 437682bc0194SAndreas Gruenbacher int err; 4377b411b363SPhilipp Reisner 4378eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 4379deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4380deebe195SAndreas Gruenbacher 4381eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 438269bc7bc3SAndreas Gruenbacher if (drbd_recv_header(tconn, &pi)) 438302918be2SPhilipp Reisner goto err_out; 438402918be2SPhilipp Reisner 4385deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 43864a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 43872fcb8f30SAndreas Gruenbacher conn_err(tconn, "Unexpected data packet %s (0x%04x)", 43882fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 438902918be2SPhilipp Reisner goto err_out; 43900b33a916SLars Ellenberg } 4391b411b363SPhilipp Reisner 4392e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4393e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 43942fcb8f30SAndreas Gruenbacher conn_err(tconn, "No payload expected %s l:%d\n", 43952fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4396c13f7e1aSLars Ellenberg goto err_out; 4397c13f7e1aSLars Ellenberg } 4398c13f7e1aSLars Ellenberg 4399c13f7e1aSLars Ellenberg if (shs) { 4400e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, pi.data, shs); 4401a5c31904SAndreas Gruenbacher if (err) 440202918be2SPhilipp Reisner goto err_out; 4403e2857216SAndreas Gruenbacher pi.size -= shs; 4404b411b363SPhilipp Reisner } 440502918be2SPhilipp Reisner 44064a76b161SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 44074a76b161SAndreas Gruenbacher if (err) { 44089f5bdc33SAndreas Gruenbacher conn_err(tconn, "error receiving %s, e: %d l: %d!\n", 44099f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 441002918be2SPhilipp Reisner goto err_out; 441102918be2SPhilipp Reisner } 441202918be2SPhilipp Reisner } 441382bc0194SAndreas Gruenbacher return; 441402918be2SPhilipp Reisner 441502918be2SPhilipp Reisner err_out: 4416bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4417b411b363SPhilipp Reisner } 4418b411b363SPhilipp Reisner 44190e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 4420b411b363SPhilipp Reisner { 4421b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4422b411b363SPhilipp Reisner 4423b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 44240e29d163SPhilipp Reisner barr.w.tconn = tconn; 4425b411b363SPhilipp Reisner init_completion(&barr.done); 4426d5b27b01SLars Ellenberg drbd_queue_work(&tconn->sender_work, &barr.w); 4427b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4428b411b363SPhilipp Reisner } 4429b411b363SPhilipp Reisner 443081fa2e67SPhilipp Reisner static void conn_disconnect(struct drbd_tconn *tconn) 4431f70b3511SPhilipp Reisner { 4432c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 4433bbeb641cSPhilipp Reisner enum drbd_conns oc; 4434376694a0SPhilipp Reisner int vnr; 4435f70b3511SPhilipp Reisner 4436bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4437b411b363SPhilipp Reisner return; 4438b411b363SPhilipp Reisner 4439545752d5SLars Ellenberg /* We are about to start the cleanup after connection loss. 4440545752d5SLars Ellenberg * Make sure drbd_make_request knows about that. 4441545752d5SLars Ellenberg * Usually we should be in some network failure state already, 4442545752d5SLars Ellenberg * but just in case we are not, we fix it up here. 4443545752d5SLars Ellenberg */ 4444b8853dbdSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4445545752d5SLars Ellenberg 4446b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4447360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4448360cc740SPhilipp Reisner drbd_free_sock(tconn); 4449360cc740SPhilipp Reisner 4450c141ebdaSPhilipp Reisner rcu_read_lock(); 4451c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 4452c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 4453c141ebdaSPhilipp Reisner rcu_read_unlock(); 4454c141ebdaSPhilipp Reisner drbd_disconnected(mdev); 4455c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 4456c141ebdaSPhilipp Reisner rcu_read_lock(); 4457c141ebdaSPhilipp Reisner } 4458c141ebdaSPhilipp Reisner rcu_read_unlock(); 4459c141ebdaSPhilipp Reisner 446012038a3aSPhilipp Reisner if (!list_empty(&tconn->current_epoch->list)) 446112038a3aSPhilipp Reisner conn_err(tconn, "ASSERTION FAILED: tconn->current_epoch->list not empty\n"); 446212038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 446312038a3aSPhilipp Reisner atomic_set(&tconn->current_epoch->epoch_size, 0); 4464b6dd1a89SLars Ellenberg tconn->send.seen_any_write_yet = false; 446512038a3aSPhilipp Reisner 4466360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4467360cc740SPhilipp Reisner 4468cb703454SPhilipp Reisner if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN) 4469cb703454SPhilipp Reisner conn_try_outdate_peer_async(tconn); 4470cb703454SPhilipp Reisner 4471360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4472bbeb641cSPhilipp Reisner oc = tconn->cstate; 4473bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4474376694a0SPhilipp Reisner _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4475bbeb641cSPhilipp Reisner 4476360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4477360cc740SPhilipp Reisner 4478f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4479d9cc6e23SLars Ellenberg conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4480360cc740SPhilipp Reisner } 4481360cc740SPhilipp Reisner 4482c141ebdaSPhilipp Reisner static int drbd_disconnected(struct drbd_conf *mdev) 4483360cc740SPhilipp Reisner { 4484360cc740SPhilipp Reisner unsigned int i; 4485b411b363SPhilipp Reisner 448685719573SPhilipp Reisner /* wait for current activity to cease. */ 448787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4488b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4489b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4490b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 449187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4492b411b363SPhilipp Reisner 4493b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4494b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4495b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4496b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4497b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4498b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4499b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4500b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4501b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4502b411b363SPhilipp Reisner * on the fly. */ 4503b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4504b411b363SPhilipp Reisner mdev->rs_total = 0; 4505b411b363SPhilipp Reisner mdev->rs_failed = 0; 4506b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4507b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4508b411b363SPhilipp Reisner 4509b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4510b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4511b411b363SPhilipp Reisner 4512b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4513b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4514b411b363SPhilipp Reisner * to be "canceled" */ 4515b411b363SPhilipp Reisner drbd_flush_workqueue(mdev); 4516b411b363SPhilipp Reisner 4517a990be46SAndreas Gruenbacher drbd_finish_peer_reqs(mdev); 4518b411b363SPhilipp Reisner 4519d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 4520d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 4521d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 4522d10b4ea3SPhilipp Reisner drbd_flush_workqueue(mdev); 4523d10b4ea3SPhilipp Reisner 452408332d73SLars Ellenberg /* need to do it again, drbd_finish_peer_reqs() may have populated it 452508332d73SLars Ellenberg * again via drbd_try_clear_on_disk_bm(). */ 452608332d73SLars Ellenberg drbd_rs_cancel_all(mdev); 4527b411b363SPhilipp Reisner 4528b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4529b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4530b411b363SPhilipp Reisner 45312aebfabbSPhilipp Reisner if (!drbd_suspended(mdev)) 45322f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4533b411b363SPhilipp Reisner 4534b411b363SPhilipp Reisner drbd_md_sync(mdev); 4535b411b363SPhilipp Reisner 453620ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 453720ceb2b2SLars Ellenberg * if any. */ 453820ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 453920ceb2b2SLars Ellenberg 4540b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4541b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4542b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4543b411b363SPhilipp Reisner * 4544b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4545b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4546b411b363SPhilipp Reisner */ 45477721f567SAndreas Gruenbacher i = drbd_free_peer_reqs(mdev, &mdev->net_ee); 4548b411b363SPhilipp Reisner if (i) 4549b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4550435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4551435f0740SLars Ellenberg if (i) 4552435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4553b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4554b411b363SPhilipp Reisner if (i) 455545bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4556b411b363SPhilipp Reisner 4557b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4558b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4559b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4560b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4561b411b363SPhilipp Reisner 4562360cc740SPhilipp Reisner return 0; 4563b411b363SPhilipp Reisner } 4564b411b363SPhilipp Reisner 4565b411b363SPhilipp Reisner /* 4566b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4567b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4568b411b363SPhilipp Reisner * 4569b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4570b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4571b411b363SPhilipp Reisner * 4572b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4573b411b363SPhilipp Reisner */ 45746038178eSAndreas Gruenbacher static int drbd_send_features(struct drbd_tconn *tconn) 4575b411b363SPhilipp Reisner { 45769f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 45779f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4578b411b363SPhilipp Reisner 45799f5bdc33SAndreas Gruenbacher sock = &tconn->data; 45809f5bdc33SAndreas Gruenbacher p = conn_prepare_command(tconn, sock); 45819f5bdc33SAndreas Gruenbacher if (!p) 4582e8d17b01SAndreas Gruenbacher return -EIO; 4583b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4584b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4585b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 45869f5bdc33SAndreas Gruenbacher return conn_send_command(tconn, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4587b411b363SPhilipp Reisner } 4588b411b363SPhilipp Reisner 4589b411b363SPhilipp Reisner /* 4590b411b363SPhilipp Reisner * return values: 4591b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4592b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4593b411b363SPhilipp Reisner * -1 peer talks different language, 4594b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4595b411b363SPhilipp Reisner */ 45966038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn) 4597b411b363SPhilipp Reisner { 459865d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 4599e658983aSAndreas Gruenbacher struct p_connection_features *p; 4600e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 460177351055SPhilipp Reisner struct packet_info pi; 4602a5c31904SAndreas Gruenbacher int err; 4603b411b363SPhilipp Reisner 46046038178eSAndreas Gruenbacher err = drbd_send_features(tconn); 4605e8d17b01SAndreas Gruenbacher if (err) 4606b411b363SPhilipp Reisner return 0; 4607b411b363SPhilipp Reisner 460869bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 460969bc7bc3SAndreas Gruenbacher if (err) 4610b411b363SPhilipp Reisner return 0; 4611b411b363SPhilipp Reisner 46126038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 46136038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 461477351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4615b411b363SPhilipp Reisner return -1; 4616b411b363SPhilipp Reisner } 4617b411b363SPhilipp Reisner 461877351055SPhilipp Reisner if (pi.size != expect) { 46196038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures length: %u, received: %u\n", 462077351055SPhilipp Reisner expect, pi.size); 4621b411b363SPhilipp Reisner return -1; 4622b411b363SPhilipp Reisner } 4623b411b363SPhilipp Reisner 4624e658983aSAndreas Gruenbacher p = pi.data; 4625e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, p, expect); 4626a5c31904SAndreas Gruenbacher if (err) 4627b411b363SPhilipp Reisner return 0; 4628b411b363SPhilipp Reisner 4629b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4630b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4631b411b363SPhilipp Reisner if (p->protocol_max == 0) 4632b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4633b411b363SPhilipp Reisner 4634b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4635b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4636b411b363SPhilipp Reisner goto incompat; 4637b411b363SPhilipp Reisner 463865d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4639b411b363SPhilipp Reisner 464065d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 464165d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4642b411b363SPhilipp Reisner 4643b411b363SPhilipp Reisner return 1; 4644b411b363SPhilipp Reisner 4645b411b363SPhilipp Reisner incompat: 464665d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4647b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4648b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4649b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4650b411b363SPhilipp Reisner return -1; 4651b411b363SPhilipp Reisner } 4652b411b363SPhilipp Reisner 4653b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 465413e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4655b411b363SPhilipp Reisner { 4656ef57f9e6SPhilipp Reisner conn_err(tconn, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4657ef57f9e6SPhilipp Reisner conn_err(tconn, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4658b10d96cbSJohannes Thoma return -1; 4659b411b363SPhilipp Reisner } 4660b411b363SPhilipp Reisner #else 4661b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4662b10d96cbSJohannes Thoma 4663b10d96cbSJohannes Thoma /* Return value: 4664b10d96cbSJohannes Thoma 1 - auth succeeded, 4665b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4666b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4667b10d96cbSJohannes Thoma */ 4668b10d96cbSJohannes Thoma 466913e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4670b411b363SPhilipp Reisner { 46719f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4672b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4673b411b363SPhilipp Reisner struct scatterlist sg; 4674b411b363SPhilipp Reisner char *response = NULL; 4675b411b363SPhilipp Reisner char *right_response = NULL; 4676b411b363SPhilipp Reisner char *peers_ch = NULL; 467744ed167dSPhilipp Reisner unsigned int key_len; 467844ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4679b411b363SPhilipp Reisner unsigned int resp_size; 4680b411b363SPhilipp Reisner struct hash_desc desc; 468177351055SPhilipp Reisner struct packet_info pi; 468244ed167dSPhilipp Reisner struct net_conf *nc; 468369bc7bc3SAndreas Gruenbacher int err, rv; 4684b411b363SPhilipp Reisner 46859f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 46869f5bdc33SAndreas Gruenbacher 468744ed167dSPhilipp Reisner rcu_read_lock(); 468844ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 468944ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 469044ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 469144ed167dSPhilipp Reisner rcu_read_unlock(); 469244ed167dSPhilipp Reisner 469313e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4694b411b363SPhilipp Reisner desc.flags = 0; 4695b411b363SPhilipp Reisner 469644ed167dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, (u8 *)secret, key_len); 4697b411b363SPhilipp Reisner if (rv) { 469813e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4699b10d96cbSJohannes Thoma rv = -1; 4700b411b363SPhilipp Reisner goto fail; 4701b411b363SPhilipp Reisner } 4702b411b363SPhilipp Reisner 4703b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4704b411b363SPhilipp Reisner 47059f5bdc33SAndreas Gruenbacher sock = &tconn->data; 47069f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 47079f5bdc33SAndreas Gruenbacher rv = 0; 47089f5bdc33SAndreas Gruenbacher goto fail; 47099f5bdc33SAndreas Gruenbacher } 4710e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_CHALLENGE, 0, 47119f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4712b411b363SPhilipp Reisner if (!rv) 4713b411b363SPhilipp Reisner goto fail; 4714b411b363SPhilipp Reisner 471569bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 471669bc7bc3SAndreas Gruenbacher if (err) { 4717b411b363SPhilipp Reisner rv = 0; 4718b411b363SPhilipp Reisner goto fail; 4719b411b363SPhilipp Reisner } 4720b411b363SPhilipp Reisner 472177351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 472213e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 472377351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4724b411b363SPhilipp Reisner rv = 0; 4725b411b363SPhilipp Reisner goto fail; 4726b411b363SPhilipp Reisner } 4727b411b363SPhilipp Reisner 472877351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 472913e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4730b10d96cbSJohannes Thoma rv = -1; 4731b411b363SPhilipp Reisner goto fail; 4732b411b363SPhilipp Reisner } 4733b411b363SPhilipp Reisner 473477351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4735b411b363SPhilipp Reisner if (peers_ch == NULL) { 473613e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4737b10d96cbSJohannes Thoma rv = -1; 4738b411b363SPhilipp Reisner goto fail; 4739b411b363SPhilipp Reisner } 4740b411b363SPhilipp Reisner 4741a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, peers_ch, pi.size); 4742a5c31904SAndreas Gruenbacher if (err) { 4743b411b363SPhilipp Reisner rv = 0; 4744b411b363SPhilipp Reisner goto fail; 4745b411b363SPhilipp Reisner } 4746b411b363SPhilipp Reisner 474713e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4748b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4749b411b363SPhilipp Reisner if (response == NULL) { 475013e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4751b10d96cbSJohannes Thoma rv = -1; 4752b411b363SPhilipp Reisner goto fail; 4753b411b363SPhilipp Reisner } 4754b411b363SPhilipp Reisner 4755b411b363SPhilipp Reisner sg_init_table(&sg, 1); 475677351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4757b411b363SPhilipp Reisner 4758b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4759b411b363SPhilipp Reisner if (rv) { 476013e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4761b10d96cbSJohannes Thoma rv = -1; 4762b411b363SPhilipp Reisner goto fail; 4763b411b363SPhilipp Reisner } 4764b411b363SPhilipp Reisner 47659f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 47669f5bdc33SAndreas Gruenbacher rv = 0; 47679f5bdc33SAndreas Gruenbacher goto fail; 47689f5bdc33SAndreas Gruenbacher } 4769e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_RESPONSE, 0, 47709f5bdc33SAndreas Gruenbacher response, resp_size); 4771b411b363SPhilipp Reisner if (!rv) 4772b411b363SPhilipp Reisner goto fail; 4773b411b363SPhilipp Reisner 477469bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 477569bc7bc3SAndreas Gruenbacher if (err) { 4776b411b363SPhilipp Reisner rv = 0; 4777b411b363SPhilipp Reisner goto fail; 4778b411b363SPhilipp Reisner } 4779b411b363SPhilipp Reisner 478077351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 478113e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 478277351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4783b411b363SPhilipp Reisner rv = 0; 4784b411b363SPhilipp Reisner goto fail; 4785b411b363SPhilipp Reisner } 4786b411b363SPhilipp Reisner 478777351055SPhilipp Reisner if (pi.size != resp_size) { 478813e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4789b411b363SPhilipp Reisner rv = 0; 4790b411b363SPhilipp Reisner goto fail; 4791b411b363SPhilipp Reisner } 4792b411b363SPhilipp Reisner 4793a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, response , resp_size); 4794a5c31904SAndreas Gruenbacher if (err) { 4795b411b363SPhilipp Reisner rv = 0; 4796b411b363SPhilipp Reisner goto fail; 4797b411b363SPhilipp Reisner } 4798b411b363SPhilipp Reisner 4799b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 48002d1ee87dSJulia Lawall if (right_response == NULL) { 480113e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4802b10d96cbSJohannes Thoma rv = -1; 4803b411b363SPhilipp Reisner goto fail; 4804b411b363SPhilipp Reisner } 4805b411b363SPhilipp Reisner 4806b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4807b411b363SPhilipp Reisner 4808b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4809b411b363SPhilipp Reisner if (rv) { 481013e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4811b10d96cbSJohannes Thoma rv = -1; 4812b411b363SPhilipp Reisner goto fail; 4813b411b363SPhilipp Reisner } 4814b411b363SPhilipp Reisner 4815b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4816b411b363SPhilipp Reisner 4817b411b363SPhilipp Reisner if (rv) 481844ed167dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes HMAC\n", 481944ed167dSPhilipp Reisner resp_size); 4820b10d96cbSJohannes Thoma else 4821b10d96cbSJohannes Thoma rv = -1; 4822b411b363SPhilipp Reisner 4823b411b363SPhilipp Reisner fail: 4824b411b363SPhilipp Reisner kfree(peers_ch); 4825b411b363SPhilipp Reisner kfree(response); 4826b411b363SPhilipp Reisner kfree(right_response); 4827b411b363SPhilipp Reisner 4828b411b363SPhilipp Reisner return rv; 4829b411b363SPhilipp Reisner } 4830b411b363SPhilipp Reisner #endif 4831b411b363SPhilipp Reisner 4832b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4833b411b363SPhilipp Reisner { 4834392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4835b411b363SPhilipp Reisner int h; 4836b411b363SPhilipp Reisner 48374d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4838b411b363SPhilipp Reisner 4839b411b363SPhilipp Reisner do { 484081fa2e67SPhilipp Reisner h = conn_connect(tconn); 4841b411b363SPhilipp Reisner if (h == 0) { 484281fa2e67SPhilipp Reisner conn_disconnect(tconn); 484320ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4844b411b363SPhilipp Reisner } 4845b411b363SPhilipp Reisner if (h == -1) { 48464d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4847bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4848b411b363SPhilipp Reisner } 4849b411b363SPhilipp Reisner } while (h == 0); 4850b411b363SPhilipp Reisner 485191fd4dadSPhilipp Reisner if (h > 0) 48524d641dd7SPhilipp Reisner drbdd(tconn); 4853b411b363SPhilipp Reisner 485481fa2e67SPhilipp Reisner conn_disconnect(tconn); 4855b411b363SPhilipp Reisner 48564d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4857b411b363SPhilipp Reisner return 0; 4858b411b363SPhilipp Reisner } 4859b411b363SPhilipp Reisner 4860b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4861b411b363SPhilipp Reisner 4862e05e1e59SAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4863b411b363SPhilipp Reisner { 4864e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4865b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4866b411b363SPhilipp Reisner 4867b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4868fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4869b411b363SPhilipp Reisner } else { 4870fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4871fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4872fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4873fc3b10a4SPhilipp Reisner } 4874fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4875e4f78edeSPhilipp Reisner 48762735a594SAndreas Gruenbacher return 0; 4877fc3b10a4SPhilipp Reisner } 4878e4f78edeSPhilipp Reisner 48791952e916SAndreas Gruenbacher static int got_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4880e4f78edeSPhilipp Reisner { 48811952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4882e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4883e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4884e4f78edeSPhilipp Reisner 48851952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48861952e916SAndreas Gruenbacher if (!mdev) 48872735a594SAndreas Gruenbacher return -EIO; 48881952e916SAndreas Gruenbacher 48894d0fc3fdSPhilipp Reisner if (test_bit(CONN_WD_ST_CHG_REQ, &tconn->flags)) { 48904d0fc3fdSPhilipp Reisner D_ASSERT(tconn->agreed_pro_version < 100); 48914d0fc3fdSPhilipp Reisner return got_conn_RqSReply(tconn, pi); 48924d0fc3fdSPhilipp Reisner } 48934d0fc3fdSPhilipp Reisner 4894e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4895e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4896e4f78edeSPhilipp Reisner } else { 4897e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4898b411b363SPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4899b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4900b411b363SPhilipp Reisner } 4901b411b363SPhilipp Reisner wake_up(&mdev->state_wait); 4902b411b363SPhilipp Reisner 49032735a594SAndreas Gruenbacher return 0; 4904b411b363SPhilipp Reisner } 4905b411b363SPhilipp Reisner 4906e05e1e59SAndreas Gruenbacher static int got_Ping(struct drbd_tconn *tconn, struct packet_info *pi) 4907b411b363SPhilipp Reisner { 49082735a594SAndreas Gruenbacher return drbd_send_ping_ack(tconn); 4909b411b363SPhilipp Reisner 4910b411b363SPhilipp Reisner } 4911b411b363SPhilipp Reisner 4912e05e1e59SAndreas Gruenbacher static int got_PingAck(struct drbd_tconn *tconn, struct packet_info *pi) 4913b411b363SPhilipp Reisner { 4914b411b363SPhilipp Reisner /* restore idle timeout */ 49152a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 49162a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 49172a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4918b411b363SPhilipp Reisner 49192735a594SAndreas Gruenbacher return 0; 4920b411b363SPhilipp Reisner } 4921b411b363SPhilipp Reisner 49221952e916SAndreas Gruenbacher static int got_IsInSync(struct drbd_tconn *tconn, struct packet_info *pi) 4923b411b363SPhilipp Reisner { 49241952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4925e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4926b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4927b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4928b411b363SPhilipp Reisner 49291952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49301952e916SAndreas Gruenbacher if (!mdev) 49312735a594SAndreas Gruenbacher return -EIO; 49321952e916SAndreas Gruenbacher 493331890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4934b411b363SPhilipp Reisner 4935b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4936b411b363SPhilipp Reisner 49371d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4938b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4939b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4940b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4941b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 49421d53f09eSLars Ellenberg put_ldev(mdev); 49431d53f09eSLars Ellenberg } 4944b411b363SPhilipp Reisner dec_rs_pending(mdev); 4945778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4946b411b363SPhilipp Reisner 49472735a594SAndreas Gruenbacher return 0; 4948b411b363SPhilipp Reisner } 4949b411b363SPhilipp Reisner 4950bc9c5c41SAndreas Gruenbacher static int 4951bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4952bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4953bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4954b411b363SPhilipp Reisner { 4955b411b363SPhilipp Reisner struct drbd_request *req; 4956b411b363SPhilipp Reisner struct bio_and_error m; 4957b411b363SPhilipp Reisner 495887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4959bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4960b411b363SPhilipp Reisner if (unlikely(!req)) { 496187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 496285997675SAndreas Gruenbacher return -EIO; 4963b411b363SPhilipp Reisner } 4964b411b363SPhilipp Reisner __req_mod(req, what, &m); 496587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4966b411b363SPhilipp Reisner 4967b411b363SPhilipp Reisner if (m.bio) 4968b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 496985997675SAndreas Gruenbacher return 0; 4970b411b363SPhilipp Reisner } 4971b411b363SPhilipp Reisner 49721952e916SAndreas Gruenbacher static int got_BlockAck(struct drbd_tconn *tconn, struct packet_info *pi) 4973b411b363SPhilipp Reisner { 49741952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4975e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4976b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4977b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4978b411b363SPhilipp Reisner enum drbd_req_event what; 4979b411b363SPhilipp Reisner 49801952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49811952e916SAndreas Gruenbacher if (!mdev) 49822735a594SAndreas Gruenbacher return -EIO; 49831952e916SAndreas Gruenbacher 4984b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4985b411b363SPhilipp Reisner 4986579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4987b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4988b411b363SPhilipp Reisner dec_rs_pending(mdev); 49892735a594SAndreas Gruenbacher return 0; 4990b411b363SPhilipp Reisner } 4991e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4992b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 49938554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4994b411b363SPhilipp Reisner break; 4995b411b363SPhilipp Reisner case P_WRITE_ACK: 49968554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4997b411b363SPhilipp Reisner break; 4998b411b363SPhilipp Reisner case P_RECV_ACK: 49998554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 5000b411b363SPhilipp Reisner break; 5001d4dabbe2SLars Ellenberg case P_SUPERSEDED: 5002d4dabbe2SLars Ellenberg what = CONFLICT_RESOLVED; 50037be8da07SAndreas Gruenbacher break; 50047be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 50057be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5006b411b363SPhilipp Reisner break; 5007b411b363SPhilipp Reisner default: 50082735a594SAndreas Gruenbacher BUG(); 5009b411b363SPhilipp Reisner } 5010b411b363SPhilipp Reisner 5011b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 5012bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 5013bc9c5c41SAndreas Gruenbacher what, false); 5014b411b363SPhilipp Reisner } 5015b411b363SPhilipp Reisner 50161952e916SAndreas Gruenbacher static int got_NegAck(struct drbd_tconn *tconn, struct packet_info *pi) 5017b411b363SPhilipp Reisner { 50181952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5019e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5020b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 50212deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 502285997675SAndreas Gruenbacher int err; 5023b411b363SPhilipp Reisner 50241952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50251952e916SAndreas Gruenbacher if (!mdev) 50262735a594SAndreas Gruenbacher return -EIO; 5027b411b363SPhilipp Reisner 5028b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5029b411b363SPhilipp Reisner 5030579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5031b411b363SPhilipp Reisner dec_rs_pending(mdev); 5032b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 50332735a594SAndreas Gruenbacher return 0; 5034b411b363SPhilipp Reisner } 50352deb8336SPhilipp Reisner 503685997675SAndreas Gruenbacher err = validate_req_change_req_state(mdev, p->block_id, sector, 5037bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 5038303d1448SPhilipp Reisner NEG_ACKED, true); 503985997675SAndreas Gruenbacher if (err) { 50402deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 50412deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5042c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 50432deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 50442deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 50452deb8336SPhilipp Reisner drbd_set_out_of_sync(mdev, sector, size); 50462deb8336SPhilipp Reisner } 50472735a594SAndreas Gruenbacher return 0; 5048b411b363SPhilipp Reisner } 5049b411b363SPhilipp Reisner 50501952e916SAndreas Gruenbacher static int got_NegDReply(struct drbd_tconn *tconn, struct packet_info *pi) 5051b411b363SPhilipp Reisner { 50521952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5053e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5054b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5055b411b363SPhilipp Reisner 50561952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50571952e916SAndreas Gruenbacher if (!mdev) 50582735a594SAndreas Gruenbacher return -EIO; 50591952e916SAndreas Gruenbacher 5060b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 50617be8da07SAndreas Gruenbacher 5062380207d0SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u.\n", 5063b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5064b411b363SPhilipp Reisner 5065b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 5066bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 50678554df1cSAndreas Gruenbacher NEG_ACKED, false); 5068b411b363SPhilipp Reisner } 5069b411b363SPhilipp Reisner 50701952e916SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_tconn *tconn, struct packet_info *pi) 5071b411b363SPhilipp Reisner { 50721952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5073b411b363SPhilipp Reisner sector_t sector; 5074b411b363SPhilipp Reisner int size; 5075e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 50761952e916SAndreas Gruenbacher 50771952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50781952e916SAndreas Gruenbacher if (!mdev) 50792735a594SAndreas Gruenbacher return -EIO; 5080b411b363SPhilipp Reisner 5081b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5082b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5083b411b363SPhilipp Reisner 5084b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5085b411b363SPhilipp Reisner 5086b411b363SPhilipp Reisner dec_rs_pending(mdev); 5087b411b363SPhilipp Reisner 5088b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 5089b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 5090e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5091d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5092b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 5093d612d309SPhilipp Reisner case P_RS_CANCEL: 5094d612d309SPhilipp Reisner break; 5095d612d309SPhilipp Reisner default: 50962735a594SAndreas Gruenbacher BUG(); 5097d612d309SPhilipp Reisner } 5098b411b363SPhilipp Reisner put_ldev(mdev); 5099b411b363SPhilipp Reisner } 5100b411b363SPhilipp Reisner 51012735a594SAndreas Gruenbacher return 0; 5102b411b363SPhilipp Reisner } 5103b411b363SPhilipp Reisner 51041952e916SAndreas Gruenbacher static int got_BarrierAck(struct drbd_tconn *tconn, struct packet_info *pi) 5105b411b363SPhilipp Reisner { 5106e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 51079ed57dcbSLars Ellenberg struct drbd_conf *mdev; 51089ed57dcbSLars Ellenberg int vnr; 5109b411b363SPhilipp Reisner 51109ed57dcbSLars Ellenberg tl_release(tconn, p->barrier, be32_to_cpu(p->set_size)); 5111b411b363SPhilipp Reisner 51129ed57dcbSLars Ellenberg rcu_read_lock(); 51139ed57dcbSLars Ellenberg idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5114c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 5115c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 511636baf611SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->flags)) { 5117370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 5118370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 5119c4752ef1SPhilipp Reisner } 51209ed57dcbSLars Ellenberg } 51219ed57dcbSLars Ellenberg rcu_read_unlock(); 5122c4752ef1SPhilipp Reisner 51232735a594SAndreas Gruenbacher return 0; 5124b411b363SPhilipp Reisner } 5125b411b363SPhilipp Reisner 51261952e916SAndreas Gruenbacher static int got_OVResult(struct drbd_tconn *tconn, struct packet_info *pi) 5127b411b363SPhilipp Reisner { 51281952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5129e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5130b411b363SPhilipp Reisner struct drbd_work *w; 5131b411b363SPhilipp Reisner sector_t sector; 5132b411b363SPhilipp Reisner int size; 5133b411b363SPhilipp Reisner 51341952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 51351952e916SAndreas Gruenbacher if (!mdev) 51362735a594SAndreas Gruenbacher return -EIO; 51371952e916SAndreas Gruenbacher 5138b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5139b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5140b411b363SPhilipp Reisner 5141b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5142b411b363SPhilipp Reisner 5143b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 51448f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 5145b411b363SPhilipp Reisner else 51468f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5147b411b363SPhilipp Reisner 51481d53f09eSLars Ellenberg if (!get_ldev(mdev)) 51492735a594SAndreas Gruenbacher return 0; 51501d53f09eSLars Ellenberg 5151b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 5152b411b363SPhilipp Reisner dec_rs_pending(mdev); 5153b411b363SPhilipp Reisner 5154ea5442afSLars Ellenberg --mdev->ov_left; 5155ea5442afSLars Ellenberg 5156ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5157ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 5158ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 5159ea5442afSLars Ellenberg 5160ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 5161b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 5162b411b363SPhilipp Reisner if (w) { 5163b411b363SPhilipp Reisner w->cb = w_ov_finished; 5164a21e9298SPhilipp Reisner w->mdev = mdev; 5165d5b27b01SLars Ellenberg drbd_queue_work(&mdev->tconn->sender_work, w); 5166b411b363SPhilipp Reisner } else { 5167b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 51688f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5169b411b363SPhilipp Reisner drbd_resync_finished(mdev); 5170b411b363SPhilipp Reisner } 5171b411b363SPhilipp Reisner } 51721d53f09eSLars Ellenberg put_ldev(mdev); 51732735a594SAndreas Gruenbacher return 0; 5174b411b363SPhilipp Reisner } 5175b411b363SPhilipp Reisner 51761952e916SAndreas Gruenbacher static int got_skip(struct drbd_tconn *tconn, struct packet_info *pi) 51770ced55a3SPhilipp Reisner { 51782735a594SAndreas Gruenbacher return 0; 51790ced55a3SPhilipp Reisner } 51800ced55a3SPhilipp Reisner 5181a990be46SAndreas Gruenbacher static int tconn_finish_peer_reqs(struct drbd_tconn *tconn) 518232862ec7SPhilipp Reisner { 5183082a3439SPhilipp Reisner struct drbd_conf *mdev; 5184c141ebdaSPhilipp Reisner int vnr, not_empty = 0; 518532862ec7SPhilipp Reisner 518632862ec7SPhilipp Reisner do { 518732862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 518832862ec7SPhilipp Reisner flush_signals(current); 5189c141ebdaSPhilipp Reisner 5190c141ebdaSPhilipp Reisner rcu_read_lock(); 5191c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5192c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 5193c141ebdaSPhilipp Reisner rcu_read_unlock(); 5194d3fcb490SPhilipp Reisner if (drbd_finish_peer_reqs(mdev)) { 5195c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5196c141ebdaSPhilipp Reisner return 1; 5197082a3439SPhilipp Reisner } 5198c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5199c141ebdaSPhilipp Reisner rcu_read_lock(); 5200d3fcb490SPhilipp Reisner } 520132862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 5202082a3439SPhilipp Reisner 5203082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 5204c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5205082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 5206082a3439SPhilipp Reisner if (not_empty) 5207082a3439SPhilipp Reisner break; 5208082a3439SPhilipp Reisner } 5209082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 5210c141ebdaSPhilipp Reisner rcu_read_unlock(); 521132862ec7SPhilipp Reisner } while (not_empty); 521232862ec7SPhilipp Reisner 521332862ec7SPhilipp Reisner return 0; 5214b411b363SPhilipp Reisner } 5215b411b363SPhilipp Reisner 5216b411b363SPhilipp Reisner struct asender_cmd { 5217b411b363SPhilipp Reisner size_t pkt_size; 52181952e916SAndreas Gruenbacher int (*fn)(struct drbd_tconn *tconn, struct packet_info *); 5219b411b363SPhilipp Reisner }; 5220b411b363SPhilipp Reisner 5221b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 5222e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5223e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 5224b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5225b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5226b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5227d4dabbe2SLars Ellenberg [P_SUPERSEDED] = { sizeof(struct p_block_ack), got_BlockAck }, 5228b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 5229b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 5230b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 5231b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 5232b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 5233b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 5234b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 523502918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 5236d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 52371952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 52381952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 5239b411b363SPhilipp Reisner }; 5240b411b363SPhilipp Reisner 5241b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5242b411b363SPhilipp Reisner { 5243392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 5244b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 524577351055SPhilipp Reisner struct packet_info pi; 5246257d0af6SPhilipp Reisner int rv; 5247e658983aSAndreas Gruenbacher void *buf = tconn->meta.rbuf; 5248b411b363SPhilipp Reisner int received = 0; 524952b061a4SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 525052b061a4SAndreas Gruenbacher int expect = header_size; 525144ed167dSPhilipp Reisner bool ping_timeout_active = false; 525244ed167dSPhilipp Reisner struct net_conf *nc; 5253bb77d34eSAndreas Gruenbacher int ping_timeo, tcp_cork, ping_int; 52543990e04dSPhilipp Reisner struct sched_param param = { .sched_priority = 2 }; 5255b411b363SPhilipp Reisner 52563990e04dSPhilipp Reisner rv = sched_setscheduler(current, SCHED_RR, ¶m); 52573990e04dSPhilipp Reisner if (rv < 0) 52583990e04dSPhilipp Reisner conn_err(tconn, "drbd_asender: ERROR set priority, ret=%d\n", rv); 5259b411b363SPhilipp Reisner 5260e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 526180822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 526244ed167dSPhilipp Reisner 526344ed167dSPhilipp Reisner rcu_read_lock(); 526444ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 526544ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 5266bb77d34eSAndreas Gruenbacher tcp_cork = nc->tcp_cork; 526744ed167dSPhilipp Reisner ping_int = nc->ping_int; 526844ed167dSPhilipp Reisner rcu_read_unlock(); 526944ed167dSPhilipp Reisner 527032862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 5271a17647aaSAndreas Gruenbacher if (drbd_send_ping(tconn)) { 527232862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 5273841ce241SAndreas Gruenbacher goto reconnect; 5274841ce241SAndreas Gruenbacher } 527544ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 527644ed167dSPhilipp Reisner ping_timeout_active = true; 5277b411b363SPhilipp Reisner } 5278b411b363SPhilipp Reisner 527932862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 528032862ec7SPhilipp Reisner much to send */ 5281bb77d34eSAndreas Gruenbacher if (tcp_cork) 528232862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 5283a990be46SAndreas Gruenbacher if (tconn_finish_peer_reqs(tconn)) { 5284a990be46SAndreas Gruenbacher conn_err(tconn, "tconn_finish_peer_reqs() failed\n"); 5285b411b363SPhilipp Reisner goto reconnect; 5286b411b363SPhilipp Reisner } 5287b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 5288bb77d34eSAndreas Gruenbacher if (tcp_cork) 528932862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 5290b411b363SPhilipp Reisner 5291b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5292b411b363SPhilipp Reisner if (signal_pending(current)) 5293b411b363SPhilipp Reisner continue; 5294b411b363SPhilipp Reisner 529532862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 529632862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5297b411b363SPhilipp Reisner 5298b411b363SPhilipp Reisner flush_signals(current); 5299b411b363SPhilipp Reisner 5300b411b363SPhilipp Reisner /* Note: 5301b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5302b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5303b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5304b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5305b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5306b411b363SPhilipp Reisner * rv == expected: full header or command 5307b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5308b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5309b411b363SPhilipp Reisner */ 5310b411b363SPhilipp Reisner if (likely(rv > 0)) { 5311b411b363SPhilipp Reisner received += rv; 5312b411b363SPhilipp Reisner buf += rv; 5313b411b363SPhilipp Reisner } else if (rv == 0) { 5314b66623e3SPhilipp Reisner if (test_bit(DISCONNECT_SENT, &tconn->flags)) { 5315b66623e3SPhilipp Reisner long t; 5316b66623e3SPhilipp Reisner rcu_read_lock(); 5317b66623e3SPhilipp Reisner t = rcu_dereference(tconn->net_conf)->ping_timeo * HZ/10; 5318b66623e3SPhilipp Reisner rcu_read_unlock(); 5319b66623e3SPhilipp Reisner 5320b66623e3SPhilipp Reisner t = wait_event_timeout(tconn->ping_wait, 5321b66623e3SPhilipp Reisner tconn->cstate < C_WF_REPORT_PARAMS, 5322b66623e3SPhilipp Reisner t); 5323599377acSPhilipp Reisner if (t) 5324599377acSPhilipp Reisner break; 5325599377acSPhilipp Reisner } 532632862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 5327b411b363SPhilipp Reisner goto reconnect; 5328b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5329cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5330cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 533132862ec7SPhilipp Reisner if (time_after(tconn->last_received, 533232862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 5333cb6518cbSLars Ellenberg continue; 5334f36af18cSLars Ellenberg if (ping_timeout_active) { 533532862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 5336b411b363SPhilipp Reisner goto reconnect; 5337b411b363SPhilipp Reisner } 533832862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 5339b411b363SPhilipp Reisner continue; 5340b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5341b411b363SPhilipp Reisner continue; 5342b411b363SPhilipp Reisner } else { 534332862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 5344b411b363SPhilipp Reisner goto reconnect; 5345b411b363SPhilipp Reisner } 5346b411b363SPhilipp Reisner 5347b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5348e658983aSAndreas Gruenbacher if (decode_header(tconn, tconn->meta.rbuf, &pi)) 5349b411b363SPhilipp Reisner goto reconnect; 53507201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 53511952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 53522fcb8f30SAndreas Gruenbacher conn_err(tconn, "Unexpected meta packet %s (0x%04x)\n", 53532fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5354b411b363SPhilipp Reisner goto disconnect; 5355b411b363SPhilipp Reisner } 5356e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 535752b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 535832862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 535977351055SPhilipp Reisner pi.cmd, pi.size); 5360b411b363SPhilipp Reisner goto reconnect; 5361b411b363SPhilipp Reisner } 5362257d0af6SPhilipp Reisner } 5363b411b363SPhilipp Reisner if (received == expect) { 53642735a594SAndreas Gruenbacher bool err; 5365a4fbda8eSPhilipp Reisner 53662735a594SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 53672735a594SAndreas Gruenbacher if (err) { 53681952e916SAndreas Gruenbacher conn_err(tconn, "%pf failed\n", cmd->fn); 5369b411b363SPhilipp Reisner goto reconnect; 53701952e916SAndreas Gruenbacher } 5371b411b363SPhilipp Reisner 5372a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 5373f36af18cSLars Ellenberg 537444ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 537544ed167dSPhilipp Reisner /* restore idle timeout */ 537644ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 537744ed167dSPhilipp Reisner ping_timeout_active = false; 537844ed167dSPhilipp Reisner } 5379b411b363SPhilipp Reisner 5380e658983aSAndreas Gruenbacher buf = tconn->meta.rbuf; 5381b411b363SPhilipp Reisner received = 0; 538252b061a4SAndreas Gruenbacher expect = header_size; 5383b411b363SPhilipp Reisner cmd = NULL; 5384b411b363SPhilipp Reisner } 5385b411b363SPhilipp Reisner } 5386b411b363SPhilipp Reisner 5387b411b363SPhilipp Reisner if (0) { 5388b411b363SPhilipp Reisner reconnect: 5389bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 539019fffd7bSPhilipp Reisner conn_md_sync(tconn); 5391b411b363SPhilipp Reisner } 5392b411b363SPhilipp Reisner if (0) { 5393b411b363SPhilipp Reisner disconnect: 5394bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 5395b411b363SPhilipp Reisner } 539632862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5397b411b363SPhilipp Reisner 539832862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 5399b411b363SPhilipp Reisner 5400b411b363SPhilipp Reisner return 0; 5401b411b363SPhilipp Reisner } 5402