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 29881a3537aSLars Ellenberg if (page == NULL) 29981a3537aSLars Ellenberg return; 30081a3537aSLars 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; 33781a3537aSLars 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 35081a3537aSLars 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; 35481a3537aSLars 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; 36153840641SAndreas Gruenbacher 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 409a990be46SAndreas Gruenbacher /* 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 mm_segment_t oldfs; 494b411b363SPhilipp Reisner struct kvec iov = { 495b411b363SPhilipp Reisner .iov_base = buf, 496b411b363SPhilipp Reisner .iov_len = size, 497b411b363SPhilipp Reisner }; 498b411b363SPhilipp Reisner struct msghdr msg = { 499b411b363SPhilipp Reisner .msg_iovlen = 1, 500b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 501b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 502b411b363SPhilipp Reisner }; 503b411b363SPhilipp Reisner int rv; 504b411b363SPhilipp Reisner 505b411b363SPhilipp Reisner oldfs = get_fs(); 506b411b363SPhilipp Reisner set_fs(KERNEL_DS); 507de0ff338SPhilipp Reisner rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags); 508155522dfSPhilipp Reisner set_fs(oldfs); 509b411b363SPhilipp Reisner 510b411b363SPhilipp Reisner if (rv < 0) { 511b411b363SPhilipp Reisner if (rv == -ECONNRESET) 512de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 513b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 514de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 515b411b363SPhilipp Reisner } else if (rv == 0) { 516b66623e3SPhilipp Reisner if (test_bit(DISCONNECT_SENT, &tconn->flags)) { 517b66623e3SPhilipp Reisner long t; 518b66623e3SPhilipp Reisner rcu_read_lock(); 519b66623e3SPhilipp Reisner t = rcu_dereference(tconn->net_conf)->ping_timeo * HZ/10; 520b66623e3SPhilipp Reisner rcu_read_unlock(); 521b66623e3SPhilipp Reisner 522b66623e3SPhilipp Reisner t = wait_event_timeout(tconn->ping_wait, tconn->cstate < C_WF_REPORT_PARAMS, t); 523b66623e3SPhilipp Reisner 524b66623e3SPhilipp Reisner if (t) 525b66623e3SPhilipp Reisner goto out; 526b66623e3SPhilipp Reisner } 527b66623e3SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 528b66623e3SPhilipp Reisner } 529b66623e3SPhilipp Reisner 530b411b363SPhilipp Reisner if (rv != size) 531bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 532b411b363SPhilipp Reisner 533b66623e3SPhilipp Reisner out: 534b411b363SPhilipp Reisner return rv; 535b411b363SPhilipp Reisner } 536b411b363SPhilipp Reisner 537c6967746SAndreas Gruenbacher static int drbd_recv_all(struct drbd_tconn *tconn, void *buf, size_t size) 538c6967746SAndreas Gruenbacher { 539c6967746SAndreas Gruenbacher int err; 540c6967746SAndreas Gruenbacher 541c6967746SAndreas Gruenbacher err = drbd_recv(tconn, buf, size); 542c6967746SAndreas Gruenbacher if (err != size) { 543c6967746SAndreas Gruenbacher if (err >= 0) 544c6967746SAndreas Gruenbacher err = -EIO; 545c6967746SAndreas Gruenbacher } else 546c6967746SAndreas Gruenbacher err = 0; 547c6967746SAndreas Gruenbacher return err; 548c6967746SAndreas Gruenbacher } 549c6967746SAndreas Gruenbacher 550a5c31904SAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_tconn *tconn, void *buf, size_t size) 551a5c31904SAndreas Gruenbacher { 552a5c31904SAndreas Gruenbacher int err; 553a5c31904SAndreas Gruenbacher 554a5c31904SAndreas Gruenbacher err = drbd_recv_all(tconn, buf, size); 555a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 556a5c31904SAndreas Gruenbacher conn_warn(tconn, "short read (expected size %d)\n", (int)size); 557a5c31904SAndreas Gruenbacher return err; 558a5c31904SAndreas Gruenbacher } 559a5c31904SAndreas Gruenbacher 5605dbf1673SLars Ellenberg /* quoting tcp(7): 5615dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5625dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5635dbf1673SLars Ellenberg * This is our wrapper to do so. 5645dbf1673SLars Ellenberg */ 5655dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5665dbf1673SLars Ellenberg unsigned int rcv) 5675dbf1673SLars Ellenberg { 5685dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5695dbf1673SLars Ellenberg if (snd) { 5705dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5715dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5725dbf1673SLars Ellenberg } 5735dbf1673SLars Ellenberg if (rcv) { 5745dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5755dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5765dbf1673SLars Ellenberg } 5775dbf1673SLars Ellenberg } 5785dbf1673SLars Ellenberg 579eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 580b411b363SPhilipp Reisner { 581b411b363SPhilipp Reisner const char *what; 582b411b363SPhilipp Reisner struct socket *sock; 583b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 58444ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 58544ed167dSPhilipp Reisner struct net_conf *nc; 58644ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 58769ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 588b411b363SPhilipp Reisner int disconnect_on_error = 1; 589b411b363SPhilipp Reisner 59044ed167dSPhilipp Reisner rcu_read_lock(); 59144ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 59244ed167dSPhilipp Reisner if (!nc) { 59344ed167dSPhilipp Reisner rcu_read_unlock(); 594b411b363SPhilipp Reisner return NULL; 59544ed167dSPhilipp Reisner } 59644ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 59744ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 59869ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 599089c075dSAndreas Gruenbacher rcu_read_unlock(); 60044ed167dSPhilipp Reisner 601089c075dSAndreas Gruenbacher my_addr_len = min_t(int, tconn->my_addr_len, sizeof(src_in6)); 602089c075dSAndreas Gruenbacher memcpy(&src_in6, &tconn->my_addr, my_addr_len); 60344ed167dSPhilipp Reisner 604089c075dSAndreas Gruenbacher if (((struct sockaddr *)&tconn->my_addr)->sa_family == AF_INET6) 60544ed167dSPhilipp Reisner src_in6.sin6_port = 0; 60644ed167dSPhilipp Reisner else 60744ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 60844ed167dSPhilipp Reisner 609089c075dSAndreas Gruenbacher peer_addr_len = min_t(int, tconn->peer_addr_len, sizeof(src_in6)); 610089c075dSAndreas Gruenbacher memcpy(&peer_in6, &tconn->peer_addr, peer_addr_len); 611b411b363SPhilipp Reisner 612b411b363SPhilipp Reisner what = "sock_create_kern"; 61344ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family, 614b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 615b411b363SPhilipp Reisner if (err < 0) { 616b411b363SPhilipp Reisner sock = NULL; 617b411b363SPhilipp Reisner goto out; 618b411b363SPhilipp Reisner } 619b411b363SPhilipp Reisner 620b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 62169ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 62244ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 623b411b363SPhilipp Reisner 624b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 625b411b363SPhilipp Reisner * for the outgoing connections. 626b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 627b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 628b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 629b411b363SPhilipp Reisner * a free one dynamically. 630b411b363SPhilipp Reisner */ 631b411b363SPhilipp Reisner what = "bind before connect"; 63244ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 633b411b363SPhilipp Reisner if (err < 0) 634b411b363SPhilipp Reisner goto out; 635b411b363SPhilipp Reisner 636b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 637b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 638b411b363SPhilipp Reisner disconnect_on_error = 0; 639b411b363SPhilipp Reisner what = "connect"; 64044ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 641b411b363SPhilipp Reisner 642b411b363SPhilipp Reisner out: 643b411b363SPhilipp Reisner if (err < 0) { 644b411b363SPhilipp Reisner if (sock) { 645b411b363SPhilipp Reisner sock_release(sock); 646b411b363SPhilipp Reisner sock = NULL; 647b411b363SPhilipp Reisner } 648b411b363SPhilipp Reisner switch (-err) { 649b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 650b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 651b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 652b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 653b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 654b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 655b411b363SPhilipp Reisner disconnect_on_error = 0; 656b411b363SPhilipp Reisner break; 657b411b363SPhilipp Reisner default: 658eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 659b411b363SPhilipp Reisner } 660b411b363SPhilipp Reisner if (disconnect_on_error) 661bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 662b411b363SPhilipp Reisner } 66344ed167dSPhilipp Reisner 664b411b363SPhilipp Reisner return sock; 665b411b363SPhilipp Reisner } 666b411b363SPhilipp Reisner 6677a426fd8SPhilipp Reisner struct accept_wait_data { 6687a426fd8SPhilipp Reisner struct drbd_tconn *tconn; 6697a426fd8SPhilipp Reisner struct socket *s_listen; 6707a426fd8SPhilipp Reisner struct completion door_bell; 6717a426fd8SPhilipp Reisner void (*original_sk_state_change)(struct sock *sk); 6727a426fd8SPhilipp Reisner 6737a426fd8SPhilipp Reisner }; 6747a426fd8SPhilipp Reisner 675715306f6SAndreas Gruenbacher static void drbd_incoming_connection(struct sock *sk) 6767a426fd8SPhilipp Reisner { 6777a426fd8SPhilipp Reisner struct accept_wait_data *ad = sk->sk_user_data; 678715306f6SAndreas Gruenbacher void (*state_change)(struct sock *sk); 6797a426fd8SPhilipp Reisner 680715306f6SAndreas Gruenbacher state_change = ad->original_sk_state_change; 681715306f6SAndreas Gruenbacher if (sk->sk_state == TCP_ESTABLISHED) 6827a426fd8SPhilipp Reisner complete(&ad->door_bell); 683715306f6SAndreas Gruenbacher state_change(sk); 6847a426fd8SPhilipp Reisner } 6857a426fd8SPhilipp Reisner 6867a426fd8SPhilipp Reisner static int prepare_listen_socket(struct drbd_tconn *tconn, struct accept_wait_data *ad) 687b411b363SPhilipp Reisner { 6881f3e509bSPhilipp Reisner int err, sndbuf_size, rcvbuf_size, my_addr_len; 68944ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 6901f3e509bSPhilipp Reisner struct socket *s_listen; 69144ed167dSPhilipp Reisner struct net_conf *nc; 692b411b363SPhilipp Reisner const char *what; 693b411b363SPhilipp Reisner 69444ed167dSPhilipp Reisner rcu_read_lock(); 69544ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 69644ed167dSPhilipp Reisner if (!nc) { 69744ed167dSPhilipp Reisner rcu_read_unlock(); 6987a426fd8SPhilipp Reisner return -EIO; 69944ed167dSPhilipp Reisner } 70044ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 70144ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 70244ed167dSPhilipp Reisner rcu_read_unlock(); 703b411b363SPhilipp Reisner 704089c075dSAndreas Gruenbacher my_addr_len = min_t(int, tconn->my_addr_len, sizeof(struct sockaddr_in6)); 705089c075dSAndreas Gruenbacher memcpy(&my_addr, &tconn->my_addr, my_addr_len); 706089c075dSAndreas Gruenbacher 707b411b363SPhilipp Reisner what = "sock_create_kern"; 70844ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family, 709b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 710b411b363SPhilipp Reisner if (err) { 711b411b363SPhilipp Reisner s_listen = NULL; 712b411b363SPhilipp Reisner goto out; 713b411b363SPhilipp Reisner } 714b411b363SPhilipp Reisner 715b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 71644ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 717b411b363SPhilipp Reisner 718b411b363SPhilipp Reisner what = "bind before listen"; 71944ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 720b411b363SPhilipp Reisner if (err < 0) 721b411b363SPhilipp Reisner goto out; 722b411b363SPhilipp Reisner 7237a426fd8SPhilipp Reisner ad->s_listen = s_listen; 7247a426fd8SPhilipp Reisner write_lock_bh(&s_listen->sk->sk_callback_lock); 7257a426fd8SPhilipp Reisner ad->original_sk_state_change = s_listen->sk->sk_state_change; 726715306f6SAndreas Gruenbacher s_listen->sk->sk_state_change = drbd_incoming_connection; 7277a426fd8SPhilipp Reisner s_listen->sk->sk_user_data = ad; 7287a426fd8SPhilipp Reisner write_unlock_bh(&s_listen->sk->sk_callback_lock); 7297a426fd8SPhilipp Reisner 7302820fd39SPhilipp Reisner what = "listen"; 7312820fd39SPhilipp Reisner err = s_listen->ops->listen(s_listen, 5); 7322820fd39SPhilipp Reisner if (err < 0) 7332820fd39SPhilipp Reisner goto out; 7342820fd39SPhilipp Reisner 7357a426fd8SPhilipp Reisner return 0; 7361f3e509bSPhilipp Reisner out: 7371f3e509bSPhilipp Reisner if (s_listen) 7381f3e509bSPhilipp Reisner sock_release(s_listen); 7391f3e509bSPhilipp Reisner if (err < 0) { 7401f3e509bSPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7411f3e509bSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 7421f3e509bSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 7431f3e509bSPhilipp Reisner } 7441f3e509bSPhilipp Reisner } 7451f3e509bSPhilipp Reisner 7467a426fd8SPhilipp Reisner return -EIO; 7471f3e509bSPhilipp Reisner } 7481f3e509bSPhilipp Reisner 749715306f6SAndreas Gruenbacher static void unregister_state_change(struct sock *sk, struct accept_wait_data *ad) 750715306f6SAndreas Gruenbacher { 751715306f6SAndreas Gruenbacher write_lock_bh(&sk->sk_callback_lock); 752715306f6SAndreas Gruenbacher sk->sk_state_change = ad->original_sk_state_change; 753715306f6SAndreas Gruenbacher sk->sk_user_data = NULL; 754715306f6SAndreas Gruenbacher write_unlock_bh(&sk->sk_callback_lock); 755715306f6SAndreas Gruenbacher } 756715306f6SAndreas Gruenbacher 7577a426fd8SPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn, struct accept_wait_data *ad) 7581f3e509bSPhilipp Reisner { 7591f3e509bSPhilipp Reisner int timeo, connect_int, err = 0; 7601f3e509bSPhilipp Reisner struct socket *s_estab = NULL; 7611f3e509bSPhilipp Reisner struct net_conf *nc; 7621f3e509bSPhilipp Reisner 7631f3e509bSPhilipp Reisner rcu_read_lock(); 7641f3e509bSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 7651f3e509bSPhilipp Reisner if (!nc) { 7661f3e509bSPhilipp Reisner rcu_read_unlock(); 7671f3e509bSPhilipp Reisner return NULL; 7681f3e509bSPhilipp Reisner } 7691f3e509bSPhilipp Reisner connect_int = nc->connect_int; 7701f3e509bSPhilipp Reisner rcu_read_unlock(); 7711f3e509bSPhilipp Reisner 7721f3e509bSPhilipp Reisner timeo = connect_int * HZ; 7731f3e509bSPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 7741f3e509bSPhilipp Reisner 7757a426fd8SPhilipp Reisner err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); 7767a426fd8SPhilipp Reisner if (err <= 0) 7777a426fd8SPhilipp Reisner return NULL; 7781f3e509bSPhilipp Reisner 7797a426fd8SPhilipp Reisner err = kernel_accept(ad->s_listen, &s_estab, 0); 780b411b363SPhilipp Reisner if (err < 0) { 781b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7821f3e509bSPhilipp Reisner conn_err(tconn, "accept failed, err = %d\n", err); 783bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 784b411b363SPhilipp Reisner } 785b411b363SPhilipp Reisner } 786b411b363SPhilipp Reisner 787715306f6SAndreas Gruenbacher if (s_estab) 788715306f6SAndreas Gruenbacher unregister_state_change(s_estab->sk, ad); 789715306f6SAndreas Gruenbacher 790b411b363SPhilipp Reisner return s_estab; 791b411b363SPhilipp Reisner } 792b411b363SPhilipp Reisner 793e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *, void *, struct packet_info *); 794b411b363SPhilipp Reisner 7959f5bdc33SAndreas Gruenbacher static int send_first_packet(struct drbd_tconn *tconn, struct drbd_socket *sock, 7969f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7979f5bdc33SAndreas Gruenbacher { 7989f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) 7999f5bdc33SAndreas Gruenbacher return -EIO; 800e658983aSAndreas Gruenbacher return conn_send_command(tconn, sock, cmd, 0, NULL, 0); 801b411b363SPhilipp Reisner } 802b411b363SPhilipp Reisner 8039f5bdc33SAndreas Gruenbacher static int receive_first_packet(struct drbd_tconn *tconn, struct socket *sock) 804b411b363SPhilipp Reisner { 8059f5bdc33SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 8069f5bdc33SAndreas Gruenbacher struct packet_info pi; 8079f5bdc33SAndreas Gruenbacher int err; 808b411b363SPhilipp Reisner 8099f5bdc33SAndreas Gruenbacher err = drbd_recv_short(sock, tconn->data.rbuf, header_size, 0); 8109f5bdc33SAndreas Gruenbacher if (err != header_size) { 8119f5bdc33SAndreas Gruenbacher if (err >= 0) 8129f5bdc33SAndreas Gruenbacher err = -EIO; 8139f5bdc33SAndreas Gruenbacher return err; 8149f5bdc33SAndreas Gruenbacher } 8159f5bdc33SAndreas Gruenbacher err = decode_header(tconn, tconn->data.rbuf, &pi); 8169f5bdc33SAndreas Gruenbacher if (err) 8179f5bdc33SAndreas Gruenbacher return err; 8189f5bdc33SAndreas Gruenbacher return pi.cmd; 819b411b363SPhilipp Reisner } 820b411b363SPhilipp Reisner 821b411b363SPhilipp Reisner /** 822b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 823b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 824b411b363SPhilipp Reisner */ 825dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 826b411b363SPhilipp Reisner { 827b411b363SPhilipp Reisner int rr; 828b411b363SPhilipp Reisner char tb[4]; 829b411b363SPhilipp Reisner 830b411b363SPhilipp Reisner if (!*sock) 83181e84650SAndreas Gruenbacher return false; 832b411b363SPhilipp Reisner 833dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 834b411b363SPhilipp Reisner 835b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 83681e84650SAndreas Gruenbacher return true; 837b411b363SPhilipp Reisner } else { 838b411b363SPhilipp Reisner sock_release(*sock); 839b411b363SPhilipp Reisner *sock = NULL; 84081e84650SAndreas Gruenbacher return false; 841b411b363SPhilipp Reisner } 842b411b363SPhilipp Reisner } 8432325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8442325eb66SPhilipp Reisner in a connection */ 845c141ebdaSPhilipp Reisner int drbd_connected(struct drbd_conf *mdev) 846907599e0SPhilipp Reisner { 8470829f5edSAndreas Gruenbacher int err; 848907599e0SPhilipp Reisner 849907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 850907599e0SPhilipp Reisner mdev->peer_seq = 0; 851907599e0SPhilipp Reisner 8528410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 8538410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 8548410da8fSPhilipp Reisner &mdev->own_state_mutex; 8558410da8fSPhilipp Reisner 8560829f5edSAndreas Gruenbacher err = drbd_send_sync_param(mdev); 8570829f5edSAndreas Gruenbacher if (!err) 8580829f5edSAndreas Gruenbacher err = drbd_send_sizes(mdev, 0, 0); 8590829f5edSAndreas Gruenbacher if (!err) 8600829f5edSAndreas Gruenbacher err = drbd_send_uuids(mdev); 8610829f5edSAndreas Gruenbacher if (!err) 86243de7c85SPhilipp Reisner err = drbd_send_current_state(mdev); 863907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 864907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 8658b924f1dSPhilipp Reisner mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */ 8660829f5edSAndreas Gruenbacher return err; 867907599e0SPhilipp Reisner } 868907599e0SPhilipp Reisner 869b411b363SPhilipp Reisner /* 870b411b363SPhilipp Reisner * return values: 871b411b363SPhilipp Reisner * 1 yes, we have a valid connection 872b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 873b411b363SPhilipp Reisner * -1 peer talks different language, 874b411b363SPhilipp Reisner * no point in trying again, please go standalone. 875b411b363SPhilipp Reisner * -2 We do not have a network config... 876b411b363SPhilipp Reisner */ 87781fa2e67SPhilipp Reisner static int conn_connect(struct drbd_tconn *tconn) 878b411b363SPhilipp Reisner { 8797da35862SPhilipp Reisner struct drbd_socket sock, msock; 880c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 88144ed167dSPhilipp Reisner struct net_conf *nc; 88292f14951SPhilipp Reisner int vnr, timeout, h, ok; 88308b165baSPhilipp Reisner bool discard_my_data; 884a1096a6eSPhilipp Reisner enum drbd_state_rv rv; 8857a426fd8SPhilipp Reisner struct accept_wait_data ad = { 8867a426fd8SPhilipp Reisner .tconn = tconn, 8877a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 8887a426fd8SPhilipp Reisner }; 889b411b363SPhilipp Reisner 890b66623e3SPhilipp Reisner clear_bit(DISCONNECT_SENT, &tconn->flags); 891bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 892b411b363SPhilipp Reisner return -2; 893b411b363SPhilipp Reisner 8947da35862SPhilipp Reisner mutex_init(&sock.mutex); 8957da35862SPhilipp Reisner sock.sbuf = tconn->data.sbuf; 8967da35862SPhilipp Reisner sock.rbuf = tconn->data.rbuf; 8977da35862SPhilipp Reisner sock.socket = NULL; 8987da35862SPhilipp Reisner mutex_init(&msock.mutex); 8997da35862SPhilipp Reisner msock.sbuf = tconn->meta.sbuf; 9007da35862SPhilipp Reisner msock.rbuf = tconn->meta.rbuf; 9017da35862SPhilipp Reisner msock.socket = NULL; 9027da35862SPhilipp Reisner 9030916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 9040916e0e3SAndreas Gruenbacher tconn->agreed_pro_version = 80; 905b411b363SPhilipp Reisner 9067a426fd8SPhilipp Reisner if (prepare_listen_socket(tconn, &ad)) 9077a426fd8SPhilipp Reisner return 0; 9087a426fd8SPhilipp Reisner 909b411b363SPhilipp Reisner do { 9102bf89621SAndreas Gruenbacher struct socket *s; 9112bf89621SAndreas Gruenbacher 912907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 913b411b363SPhilipp Reisner if (s) { 9147da35862SPhilipp Reisner if (!sock.socket) { 9157da35862SPhilipp Reisner sock.socket = s; 9167da35862SPhilipp Reisner send_first_packet(tconn, &sock, P_INITIAL_DATA); 9177da35862SPhilipp Reisner } else if (!msock.socket) { 918427c0434SLars Ellenberg clear_bit(RESOLVE_CONFLICTS, &tconn->flags); 9197da35862SPhilipp Reisner msock.socket = s; 9207da35862SPhilipp Reisner send_first_packet(tconn, &msock, P_INITIAL_META); 921b411b363SPhilipp Reisner } else { 92281fa2e67SPhilipp Reisner conn_err(tconn, "Logic error in conn_connect()\n"); 923b411b363SPhilipp Reisner goto out_release_sockets; 924b411b363SPhilipp Reisner } 925b411b363SPhilipp Reisner } 926b411b363SPhilipp Reisner 9277da35862SPhilipp Reisner if (sock.socket && msock.socket) { 9287da35862SPhilipp Reisner rcu_read_lock(); 9297da35862SPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 9307da35862SPhilipp Reisner timeout = nc->ping_timeo * HZ / 10; 9317da35862SPhilipp Reisner rcu_read_unlock(); 9327da35862SPhilipp Reisner schedule_timeout_interruptible(timeout); 9337da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9347da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 935b411b363SPhilipp Reisner if (ok) 936b411b363SPhilipp Reisner break; 937b411b363SPhilipp Reisner } 938b411b363SPhilipp Reisner 939b411b363SPhilipp Reisner retry: 9407a426fd8SPhilipp Reisner s = drbd_wait_for_connect(tconn, &ad); 941b411b363SPhilipp Reisner if (s) { 94292f14951SPhilipp Reisner int fp = receive_first_packet(tconn, s); 9437da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9447da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 94592f14951SPhilipp Reisner switch (fp) { 946e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9477da35862SPhilipp Reisner if (sock.socket) { 948907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 9497da35862SPhilipp Reisner sock_release(sock.socket); 95080c6eed4SPhilipp Reisner sock.socket = s; 95180c6eed4SPhilipp Reisner goto randomize; 952b411b363SPhilipp Reisner } 9537da35862SPhilipp Reisner sock.socket = s; 954b411b363SPhilipp Reisner break; 955e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 956427c0434SLars Ellenberg set_bit(RESOLVE_CONFLICTS, &tconn->flags); 9577da35862SPhilipp Reisner if (msock.socket) { 958907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 9597da35862SPhilipp Reisner sock_release(msock.socket); 96080c6eed4SPhilipp Reisner msock.socket = s; 96180c6eed4SPhilipp Reisner goto randomize; 962b411b363SPhilipp Reisner } 9637da35862SPhilipp Reisner msock.socket = s; 964b411b363SPhilipp Reisner break; 965b411b363SPhilipp Reisner default: 966907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 967b411b363SPhilipp Reisner sock_release(s); 96880c6eed4SPhilipp Reisner randomize: 969b411b363SPhilipp Reisner if (random32() & 1) 970b411b363SPhilipp Reisner goto retry; 971b411b363SPhilipp Reisner } 972b411b363SPhilipp Reisner } 973b411b363SPhilipp Reisner 974bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 975b411b363SPhilipp Reisner goto out_release_sockets; 976b411b363SPhilipp Reisner if (signal_pending(current)) { 977b411b363SPhilipp Reisner flush_signals(current); 978b411b363SPhilipp Reisner smp_rmb(); 979907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 980b411b363SPhilipp Reisner goto out_release_sockets; 981b411b363SPhilipp Reisner } 982b411b363SPhilipp Reisner 9837da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9847da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 985b666dbf8SPhilipp Reisner } while (!ok); 986b411b363SPhilipp Reisner 9877a426fd8SPhilipp Reisner if (ad.s_listen) 9887a426fd8SPhilipp Reisner sock_release(ad.s_listen); 9897a426fd8SPhilipp Reisner 9907da35862SPhilipp Reisner sock.socket->sk->sk_reuse = 1; /* SO_REUSEADDR */ 9917da35862SPhilipp Reisner msock.socket->sk->sk_reuse = 1; /* SO_REUSEADDR */ 9922bf89621SAndreas Gruenbacher 9937da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 9947da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 995b411b363SPhilipp Reisner 9967da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 9977da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 998b411b363SPhilipp Reisner 999b411b363SPhilipp Reisner /* NOT YET ... 10007da35862SPhilipp Reisner * sock.socket->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 10017da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 10026038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 1003b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 100444ed167dSPhilipp Reisner rcu_read_lock(); 100544ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 1006b411b363SPhilipp Reisner 10077da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 10087da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 100944ed167dSPhilipp Reisner 10107da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 101144ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 101208b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 101344ed167dSPhilipp Reisner rcu_read_unlock(); 101444ed167dSPhilipp Reisner 10157da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 1016b411b363SPhilipp Reisner 1017b411b363SPhilipp Reisner /* we don't want delays. 101825985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10197da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10207da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1021b411b363SPhilipp Reisner 10227da35862SPhilipp Reisner tconn->data.socket = sock.socket; 10237da35862SPhilipp Reisner tconn->meta.socket = msock.socket; 1024907599e0SPhilipp Reisner tconn->last_received = jiffies; 1025b411b363SPhilipp Reisner 10266038178eSAndreas Gruenbacher h = drbd_do_features(tconn); 1027b411b363SPhilipp Reisner if (h <= 0) 1028b411b363SPhilipp Reisner return h; 1029b411b363SPhilipp Reisner 1030907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 1031b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 1032907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 1033b10d96cbSJohannes Thoma case -1: 1034907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 1035b411b363SPhilipp Reisner return -1; 1036b10d96cbSJohannes Thoma case 0: 1037907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 1038b10d96cbSJohannes Thoma return 0; 1039b411b363SPhilipp Reisner } 1040b411b363SPhilipp Reisner } 1041b411b363SPhilipp Reisner 10427da35862SPhilipp Reisner tconn->data.socket->sk->sk_sndtimeo = timeout; 10437da35862SPhilipp Reisner tconn->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1044b411b363SPhilipp Reisner 1045387eb308SAndreas Gruenbacher if (drbd_send_protocol(tconn) == -EOPNOTSUPP) 10467e2455c1SPhilipp Reisner return -1; 1047b411b363SPhilipp Reisner 1048a1096a6eSPhilipp Reisner set_bit(STATE_SENT, &tconn->flags); 1049a1096a6eSPhilipp Reisner 1050c141ebdaSPhilipp Reisner rcu_read_lock(); 1051c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 1052c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 1053c141ebdaSPhilipp Reisner rcu_read_unlock(); 105408b165baSPhilipp Reisner 105508b165baSPhilipp Reisner if (discard_my_data) 105608b165baSPhilipp Reisner set_bit(DISCARD_MY_DATA, &mdev->flags); 105708b165baSPhilipp Reisner else 105808b165baSPhilipp Reisner clear_bit(DISCARD_MY_DATA, &mdev->flags); 105908b165baSPhilipp Reisner 1060c141ebdaSPhilipp Reisner drbd_connected(mdev); 1061c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 1062c141ebdaSPhilipp Reisner rcu_read_lock(); 1063c141ebdaSPhilipp Reisner } 1064c141ebdaSPhilipp Reisner rcu_read_unlock(); 1065c141ebdaSPhilipp Reisner 1066a1096a6eSPhilipp Reisner rv = conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1067a1096a6eSPhilipp Reisner if (rv < SS_SUCCESS) { 1068a1096a6eSPhilipp Reisner clear_bit(STATE_SENT, &tconn->flags); 1069823bd832SPhilipp Reisner return 0; 1070a1096a6eSPhilipp Reisner } 1071823bd832SPhilipp Reisner 1072823bd832SPhilipp Reisner drbd_thread_start(&tconn->asender); 1073823bd832SPhilipp Reisner 107408b165baSPhilipp Reisner mutex_lock(&tconn->conf_update); 107508b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 107608b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 107708b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 107808b165baSPhilipp Reisner * just to clear a single value. */ 107908b165baSPhilipp Reisner tconn->net_conf->discard_my_data = 0; 108008b165baSPhilipp Reisner mutex_unlock(&tconn->conf_update); 108108b165baSPhilipp Reisner 1082d3fcb490SPhilipp Reisner return h; 1083b411b363SPhilipp Reisner 1084b411b363SPhilipp Reisner out_release_sockets: 10857a426fd8SPhilipp Reisner if (ad.s_listen) 10867a426fd8SPhilipp Reisner sock_release(ad.s_listen); 10877da35862SPhilipp Reisner if (sock.socket) 10887da35862SPhilipp Reisner sock_release(sock.socket); 10897da35862SPhilipp Reisner if (msock.socket) 10907da35862SPhilipp Reisner sock_release(msock.socket); 1091b411b363SPhilipp Reisner return -1; 1092b411b363SPhilipp Reisner } 1093b411b363SPhilipp Reisner 1094e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *tconn, void *header, struct packet_info *pi) 1095b411b363SPhilipp Reisner { 1096e658983aSAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 1097e658983aSAndreas Gruenbacher 10980c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 10990c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 11000c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 11010c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 11020c8e36d9SAndreas Gruenbacher conn_err(tconn, "Header padding is not zero\n"); 11030c8e36d9SAndreas Gruenbacher return -EINVAL; 11040c8e36d9SAndreas Gruenbacher } 11050c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11060c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11070c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11080c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1109e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1110e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1111e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1112b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1113eefc2f7dSPhilipp Reisner pi->vnr = 0; 1114e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1115e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1116e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1117e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1118e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 111977351055SPhilipp Reisner pi->vnr = 0; 112002918be2SPhilipp Reisner } else { 1121e658983aSAndreas Gruenbacher conn_err(tconn, "Wrong magic value 0x%08x in protocol version %d\n", 1122e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1123e658983aSAndreas Gruenbacher tconn->agreed_pro_version); 11248172f3e9SAndreas Gruenbacher return -EINVAL; 1125b411b363SPhilipp Reisner } 1126e658983aSAndreas Gruenbacher pi->data = header + header_size; 11278172f3e9SAndreas Gruenbacher return 0; 1128257d0af6SPhilipp Reisner } 1129257d0af6SPhilipp Reisner 11309ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 1131257d0af6SPhilipp Reisner { 1132e658983aSAndreas Gruenbacher void *buffer = tconn->data.rbuf; 113369bc7bc3SAndreas Gruenbacher int err; 1134257d0af6SPhilipp Reisner 1135e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, buffer, drbd_header_size(tconn)); 1136a5c31904SAndreas Gruenbacher if (err) 113769bc7bc3SAndreas Gruenbacher return err; 1138257d0af6SPhilipp Reisner 1139e658983aSAndreas Gruenbacher err = decode_header(tconn, buffer, pi); 11409ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 1141b411b363SPhilipp Reisner 114269bc7bc3SAndreas Gruenbacher return err; 1143b411b363SPhilipp Reisner } 1144b411b363SPhilipp Reisner 11454b0007c0SPhilipp Reisner static void drbd_flush(struct drbd_tconn *tconn) 1146b411b363SPhilipp Reisner { 1147b411b363SPhilipp Reisner int rv; 11484b0007c0SPhilipp Reisner struct drbd_conf *mdev; 11494b0007c0SPhilipp Reisner int vnr; 1150b411b363SPhilipp Reisner 11514b0007c0SPhilipp Reisner if (tconn->write_ordering >= WO_bdev_flush) { 1152615e087fSLars Ellenberg rcu_read_lock(); 11534b0007c0SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 1154615e087fSLars Ellenberg if (!get_ldev(mdev)) 1155615e087fSLars Ellenberg continue; 1156615e087fSLars Ellenberg kref_get(&mdev->kref); 1157615e087fSLars Ellenberg rcu_read_unlock(); 11584b0007c0SPhilipp Reisner 1159615e087fSLars Ellenberg rv = blkdev_issue_flush(mdev->ldev->backing_bdev, 1160615e087fSLars Ellenberg GFP_NOIO, NULL); 1161b411b363SPhilipp Reisner if (rv) { 1162a67b813cSPhilipp Reisner dev_info(DEV, "local disk flush failed with status %d\n", rv); 1163b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1164b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1165b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 11664b0007c0SPhilipp Reisner drbd_bump_write_ordering(tconn, WO_drain_io); 1167615e087fSLars Ellenberg } 1168615e087fSLars Ellenberg put_ldev(mdev); 1169615e087fSLars Ellenberg kref_put(&mdev->kref, &drbd_minor_destroy); 1170615e087fSLars Ellenberg 1171615e087fSLars Ellenberg rcu_read_lock(); 1172615e087fSLars Ellenberg if (rv) 11734b0007c0SPhilipp Reisner break; 1174b411b363SPhilipp Reisner } 1175615e087fSLars Ellenberg rcu_read_unlock(); 1176b411b363SPhilipp Reisner } 1177b411b363SPhilipp Reisner } 1178b411b363SPhilipp Reisner 1179b411b363SPhilipp Reisner /** 1180b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1181b411b363SPhilipp Reisner * @mdev: DRBD device. 1182b411b363SPhilipp Reisner * @epoch: Epoch object. 1183b411b363SPhilipp Reisner * @ev: Epoch event. 1184b411b363SPhilipp Reisner */ 11851e9dd291SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_tconn *tconn, 1186b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1187b411b363SPhilipp Reisner enum epoch_event ev) 1188b411b363SPhilipp Reisner { 11892451fc3bSPhilipp Reisner int epoch_size; 1190b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1191b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1192b411b363SPhilipp Reisner 119312038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 1194b411b363SPhilipp Reisner do { 1195b411b363SPhilipp Reisner next_epoch = NULL; 1196b411b363SPhilipp Reisner 1197b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1198b411b363SPhilipp Reisner 1199b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1200b411b363SPhilipp Reisner case EV_PUT: 1201b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1202b411b363SPhilipp Reisner break; 1203b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1204b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1205b411b363SPhilipp Reisner break; 1206b411b363SPhilipp Reisner case EV_BECAME_LAST: 1207b411b363SPhilipp Reisner /* nothing to do*/ 1208b411b363SPhilipp Reisner break; 1209b411b363SPhilipp Reisner } 1210b411b363SPhilipp Reisner 1211b411b363SPhilipp Reisner if (epoch_size != 0 && 1212b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 121385d73513SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1214b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 121512038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 12169ed57dcbSLars Ellenberg drbd_send_b_ack(epoch->tconn, epoch->barrier_nr, epoch_size); 121712038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 1218b411b363SPhilipp Reisner } 12199ed57dcbSLars Ellenberg #if 0 12209ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 12219ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 122285d73513SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 12239ed57dcbSLars Ellenberg dec_unacked(epoch->tconn); 12249ed57dcbSLars Ellenberg #endif 1225b411b363SPhilipp Reisner 122612038a3aSPhilipp Reisner if (tconn->current_epoch != epoch) { 1227b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1228b411b363SPhilipp Reisner list_del(&epoch->list); 1229b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 123012038a3aSPhilipp Reisner tconn->epochs--; 1231b411b363SPhilipp Reisner kfree(epoch); 1232b411b363SPhilipp Reisner 1233b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1234b411b363SPhilipp Reisner rv = FE_DESTROYED; 1235b411b363SPhilipp Reisner } else { 1236b411b363SPhilipp Reisner epoch->flags = 0; 1237b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1238698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1239b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1240b411b363SPhilipp Reisner rv = FE_RECYCLED; 1241b411b363SPhilipp Reisner } 1242b411b363SPhilipp Reisner } 1243b411b363SPhilipp Reisner 1244b411b363SPhilipp Reisner if (!next_epoch) 1245b411b363SPhilipp Reisner break; 1246b411b363SPhilipp Reisner 1247b411b363SPhilipp Reisner epoch = next_epoch; 1248b411b363SPhilipp Reisner } while (1); 1249b411b363SPhilipp Reisner 125012038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 1251b411b363SPhilipp Reisner 1252b411b363SPhilipp Reisner return rv; 1253b411b363SPhilipp Reisner } 1254b411b363SPhilipp Reisner 1255b411b363SPhilipp Reisner /** 1256b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 12574b0007c0SPhilipp Reisner * @tconn: DRBD connection. 1258b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1259b411b363SPhilipp Reisner */ 12604b0007c0SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_tconn *tconn, enum write_ordering_e wo) 1261b411b363SPhilipp Reisner { 1262daeda1ccSPhilipp Reisner struct disk_conf *dc; 12634b0007c0SPhilipp Reisner struct drbd_conf *mdev; 1264b411b363SPhilipp Reisner enum write_ordering_e pwo; 12654b0007c0SPhilipp Reisner int vnr; 1266b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1267b411b363SPhilipp Reisner [WO_none] = "none", 1268b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1269b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1270b411b363SPhilipp Reisner }; 1271b411b363SPhilipp Reisner 12724b0007c0SPhilipp Reisner pwo = tconn->write_ordering; 1273b411b363SPhilipp Reisner wo = min(pwo, wo); 1274daeda1ccSPhilipp Reisner rcu_read_lock(); 12754b0007c0SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 127627eb13e9SPhilipp Reisner if (!get_ldev_if_state(mdev, D_ATTACHING)) 12774b0007c0SPhilipp Reisner continue; 1278daeda1ccSPhilipp Reisner dc = rcu_dereference(mdev->ldev->disk_conf); 1279daeda1ccSPhilipp Reisner 128066b2f6b9SAndreas Gruenbacher if (wo == WO_bdev_flush && !dc->disk_flushes) 1281b411b363SPhilipp Reisner wo = WO_drain_io; 1282d0c980e2SAndreas Gruenbacher if (wo == WO_drain_io && !dc->disk_drain) 1283b411b363SPhilipp Reisner wo = WO_none; 12844b0007c0SPhilipp Reisner put_ldev(mdev); 12854b0007c0SPhilipp Reisner } 1286daeda1ccSPhilipp Reisner rcu_read_unlock(); 12874b0007c0SPhilipp Reisner tconn->write_ordering = wo; 12884b0007c0SPhilipp Reisner if (pwo != tconn->write_ordering || wo == WO_bdev_flush) 12894b0007c0SPhilipp Reisner conn_info(tconn, "Method to ensure write ordering: %s\n", write_ordering_str[tconn->write_ordering]); 1290b411b363SPhilipp Reisner } 1291b411b363SPhilipp Reisner 1292b411b363SPhilipp Reisner /** 1293fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 129445bb912bSLars Ellenberg * @mdev: DRBD device. 1295db830c46SAndreas Gruenbacher * @peer_req: peer request 129645bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 129710f6d992SLars Ellenberg * 129810f6d992SLars Ellenberg * May spread the pages to multiple bios, 129910f6d992SLars Ellenberg * depending on bio_add_page restrictions. 130010f6d992SLars Ellenberg * 130110f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 130210f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 130310f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 130410f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 130510f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 130610f6d992SLars Ellenberg * on certain Xen deployments. 130745bb912bSLars Ellenberg */ 130845bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1309fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1310fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 131145bb912bSLars Ellenberg const unsigned rw, const int fault_type) 131245bb912bSLars Ellenberg { 131345bb912bSLars Ellenberg struct bio *bios = NULL; 131445bb912bSLars Ellenberg struct bio *bio; 1315db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1316db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1317db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 131845bb912bSLars Ellenberg unsigned n_bios = 0; 131945bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 132010f6d992SLars Ellenberg int err = -ENOMEM; 132145bb912bSLars Ellenberg 132245bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 132345bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 132445bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 1325da4a75d2SLars Ellenberg * request in more than one bio. 1326da4a75d2SLars Ellenberg * 1327da4a75d2SLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 1328da4a75d2SLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 1329da4a75d2SLars Ellenberg */ 133045bb912bSLars Ellenberg next_bio: 133145bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 133245bb912bSLars Ellenberg if (!bio) { 133345bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 133445bb912bSLars Ellenberg goto fail; 133545bb912bSLars Ellenberg } 1336db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 133745bb912bSLars Ellenberg bio->bi_sector = sector; 133845bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 133945bb912bSLars Ellenberg bio->bi_rw = rw; 1340db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1341fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 134245bb912bSLars Ellenberg 134345bb912bSLars Ellenberg bio->bi_next = bios; 134445bb912bSLars Ellenberg bios = bio; 134545bb912bSLars Ellenberg ++n_bios; 134645bb912bSLars Ellenberg 134745bb912bSLars Ellenberg page_chain_for_each(page) { 134845bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 134945bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 135010f6d992SLars Ellenberg /* A single page must always be possible! 135110f6d992SLars Ellenberg * But in case it fails anyways, 135210f6d992SLars Ellenberg * we deal with it, and complain (below). */ 135310f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 135410f6d992SLars Ellenberg dev_err(DEV, 135510f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 135610f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 135710f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 135810f6d992SLars Ellenberg err = -ENOSPC; 135910f6d992SLars Ellenberg goto fail; 136010f6d992SLars Ellenberg } 136145bb912bSLars Ellenberg goto next_bio; 136245bb912bSLars Ellenberg } 136345bb912bSLars Ellenberg ds -= len; 136445bb912bSLars Ellenberg sector += len >> 9; 136545bb912bSLars Ellenberg --nr_pages; 136645bb912bSLars Ellenberg } 136745bb912bSLars Ellenberg D_ASSERT(page == NULL); 136845bb912bSLars Ellenberg D_ASSERT(ds == 0); 136945bb912bSLars Ellenberg 1370db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 137145bb912bSLars Ellenberg do { 137245bb912bSLars Ellenberg bio = bios; 137345bb912bSLars Ellenberg bios = bios->bi_next; 137445bb912bSLars Ellenberg bio->bi_next = NULL; 137545bb912bSLars Ellenberg 137645bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 137745bb912bSLars Ellenberg } while (bios); 137845bb912bSLars Ellenberg return 0; 137945bb912bSLars Ellenberg 138045bb912bSLars Ellenberg fail: 138145bb912bSLars Ellenberg while (bios) { 138245bb912bSLars Ellenberg bio = bios; 138345bb912bSLars Ellenberg bios = bios->bi_next; 138445bb912bSLars Ellenberg bio_put(bio); 138545bb912bSLars Ellenberg } 138610f6d992SLars Ellenberg return err; 138745bb912bSLars Ellenberg } 138845bb912bSLars Ellenberg 138953840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1390db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 139153840641SAndreas Gruenbacher { 1392db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 139353840641SAndreas Gruenbacher 139453840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 139553840641SAndreas Gruenbacher drbd_clear_interval(i); 139653840641SAndreas Gruenbacher 13976c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 139853840641SAndreas Gruenbacher if (i->waiting) 139953840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 140053840641SAndreas Gruenbacher } 140153840641SAndreas Gruenbacher 140277fede51SPhilipp Reisner void conn_wait_active_ee_empty(struct drbd_tconn *tconn) 140377fede51SPhilipp Reisner { 140477fede51SPhilipp Reisner struct drbd_conf *mdev; 140577fede51SPhilipp Reisner int vnr; 140677fede51SPhilipp Reisner 140777fede51SPhilipp Reisner rcu_read_lock(); 140877fede51SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 140977fede51SPhilipp Reisner kref_get(&mdev->kref); 141077fede51SPhilipp Reisner rcu_read_unlock(); 141177fede51SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 141277fede51SPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 141377fede51SPhilipp Reisner rcu_read_lock(); 141477fede51SPhilipp Reisner } 141577fede51SPhilipp Reisner rcu_read_unlock(); 141677fede51SPhilipp Reisner } 141777fede51SPhilipp Reisner 14184a76b161SAndreas Gruenbacher static int receive_Barrier(struct drbd_tconn *tconn, struct packet_info *pi) 1419b411b363SPhilipp Reisner { 14202451fc3bSPhilipp Reisner int rv; 1421e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1422b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1423b411b363SPhilipp Reisner 14249ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 14259ed57dcbSLars Ellenberg * not a specific (peer)device. 14269ed57dcbSLars Ellenberg */ 142712038a3aSPhilipp Reisner tconn->current_epoch->barrier_nr = p->barrier; 14289ed57dcbSLars Ellenberg tconn->current_epoch->tconn = tconn; 14291e9dd291SPhilipp Reisner rv = drbd_may_finish_epoch(tconn, tconn->current_epoch, EV_GOT_BARRIER_NR); 1430b411b363SPhilipp Reisner 1431b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1432b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1433b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1434b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1435b411b363SPhilipp Reisner * completed. */ 14364b0007c0SPhilipp Reisner switch (tconn->write_ordering) { 1437b411b363SPhilipp Reisner case WO_none: 1438b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 143982bc0194SAndreas Gruenbacher return 0; 1440b411b363SPhilipp Reisner 1441b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1442b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1443b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14442451fc3bSPhilipp Reisner if (epoch) 14452451fc3bSPhilipp Reisner break; 14462451fc3bSPhilipp Reisner else 14479ed57dcbSLars Ellenberg conn_warn(tconn, "Allocation of an epoch failed, slowing down\n"); 14482451fc3bSPhilipp Reisner /* Fall through */ 14492451fc3bSPhilipp Reisner 14502451fc3bSPhilipp Reisner case WO_bdev_flush: 14512451fc3bSPhilipp Reisner case WO_drain_io: 145277fede51SPhilipp Reisner conn_wait_active_ee_empty(tconn); 14534b0007c0SPhilipp Reisner drbd_flush(tconn); 14542451fc3bSPhilipp Reisner 145512038a3aSPhilipp Reisner if (atomic_read(&tconn->current_epoch->epoch_size)) { 14562451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14572451fc3bSPhilipp Reisner if (epoch) 14582451fc3bSPhilipp Reisner break; 1459b411b363SPhilipp Reisner } 1460b411b363SPhilipp Reisner 146182bc0194SAndreas Gruenbacher return 0; 14622451fc3bSPhilipp Reisner default: 14639ed57dcbSLars Ellenberg conn_err(tconn, "Strangeness in tconn->write_ordering %d\n", tconn->write_ordering); 146482bc0194SAndreas Gruenbacher return -EIO; 1465b411b363SPhilipp Reisner } 1466b411b363SPhilipp Reisner 1467b411b363SPhilipp Reisner epoch->flags = 0; 1468b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1469b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1470b411b363SPhilipp Reisner 147112038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 147212038a3aSPhilipp Reisner if (atomic_read(&tconn->current_epoch->epoch_size)) { 147312038a3aSPhilipp Reisner list_add(&epoch->list, &tconn->current_epoch->list); 147412038a3aSPhilipp Reisner tconn->current_epoch = epoch; 147512038a3aSPhilipp Reisner tconn->epochs++; 1476b411b363SPhilipp Reisner } else { 1477b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1478b411b363SPhilipp Reisner kfree(epoch); 1479b411b363SPhilipp Reisner } 148012038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 1481b411b363SPhilipp Reisner 148282bc0194SAndreas Gruenbacher return 0; 1483b411b363SPhilipp Reisner } 1484b411b363SPhilipp Reisner 1485b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1486b411b363SPhilipp Reisner * and from receive_Data */ 1487f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1488f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1489f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1490b411b363SPhilipp Reisner { 14916666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1492db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1493b411b363SPhilipp Reisner struct page *page; 1494a5c31904SAndreas Gruenbacher int dgs, ds, err; 1495a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1496a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 14976b4388acSPhilipp Reisner unsigned long *data; 1498b411b363SPhilipp Reisner 149988104ca4SAndreas Gruenbacher dgs = 0; 150088104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 150188104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 15029f5bdc33SAndreas Gruenbacher /* 15039f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 15049f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 15059f5bdc33SAndreas Gruenbacher */ 1506a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1507a5c31904SAndreas Gruenbacher if (err) 1508b411b363SPhilipp Reisner return NULL; 1509b411b363SPhilipp Reisner data_size -= dgs; 151088104ca4SAndreas Gruenbacher } 1511b411b363SPhilipp Reisner 1512841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1513841ce241SAndreas Gruenbacher return NULL; 1514841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1515841ce241SAndreas Gruenbacher return NULL; 1516b411b363SPhilipp Reisner 15176666032aSLars Ellenberg /* even though we trust out peer, 15186666032aSLars Ellenberg * we sometimes have to double check. */ 15196666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1520fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1521fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 15226666032aSLars Ellenberg (unsigned long long)capacity, 15236666032aSLars Ellenberg (unsigned long long)sector, data_size); 15246666032aSLars Ellenberg return NULL; 15256666032aSLars Ellenberg } 15266666032aSLars Ellenberg 1527b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1528b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1529b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 15300db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, id, sector, data_size, GFP_NOIO); 1531db830c46SAndreas Gruenbacher if (!peer_req) 1532b411b363SPhilipp Reisner return NULL; 153345bb912bSLars Ellenberg 153481a3537aSLars Ellenberg if (!data_size) 153581a3537aSLars Ellenberg return peer_req; 153681a3537aSLars Ellenberg 1537b411b363SPhilipp Reisner ds = data_size; 1538db830c46SAndreas Gruenbacher page = peer_req->pages; 153945bb912bSLars Ellenberg page_chain_for_each(page) { 154045bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 15416b4388acSPhilipp Reisner data = kmap(page); 1542a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 15430cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 15446b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 15456b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 15466b4388acSPhilipp Reisner } 1547b411b363SPhilipp Reisner kunmap(page); 1548a5c31904SAndreas Gruenbacher if (err) { 15493967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1550b411b363SPhilipp Reisner return NULL; 1551b411b363SPhilipp Reisner } 1552a5c31904SAndreas Gruenbacher ds -= len; 1553b411b363SPhilipp Reisner } 1554b411b363SPhilipp Reisner 1555b411b363SPhilipp Reisner if (dgs) { 15565b614abeSAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->peer_integrity_tfm, peer_req, dig_vv); 1557b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1558470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1559470be44aSLars Ellenberg (unsigned long long)sector, data_size); 15603967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1561b411b363SPhilipp Reisner return NULL; 1562b411b363SPhilipp Reisner } 1563b411b363SPhilipp Reisner } 1564b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1565db830c46SAndreas Gruenbacher return peer_req; 1566b411b363SPhilipp Reisner } 1567b411b363SPhilipp Reisner 1568b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1569b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1570b411b363SPhilipp Reisner */ 1571b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1572b411b363SPhilipp Reisner { 1573b411b363SPhilipp Reisner struct page *page; 1574a5c31904SAndreas Gruenbacher int err = 0; 1575b411b363SPhilipp Reisner void *data; 1576b411b363SPhilipp Reisner 1577c3470cdeSLars Ellenberg if (!data_size) 1578fc5be839SAndreas Gruenbacher return 0; 1579c3470cdeSLars Ellenberg 1580c37c8ecfSAndreas Gruenbacher page = drbd_alloc_pages(mdev, 1, 1); 1581b411b363SPhilipp Reisner 1582b411b363SPhilipp Reisner data = kmap(page); 1583b411b363SPhilipp Reisner while (data_size) { 1584fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1585fc5be839SAndreas Gruenbacher 1586a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 1587a5c31904SAndreas Gruenbacher if (err) 1588b411b363SPhilipp Reisner break; 1589a5c31904SAndreas Gruenbacher data_size -= len; 1590b411b363SPhilipp Reisner } 1591b411b363SPhilipp Reisner kunmap(page); 15925cc287e0SAndreas Gruenbacher drbd_free_pages(mdev, page, 0); 1593fc5be839SAndreas Gruenbacher return err; 1594b411b363SPhilipp Reisner } 1595b411b363SPhilipp Reisner 1596b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1597b411b363SPhilipp Reisner sector_t sector, int data_size) 1598b411b363SPhilipp Reisner { 1599b411b363SPhilipp Reisner struct bio_vec *bvec; 1600b411b363SPhilipp Reisner struct bio *bio; 1601a5c31904SAndreas Gruenbacher int dgs, err, i, expect; 1602a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1603a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1604b411b363SPhilipp Reisner 160588104ca4SAndreas Gruenbacher dgs = 0; 160688104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 160788104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 1608a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1609a5c31904SAndreas Gruenbacher if (err) 1610a5c31904SAndreas Gruenbacher return err; 1611b411b363SPhilipp Reisner data_size -= dgs; 161288104ca4SAndreas Gruenbacher } 1613b411b363SPhilipp Reisner 1614b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1615b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1616b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1617b411b363SPhilipp Reisner 1618b411b363SPhilipp Reisner bio = req->master_bio; 1619b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1620b411b363SPhilipp Reisner 1621b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1622a5c31904SAndreas Gruenbacher void *mapped = kmap(bvec->bv_page) + bvec->bv_offset; 1623b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1624a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, mapped, expect); 1625b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1626a5c31904SAndreas Gruenbacher if (err) 1627a5c31904SAndreas Gruenbacher return err; 1628a5c31904SAndreas Gruenbacher data_size -= expect; 1629b411b363SPhilipp Reisner } 1630b411b363SPhilipp Reisner 1631b411b363SPhilipp Reisner if (dgs) { 16325b614abeSAndreas Gruenbacher drbd_csum_bio(mdev, mdev->tconn->peer_integrity_tfm, bio, dig_vv); 1633b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1634b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 163528284cefSAndreas Gruenbacher return -EINVAL; 1636b411b363SPhilipp Reisner } 1637b411b363SPhilipp Reisner } 1638b411b363SPhilipp Reisner 1639b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 164028284cefSAndreas Gruenbacher return 0; 1641b411b363SPhilipp Reisner } 1642b411b363SPhilipp Reisner 1643a990be46SAndreas Gruenbacher /* 1644a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1645a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1646a990be46SAndreas Gruenbacher */ 164799920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1648b411b363SPhilipp Reisner { 16498050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16508050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 165100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1652db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 165399920dc5SAndreas Gruenbacher int err; 1654b411b363SPhilipp Reisner 1655db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1656b411b363SPhilipp Reisner 1657db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1658db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 165999920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1660b411b363SPhilipp Reisner } else { 1661b411b363SPhilipp Reisner /* Record failure to sync */ 1662db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1663b411b363SPhilipp Reisner 166499920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1665b411b363SPhilipp Reisner } 1666b411b363SPhilipp Reisner dec_unacked(mdev); 1667b411b363SPhilipp Reisner 166899920dc5SAndreas Gruenbacher return err; 1669b411b363SPhilipp Reisner } 1670b411b363SPhilipp Reisner 1671b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1672b411b363SPhilipp Reisner { 1673db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1674b411b363SPhilipp Reisner 1675db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1676db830c46SAndreas Gruenbacher if (!peer_req) 167745bb912bSLars Ellenberg goto fail; 1678b411b363SPhilipp Reisner 1679b411b363SPhilipp Reisner dec_rs_pending(mdev); 1680b411b363SPhilipp Reisner 1681b411b363SPhilipp Reisner inc_unacked(mdev); 1682b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1683b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1684b411b363SPhilipp Reisner 1685db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 168645bb912bSLars Ellenberg 168787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1688db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 168987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1690b411b363SPhilipp Reisner 16910f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1692fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1693e1c1b0fcSAndreas Gruenbacher return 0; 169445bb912bSLars Ellenberg 169510f6d992SLars Ellenberg /* don't care for the reason here */ 169610f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 169787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1698db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 169987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 170022cc37a9SLars Ellenberg 17013967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 170245bb912bSLars Ellenberg fail: 170345bb912bSLars Ellenberg put_ldev(mdev); 1704e1c1b0fcSAndreas Gruenbacher return -EIO; 1705b411b363SPhilipp Reisner } 1706b411b363SPhilipp Reisner 1707668eebc6SAndreas Gruenbacher static struct drbd_request * 1708bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1709bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1710668eebc6SAndreas Gruenbacher { 1711668eebc6SAndreas Gruenbacher struct drbd_request *req; 1712668eebc6SAndreas Gruenbacher 1713bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1714bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 17155e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1716668eebc6SAndreas Gruenbacher return req; 1717c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 17185af172edSAndreas Gruenbacher dev_err(DEV, "%s: failed to find request 0x%lx, sector %llus\n", func, 1719c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1720c3afd8f5SAndreas Gruenbacher } 1721668eebc6SAndreas Gruenbacher return NULL; 1722668eebc6SAndreas Gruenbacher } 1723668eebc6SAndreas Gruenbacher 17244a76b161SAndreas Gruenbacher static int receive_DataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1725b411b363SPhilipp Reisner { 17264a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1727b411b363SPhilipp Reisner struct drbd_request *req; 1728b411b363SPhilipp Reisner sector_t sector; 172982bc0194SAndreas Gruenbacher int err; 1730e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17314a76b161SAndreas Gruenbacher 17324a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 17334a76b161SAndreas Gruenbacher if (!mdev) 17344a76b161SAndreas Gruenbacher return -EIO; 1735b411b363SPhilipp Reisner 1736b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1737b411b363SPhilipp Reisner 173887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1739bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 174087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1741c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 174282bc0194SAndreas Gruenbacher return -EIO; 1743b411b363SPhilipp Reisner 174424c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1745b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1746b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1747e2857216SAndreas Gruenbacher err = recv_dless_read(mdev, req, sector, pi->size); 174882bc0194SAndreas Gruenbacher if (!err) 17498554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1750b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1751b411b363SPhilipp Reisner * I don't think we may complete this just yet 1752b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1753b411b363SPhilipp Reisner 175482bc0194SAndreas Gruenbacher return err; 1755b411b363SPhilipp Reisner } 1756b411b363SPhilipp Reisner 17574a76b161SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1758b411b363SPhilipp Reisner { 17594a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1760b411b363SPhilipp Reisner sector_t sector; 176182bc0194SAndreas Gruenbacher int err; 1762e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17634a76b161SAndreas Gruenbacher 17644a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 17654a76b161SAndreas Gruenbacher if (!mdev) 17664a76b161SAndreas Gruenbacher return -EIO; 1767b411b363SPhilipp Reisner 1768b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1769b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1770b411b363SPhilipp Reisner 1771b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1772b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1773b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1774fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1775e2857216SAndreas Gruenbacher err = recv_resync_read(mdev, sector, pi->size); 1776b411b363SPhilipp Reisner } else { 1777b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1778b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1779b411b363SPhilipp Reisner 1780e2857216SAndreas Gruenbacher err = drbd_drain_block(mdev, pi->size); 1781b411b363SPhilipp Reisner 1782e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 1783b411b363SPhilipp Reisner } 1784b411b363SPhilipp Reisner 1785e2857216SAndreas Gruenbacher atomic_add(pi->size >> 9, &mdev->rs_sect_in); 1786778f271dSPhilipp Reisner 178782bc0194SAndreas Gruenbacher return err; 1788b411b363SPhilipp Reisner } 1789b411b363SPhilipp Reisner 17907be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 17917be8da07SAndreas Gruenbacher sector_t sector, int size) 17927be8da07SAndreas Gruenbacher { 17937be8da07SAndreas Gruenbacher struct drbd_interval *i; 17947be8da07SAndreas Gruenbacher struct drbd_request *req; 17957be8da07SAndreas Gruenbacher 17967be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 17977be8da07SAndreas Gruenbacher if (!i->local) 17987be8da07SAndreas Gruenbacher continue; 17997be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18007be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 18017be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 18027be8da07SAndreas Gruenbacher continue; 18032312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 18042312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 1805d4dabbe2SLars Ellenberg __req_mod(req, CONFLICT_RESOLVED, NULL); 18067be8da07SAndreas Gruenbacher } 18077be8da07SAndreas Gruenbacher } 18087be8da07SAndreas Gruenbacher 1809a990be46SAndreas Gruenbacher /* 1810a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1811b411b363SPhilipp Reisner */ 181299920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1813b411b363SPhilipp Reisner { 18148050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 18158050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 181600d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1817db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 181899920dc5SAndreas Gruenbacher int err = 0, pcmd; 1819b411b363SPhilipp Reisner 1820303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1821db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1822b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1823b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1824db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1825b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 182699920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, pcmd, peer_req); 1827b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1828db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1829b411b363SPhilipp Reisner } else { 183099920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1831b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1832b411b363SPhilipp Reisner * maybe assert this? */ 1833b411b363SPhilipp Reisner } 1834b411b363SPhilipp Reisner dec_unacked(mdev); 1835b411b363SPhilipp Reisner } 1836b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1837b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1838302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 183987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1840db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1841db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 18427be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 18437be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 184487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1845bb3bfe96SAndreas Gruenbacher } else 1846db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1847b411b363SPhilipp Reisner 18481e9dd291SPhilipp Reisner drbd_may_finish_epoch(mdev->tconn, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1849b411b363SPhilipp Reisner 185099920dc5SAndreas Gruenbacher return err; 1851b411b363SPhilipp Reisner } 1852b411b363SPhilipp Reisner 18537be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1854b411b363SPhilipp Reisner { 18557be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 18568050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 18578050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 185899920dc5SAndreas Gruenbacher int err; 1859b411b363SPhilipp Reisner 186099920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, ack, peer_req); 1861b411b363SPhilipp Reisner dec_unacked(mdev); 1862b411b363SPhilipp Reisner 186399920dc5SAndreas Gruenbacher return err; 1864b411b363SPhilipp Reisner } 1865b411b363SPhilipp Reisner 1866d4dabbe2SLars Ellenberg static int e_send_superseded(struct drbd_work *w, int unused) 18677be8da07SAndreas Gruenbacher { 1868d4dabbe2SLars Ellenberg return e_send_ack(w, P_SUPERSEDED); 18697be8da07SAndreas Gruenbacher } 18707be8da07SAndreas Gruenbacher 187199920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 18727be8da07SAndreas Gruenbacher { 18737be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 18747be8da07SAndreas Gruenbacher 18757be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 1876d4dabbe2SLars Ellenberg P_RETRY_WRITE : P_SUPERSEDED); 18777be8da07SAndreas Gruenbacher } 18787be8da07SAndreas Gruenbacher 18793e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 18803e394da1SAndreas Gruenbacher { 18813e394da1SAndreas Gruenbacher /* 18823e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 18833e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 18843e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 18853e394da1SAndreas Gruenbacher */ 18863e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 18873e394da1SAndreas Gruenbacher } 18883e394da1SAndreas Gruenbacher 18893e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 18903e394da1SAndreas Gruenbacher { 18913e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 18923e394da1SAndreas Gruenbacher } 18933e394da1SAndreas Gruenbacher 18947be8da07SAndreas Gruenbacher static bool need_peer_seq(struct drbd_conf *mdev) 18957be8da07SAndreas Gruenbacher { 18967be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 1897302bdeaeSPhilipp Reisner int tp; 18987be8da07SAndreas Gruenbacher 18997be8da07SAndreas Gruenbacher /* 19007be8da07SAndreas Gruenbacher * We only need to keep track of the last packet_seq number of our peer 1901427c0434SLars Ellenberg * if we are in dual-primary mode and we have the resolve-conflicts flag set; see 19027be8da07SAndreas Gruenbacher * handle_write_conflicts(). 19037be8da07SAndreas Gruenbacher */ 1904302bdeaeSPhilipp Reisner 1905302bdeaeSPhilipp Reisner rcu_read_lock(); 1906302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 1907302bdeaeSPhilipp Reisner rcu_read_unlock(); 1908302bdeaeSPhilipp Reisner 1909427c0434SLars Ellenberg return tp && test_bit(RESOLVE_CONFLICTS, &tconn->flags); 19107be8da07SAndreas Gruenbacher } 19117be8da07SAndreas Gruenbacher 191243ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 19133e394da1SAndreas Gruenbacher { 19143c13b680SLars Ellenberg unsigned int newest_peer_seq; 19153e394da1SAndreas Gruenbacher 19167be8da07SAndreas Gruenbacher if (need_peer_seq(mdev)) { 19173e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 19183c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 19193c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 19203e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 19213c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 19223c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 19233e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 19243e394da1SAndreas Gruenbacher } 19257be8da07SAndreas Gruenbacher } 19263e394da1SAndreas Gruenbacher 1927d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 1928d93f6302SLars Ellenberg { 1929d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 1930d93f6302SLars Ellenberg } 1931d93f6302SLars Ellenberg 1932d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 19333ea35df8SPhilipp Reisner static bool overlapping_resync_write(struct drbd_conf *mdev, struct drbd_peer_request *peer_req) 1934d93f6302SLars Ellenberg { 1935d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 1936d93f6302SLars Ellenberg bool rv = 0; 1937d93f6302SLars Ellenberg 1938d93f6302SLars Ellenberg spin_lock_irq(&mdev->tconn->req_lock); 1939d93f6302SLars Ellenberg list_for_each_entry(rs_req, &mdev->sync_ee, w.list) { 1940d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 1941d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 1942d93f6302SLars Ellenberg rv = 1; 1943d93f6302SLars Ellenberg break; 1944d93f6302SLars Ellenberg } 1945d93f6302SLars Ellenberg } 1946d93f6302SLars Ellenberg spin_unlock_irq(&mdev->tconn->req_lock); 1947d93f6302SLars Ellenberg 1948d93f6302SLars Ellenberg return rv; 1949d93f6302SLars Ellenberg } 1950d93f6302SLars Ellenberg 1951b411b363SPhilipp Reisner /* Called from receive_Data. 1952b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1953b411b363SPhilipp Reisner * 1954b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1955b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1956b411b363SPhilipp Reisner * been sent. 1957b411b363SPhilipp Reisner * 1958b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1959b411b363SPhilipp Reisner * 1960b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1961b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1962b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1963b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1964b411b363SPhilipp Reisner * 1965b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1966b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1967b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1968b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1969b411b363SPhilipp Reisner * 1970b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1971b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 19727be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1973b411b363SPhilipp Reisner { 1974b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1975b411b363SPhilipp Reisner long timeout; 19767be8da07SAndreas Gruenbacher int ret; 19777be8da07SAndreas Gruenbacher 19787be8da07SAndreas Gruenbacher if (!need_peer_seq(mdev)) 19797be8da07SAndreas Gruenbacher return 0; 19807be8da07SAndreas Gruenbacher 1981b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1982b411b363SPhilipp Reisner for (;;) { 19837be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 19847be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 19857be8da07SAndreas Gruenbacher ret = 0; 1986b411b363SPhilipp Reisner break; 19877be8da07SAndreas Gruenbacher } 1988b411b363SPhilipp Reisner if (signal_pending(current)) { 1989b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1990b411b363SPhilipp Reisner break; 1991b411b363SPhilipp Reisner } 19927be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1993b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 199444ed167dSPhilipp Reisner rcu_read_lock(); 199544ed167dSPhilipp Reisner timeout = rcu_dereference(mdev->tconn->net_conf)->ping_timeo*HZ/10; 199644ed167dSPhilipp Reisner rcu_read_unlock(); 199771b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1998b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 19997be8da07SAndreas Gruenbacher if (!timeout) { 2000b411b363SPhilipp Reisner ret = -ETIMEDOUT; 200171b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 2002b411b363SPhilipp Reisner break; 2003b411b363SPhilipp Reisner } 2004b411b363SPhilipp Reisner } 2005b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 20067be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 2007b411b363SPhilipp Reisner return ret; 2008b411b363SPhilipp Reisner } 2009b411b363SPhilipp Reisner 2010688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2011688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2012688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 2013688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 201476d2e7ecSPhilipp Reisner { 201576d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 201676d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 2017688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 201876d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 201976d2e7ecSPhilipp Reisner } 202076d2e7ecSPhilipp Reisner 20217be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 20227be8da07SAndreas Gruenbacher unsigned int size) 20237be8da07SAndreas Gruenbacher { 20247be8da07SAndreas Gruenbacher struct drbd_interval *i; 20257be8da07SAndreas Gruenbacher 20267be8da07SAndreas Gruenbacher repeat: 20277be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 20287be8da07SAndreas Gruenbacher struct drbd_request *req; 20297be8da07SAndreas Gruenbacher struct bio_and_error m; 20307be8da07SAndreas Gruenbacher 20317be8da07SAndreas Gruenbacher if (!i->local) 20327be8da07SAndreas Gruenbacher continue; 20337be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 20347be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 20357be8da07SAndreas Gruenbacher continue; 20367be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 20377be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 20387be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 20397be8da07SAndreas Gruenbacher if (m.bio) 20407be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 20417be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 20427be8da07SAndreas Gruenbacher goto repeat; 20437be8da07SAndreas Gruenbacher } 20447be8da07SAndreas Gruenbacher } 20457be8da07SAndreas Gruenbacher 20467be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 20477be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 20487be8da07SAndreas Gruenbacher { 20497be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 2050427c0434SLars Ellenberg bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &tconn->flags); 20517be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 20527be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 20537be8da07SAndreas Gruenbacher struct drbd_interval *i; 20547be8da07SAndreas Gruenbacher bool equal; 20557be8da07SAndreas Gruenbacher int err; 20567be8da07SAndreas Gruenbacher 20577be8da07SAndreas Gruenbacher /* 20587be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 20597be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 20607be8da07SAndreas Gruenbacher */ 20617be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 20627be8da07SAndreas Gruenbacher 20637be8da07SAndreas Gruenbacher repeat: 20647be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 20657be8da07SAndreas Gruenbacher if (i == &peer_req->i) 20667be8da07SAndreas Gruenbacher continue; 20677be8da07SAndreas Gruenbacher 20687be8da07SAndreas Gruenbacher if (!i->local) { 20697be8da07SAndreas Gruenbacher /* 20707be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 20717be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 20727be8da07SAndreas Gruenbacher * earlier peer request to complete. 20737be8da07SAndreas Gruenbacher */ 20747be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 20757be8da07SAndreas Gruenbacher if (err) 20767be8da07SAndreas Gruenbacher goto out; 20777be8da07SAndreas Gruenbacher goto repeat; 20787be8da07SAndreas Gruenbacher } 20797be8da07SAndreas Gruenbacher 20807be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 20817be8da07SAndreas Gruenbacher if (resolve_conflicts) { 20827be8da07SAndreas Gruenbacher /* 20837be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 2084d4dabbe2SLars Ellenberg * overlapping request, it can be considered overwritten 2085d4dabbe2SLars Ellenberg * and thus superseded; otherwise, it will be retried 2086d4dabbe2SLars Ellenberg * once all overlapping requests have completed. 20877be8da07SAndreas Gruenbacher */ 2088d4dabbe2SLars Ellenberg bool superseded = i->sector <= sector && i->sector + 20897be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 20907be8da07SAndreas Gruenbacher 20917be8da07SAndreas Gruenbacher if (!equal) 20927be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 20937be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 20947be8da07SAndreas Gruenbacher "assuming %s came first\n", 20957be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 20967be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 2097d4dabbe2SLars Ellenberg superseded ? "local" : "remote"); 20987be8da07SAndreas Gruenbacher 20997be8da07SAndreas Gruenbacher inc_unacked(mdev); 2100d4dabbe2SLars Ellenberg peer_req->w.cb = superseded ? e_send_superseded : 21017be8da07SAndreas Gruenbacher e_send_retry_write; 21027be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 21037be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 21047be8da07SAndreas Gruenbacher 21057be8da07SAndreas Gruenbacher err = -ENOENT; 21067be8da07SAndreas Gruenbacher goto out; 21077be8da07SAndreas Gruenbacher } else { 21087be8da07SAndreas Gruenbacher struct drbd_request *req = 21097be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 21107be8da07SAndreas Gruenbacher 21117be8da07SAndreas Gruenbacher if (!equal) 21127be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 21137be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 21147be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 21157be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 21167be8da07SAndreas Gruenbacher 21177be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 21187be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 21197be8da07SAndreas Gruenbacher /* 21207be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 2121d4dabbe2SLars Ellenberg * decide if this request has been superseded 2122d4dabbe2SLars Ellenberg * or needs to be retried. 2123d4dabbe2SLars Ellenberg * Requests that have been superseded will 21247be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 21257be8da07SAndreas Gruenbacher * 21267be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 21277be8da07SAndreas Gruenbacher * request to finish locally before submitting 21287be8da07SAndreas Gruenbacher * the conflicting peer request. 21297be8da07SAndreas Gruenbacher */ 21307be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 21317be8da07SAndreas Gruenbacher if (err) { 21327be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 21337be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 21347be8da07SAndreas Gruenbacher CS_HARD); 21357be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 21367be8da07SAndreas Gruenbacher goto out; 21377be8da07SAndreas Gruenbacher } 21387be8da07SAndreas Gruenbacher goto repeat; 21397be8da07SAndreas Gruenbacher } 21407be8da07SAndreas Gruenbacher /* 21417be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 21427be8da07SAndreas Gruenbacher * the new peer request has completed. 21437be8da07SAndreas Gruenbacher */ 21447be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 21457be8da07SAndreas Gruenbacher } 21467be8da07SAndreas Gruenbacher } 21477be8da07SAndreas Gruenbacher err = 0; 21487be8da07SAndreas Gruenbacher 21497be8da07SAndreas Gruenbacher out: 21507be8da07SAndreas Gruenbacher if (err) 21517be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 21527be8da07SAndreas Gruenbacher return err; 21537be8da07SAndreas Gruenbacher } 21547be8da07SAndreas Gruenbacher 2155b411b363SPhilipp Reisner /* mirrored write */ 21564a76b161SAndreas Gruenbacher static int receive_Data(struct drbd_tconn *tconn, struct packet_info *pi) 2157b411b363SPhilipp Reisner { 21584a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2159b411b363SPhilipp Reisner sector_t sector; 2160db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2161e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 21627be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2163b411b363SPhilipp Reisner int rw = WRITE; 2164b411b363SPhilipp Reisner u32 dp_flags; 2165302bdeaeSPhilipp Reisner int err, tp; 21667be8da07SAndreas Gruenbacher 21674a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 21684a76b161SAndreas Gruenbacher if (!mdev) 21694a76b161SAndreas Gruenbacher return -EIO; 21704a76b161SAndreas Gruenbacher 2171b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 217282bc0194SAndreas Gruenbacher int err2; 217382bc0194SAndreas Gruenbacher 21747be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 2175e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 217612038a3aSPhilipp Reisner atomic_inc(&tconn->current_epoch->epoch_size); 2177e2857216SAndreas Gruenbacher err2 = drbd_drain_block(mdev, pi->size); 217882bc0194SAndreas Gruenbacher if (!err) 217982bc0194SAndreas Gruenbacher err = err2; 218082bc0194SAndreas Gruenbacher return err; 2181b411b363SPhilipp Reisner } 2182b411b363SPhilipp Reisner 2183fcefa62eSAndreas Gruenbacher /* 2184fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2185fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2186fcefa62eSAndreas Gruenbacher * end of this function. 2187fcefa62eSAndreas Gruenbacher */ 2188b411b363SPhilipp Reisner 2189b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2190e2857216SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, pi->size); 2191db830c46SAndreas Gruenbacher if (!peer_req) { 2192b411b363SPhilipp Reisner put_ldev(mdev); 219382bc0194SAndreas Gruenbacher return -EIO; 2194b411b363SPhilipp Reisner } 2195b411b363SPhilipp Reisner 2196db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 2197b411b363SPhilipp Reisner 2198688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2199688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 220081a3537aSLars Ellenberg if (peer_req->pages == NULL) { 220181a3537aSLars Ellenberg D_ASSERT(peer_req->i.size == 0); 220281a3537aSLars Ellenberg D_ASSERT(dp_flags & DP_FLUSH); 220381a3537aSLars Ellenberg } 2204688593c5SLars Ellenberg 2205688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2206db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2207688593c5SLars Ellenberg 220812038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 220912038a3aSPhilipp Reisner peer_req->epoch = tconn->current_epoch; 2210db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2211db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 221212038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 2213b411b363SPhilipp Reisner 2214302bdeaeSPhilipp Reisner rcu_read_lock(); 2215302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 2216302bdeaeSPhilipp Reisner rcu_read_unlock(); 2217302bdeaeSPhilipp Reisner if (tp) { 2218302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 22197be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 22207be8da07SAndreas Gruenbacher if (err) 2221b411b363SPhilipp Reisner goto out_interrupted; 222287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 22237be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 22247be8da07SAndreas Gruenbacher if (err) { 222587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 22267be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2227b411b363SPhilipp Reisner put_ldev(mdev); 222882bc0194SAndreas Gruenbacher return 0; 2229b411b363SPhilipp Reisner } 2230b411b363SPhilipp Reisner goto out_interrupted; 2231b411b363SPhilipp Reisner } 22327be8da07SAndreas Gruenbacher } else 223387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2234db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 223587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2236b411b363SPhilipp Reisner 2237d93f6302SLars Ellenberg if (mdev->state.conn == C_SYNC_TARGET) 22383ea35df8SPhilipp Reisner wait_event(mdev->ee_wait, !overlapping_resync_write(mdev, peer_req)); 2239d93f6302SLars Ellenberg 2240303d1448SPhilipp Reisner if (mdev->tconn->agreed_pro_version < 100) { 224144ed167dSPhilipp Reisner rcu_read_lock(); 224244ed167dSPhilipp Reisner switch (rcu_dereference(mdev->tconn->net_conf)->wire_protocol) { 2243b411b363SPhilipp Reisner case DRBD_PROT_C: 2244303d1448SPhilipp Reisner dp_flags |= DP_SEND_WRITE_ACK; 2245303d1448SPhilipp Reisner break; 2246303d1448SPhilipp Reisner case DRBD_PROT_B: 2247303d1448SPhilipp Reisner dp_flags |= DP_SEND_RECEIVE_ACK; 2248303d1448SPhilipp Reisner break; 2249303d1448SPhilipp Reisner } 225044ed167dSPhilipp Reisner rcu_read_unlock(); 2251303d1448SPhilipp Reisner } 2252303d1448SPhilipp Reisner 2253303d1448SPhilipp Reisner if (dp_flags & DP_SEND_WRITE_ACK) { 2254303d1448SPhilipp Reisner peer_req->flags |= EE_SEND_WRITE_ACK; 2255b411b363SPhilipp Reisner inc_unacked(mdev); 2256b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2257b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2258303d1448SPhilipp Reisner } 2259303d1448SPhilipp Reisner 2260303d1448SPhilipp Reisner if (dp_flags & DP_SEND_RECEIVE_ACK) { 2261b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2262b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2263db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2264b411b363SPhilipp Reisner } 2265b411b363SPhilipp Reisner 22666719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2267b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2268db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2269db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2270db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2271181286adSLars Ellenberg drbd_al_begin_io(mdev, &peer_req->i); 2272b411b363SPhilipp Reisner } 2273b411b363SPhilipp Reisner 227482bc0194SAndreas Gruenbacher err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR); 227582bc0194SAndreas Gruenbacher if (!err) 227682bc0194SAndreas Gruenbacher return 0; 2277b411b363SPhilipp Reisner 227810f6d992SLars Ellenberg /* don't care for the reason here */ 227910f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 228087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2281db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2282db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 228387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2284db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2285181286adSLars Ellenberg drbd_al_complete_io(mdev, &peer_req->i); 228622cc37a9SLars Ellenberg 2287b411b363SPhilipp Reisner out_interrupted: 22881e9dd291SPhilipp Reisner drbd_may_finish_epoch(tconn, peer_req->epoch, EV_PUT + EV_CLEANUP); 2289b411b363SPhilipp Reisner put_ldev(mdev); 22903967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 229182bc0194SAndreas Gruenbacher return err; 2292b411b363SPhilipp Reisner } 2293b411b363SPhilipp Reisner 22940f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 22950f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 22960f0601f4SLars Ellenberg * 22970f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 22980f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 22990f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 23000f0601f4SLars Ellenberg * activity, it obviously is "busy". 23010f0601f4SLars Ellenberg * 23020f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 23030f0601f4SLars Ellenberg * to have a short time average so we can react faster. 23040f0601f4SLars Ellenberg */ 2305e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 23060f0601f4SLars Ellenberg { 23070f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 23080f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2309e3555d85SPhilipp Reisner struct lc_element *tmp; 23100f0601f4SLars Ellenberg int curr_events; 23110f0601f4SLars Ellenberg int throttle = 0; 2312daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2313daeda1ccSPhilipp Reisner 2314daeda1ccSPhilipp Reisner rcu_read_lock(); 2315daeda1ccSPhilipp Reisner c_min_rate = rcu_dereference(mdev->ldev->disk_conf)->c_min_rate; 2316daeda1ccSPhilipp Reisner rcu_read_unlock(); 23170f0601f4SLars Ellenberg 23180f0601f4SLars Ellenberg /* feature disabled? */ 2319daeda1ccSPhilipp Reisner if (c_min_rate == 0) 23200f0601f4SLars Ellenberg return 0; 23210f0601f4SLars Ellenberg 2322e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2323e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2324e3555d85SPhilipp Reisner if (tmp) { 2325e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2326e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2327e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2328e3555d85SPhilipp Reisner return 0; 2329e3555d85SPhilipp Reisner } 2330e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2331e3555d85SPhilipp Reisner } 2332e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2333e3555d85SPhilipp Reisner 23340f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 23350f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 23360f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2337e3555d85SPhilipp Reisner 23380f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 23390f0601f4SLars Ellenberg unsigned long rs_left; 23400f0601f4SLars Ellenberg int i; 23410f0601f4SLars Ellenberg 23420f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 23430f0601f4SLars Ellenberg 23440f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 23450f0601f4SLars Ellenberg * approx. */ 23462649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 23472649f080SLars Ellenberg 23482649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 23492649f080SLars Ellenberg rs_left = mdev->ov_left; 23502649f080SLars Ellenberg else 23510f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 23520f0601f4SLars Ellenberg 23530f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 23540f0601f4SLars Ellenberg if (!dt) 23550f0601f4SLars Ellenberg dt++; 23560f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 23570f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 23580f0601f4SLars Ellenberg 2359daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 23600f0601f4SLars Ellenberg throttle = 1; 23610f0601f4SLars Ellenberg } 23620f0601f4SLars Ellenberg return throttle; 23630f0601f4SLars Ellenberg } 23640f0601f4SLars Ellenberg 23650f0601f4SLars Ellenberg 23664a76b161SAndreas Gruenbacher static int receive_DataRequest(struct drbd_tconn *tconn, struct packet_info *pi) 2367b411b363SPhilipp Reisner { 23684a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2369b411b363SPhilipp Reisner sector_t sector; 23704a76b161SAndreas Gruenbacher sector_t capacity; 2371db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2372b411b363SPhilipp Reisner struct digest_info *di = NULL; 2373b18b37beSPhilipp Reisner int size, verb; 2374b411b363SPhilipp Reisner unsigned int fault_type; 2375e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 23764a76b161SAndreas Gruenbacher 23774a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 23784a76b161SAndreas Gruenbacher if (!mdev) 23794a76b161SAndreas Gruenbacher return -EIO; 23804a76b161SAndreas Gruenbacher capacity = drbd_get_capacity(mdev->this_bdev); 2381b411b363SPhilipp Reisner 2382b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2383b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2384b411b363SPhilipp Reisner 2385c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2386b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2387b411b363SPhilipp Reisner (unsigned long long)sector, size); 238882bc0194SAndreas Gruenbacher return -EINVAL; 2389b411b363SPhilipp Reisner } 2390b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2391b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2392b411b363SPhilipp Reisner (unsigned long long)sector, size); 239382bc0194SAndreas Gruenbacher return -EINVAL; 2394b411b363SPhilipp Reisner } 2395b411b363SPhilipp Reisner 2396b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2397b18b37beSPhilipp Reisner verb = 1; 2398e2857216SAndreas Gruenbacher switch (pi->cmd) { 2399b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2400b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2401b18b37beSPhilipp Reisner break; 2402b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2403b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2404b18b37beSPhilipp Reisner case P_OV_REQUEST: 2405b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2406b18b37beSPhilipp Reisner break; 2407b18b37beSPhilipp Reisner case P_OV_REPLY: 2408b18b37beSPhilipp Reisner verb = 0; 2409b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2410b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2411b18b37beSPhilipp Reisner break; 2412b18b37beSPhilipp Reisner default: 241349ba9b1bSAndreas Gruenbacher BUG(); 2414b18b37beSPhilipp Reisner } 2415b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2416b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2417b411b363SPhilipp Reisner "no local data.\n"); 2418b18b37beSPhilipp Reisner 2419a821cc4aSLars Ellenberg /* drain possibly payload */ 2420e2857216SAndreas Gruenbacher return drbd_drain_block(mdev, pi->size); 2421b411b363SPhilipp Reisner } 2422b411b363SPhilipp Reisner 2423b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2424b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2425b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 24260db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, p->block_id, sector, size, GFP_NOIO); 2427db830c46SAndreas Gruenbacher if (!peer_req) { 2428b411b363SPhilipp Reisner put_ldev(mdev); 242982bc0194SAndreas Gruenbacher return -ENOMEM; 2430b411b363SPhilipp Reisner } 2431b411b363SPhilipp Reisner 2432e2857216SAndreas Gruenbacher switch (pi->cmd) { 2433b411b363SPhilipp Reisner case P_DATA_REQUEST: 2434db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2435b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 243680a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 243780a40e43SLars Ellenberg goto submit; 243880a40e43SLars Ellenberg 2439b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2440db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2441b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 24425f9915bbSLars Ellenberg /* used in the sector offset progress display */ 24435f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2444b411b363SPhilipp Reisner break; 2445b411b363SPhilipp Reisner 2446b411b363SPhilipp Reisner case P_OV_REPLY: 2447b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2448b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2449e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2450b411b363SPhilipp Reisner if (!di) 2451b411b363SPhilipp Reisner goto out_free_e; 2452b411b363SPhilipp Reisner 2453e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2454b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2455b411b363SPhilipp Reisner 2456db830c46SAndreas Gruenbacher peer_req->digest = di; 2457db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2458c36c3cedSLars Ellenberg 2459e2857216SAndreas Gruenbacher if (drbd_recv_all(mdev->tconn, di->digest, pi->size)) 2460b411b363SPhilipp Reisner goto out_free_e; 2461b411b363SPhilipp Reisner 2462e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 246331890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2464db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 24655f9915bbSLars Ellenberg /* used in the sector offset progress display */ 24665f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2467e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 24682649f080SLars Ellenberg /* track progress, we may need to throttle */ 24692649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2470db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2471b411b363SPhilipp Reisner dec_rs_pending(mdev); 24720f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 24730f0601f4SLars Ellenberg * but accounting still needs to be done. */ 24740f0601f4SLars Ellenberg goto submit_for_resync; 2475b411b363SPhilipp Reisner } 2476b411b363SPhilipp Reisner break; 2477b411b363SPhilipp Reisner 2478b411b363SPhilipp Reisner case P_OV_REQUEST: 2479b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 248031890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2481de228bbaSLars Ellenberg unsigned long now = jiffies; 2482de228bbaSLars Ellenberg int i; 2483b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2484b411b363SPhilipp Reisner mdev->ov_position = sector; 248530b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 248630b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2487de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2488de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2489de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2490de228bbaSLars Ellenberg } 2491b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2492b411b363SPhilipp Reisner (unsigned long long)sector); 2493b411b363SPhilipp Reisner } 2494db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2495b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2496b411b363SPhilipp Reisner break; 2497b411b363SPhilipp Reisner 2498b411b363SPhilipp Reisner default: 249949ba9b1bSAndreas Gruenbacher BUG(); 2500b411b363SPhilipp Reisner } 2501b411b363SPhilipp Reisner 25020f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 25030f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 25040f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 25050f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 25060f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 25070f0601f4SLars Ellenberg * 25080f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 25090f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 25100f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 25110f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 25120f0601f4SLars Ellenberg * a while, anyways. 25130f0601f4SLars Ellenberg */ 2514b411b363SPhilipp Reisner 25150f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 25160f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 25170f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 25180f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 25190f0601f4SLars Ellenberg * 25200f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 25210f0601f4SLars Ellenberg * we would also throttle its application reads. 25220f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 25230f0601f4SLars Ellenberg */ 2524e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2525e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2526e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 252780a40e43SLars Ellenberg goto out_free_e; 2528b411b363SPhilipp Reisner 25290f0601f4SLars Ellenberg submit_for_resync: 25300f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 25310f0601f4SLars Ellenberg 253280a40e43SLars Ellenberg submit: 2533b411b363SPhilipp Reisner inc_unacked(mdev); 253487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2535db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 253687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2537b411b363SPhilipp Reisner 2538fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 253982bc0194SAndreas Gruenbacher return 0; 2540b411b363SPhilipp Reisner 254110f6d992SLars Ellenberg /* don't care for the reason here */ 254210f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 254387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2544db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 254587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 254622cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 254722cc37a9SLars Ellenberg 2548b411b363SPhilipp Reisner out_free_e: 2549b411b363SPhilipp Reisner put_ldev(mdev); 25503967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 255182bc0194SAndreas Gruenbacher return -EIO; 2552b411b363SPhilipp Reisner } 2553b411b363SPhilipp Reisner 2554b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2555b411b363SPhilipp Reisner { 2556b411b363SPhilipp Reisner int self, peer, rv = -100; 2557b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 255844ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2559b411b363SPhilipp Reisner 2560b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2561b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2562b411b363SPhilipp Reisner 2563b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2564b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2565b411b363SPhilipp Reisner 256644ed167dSPhilipp Reisner rcu_read_lock(); 256744ed167dSPhilipp Reisner after_sb_0p = rcu_dereference(mdev->tconn->net_conf)->after_sb_0p; 256844ed167dSPhilipp Reisner rcu_read_unlock(); 256944ed167dSPhilipp Reisner switch (after_sb_0p) { 2570b411b363SPhilipp Reisner case ASB_CONSENSUS: 2571b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2572b411b363SPhilipp Reisner case ASB_CALL_HELPER: 257344ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2574b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2575b411b363SPhilipp Reisner break; 2576b411b363SPhilipp Reisner case ASB_DISCONNECT: 2577b411b363SPhilipp Reisner break; 2578b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2579b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2580b411b363SPhilipp Reisner rv = -1; 2581b411b363SPhilipp Reisner break; 2582b411b363SPhilipp Reisner } 2583b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2584b411b363SPhilipp Reisner rv = 1; 2585b411b363SPhilipp Reisner break; 2586b411b363SPhilipp Reisner } 2587b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2588b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2589b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2590b411b363SPhilipp Reisner rv = 1; 2591b411b363SPhilipp Reisner break; 2592b411b363SPhilipp Reisner } 2593b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2594b411b363SPhilipp Reisner rv = -1; 2595b411b363SPhilipp Reisner break; 2596b411b363SPhilipp Reisner } 2597b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2598ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2599b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2600b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2601b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 2602427c0434SLars Ellenberg rv = test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags) 2603b411b363SPhilipp Reisner ? -1 : 1; 2604b411b363SPhilipp Reisner break; 2605b411b363SPhilipp Reisner } else { 2606b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2607b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2608b411b363SPhilipp Reisner } 260944ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2610b411b363SPhilipp Reisner break; 2611b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2612b411b363SPhilipp Reisner if (ch_self < ch_peer) 2613b411b363SPhilipp Reisner rv = -1; 2614b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2615b411b363SPhilipp Reisner rv = 1; 2616b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2617b411b363SPhilipp Reisner /* Well, then use something else. */ 2618427c0434SLars Ellenberg rv = test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags) 2619b411b363SPhilipp Reisner ? -1 : 1; 2620b411b363SPhilipp Reisner break; 2621b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2622b411b363SPhilipp Reisner rv = -1; 2623b411b363SPhilipp Reisner break; 2624b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2625b411b363SPhilipp Reisner rv = 1; 2626b411b363SPhilipp Reisner } 2627b411b363SPhilipp Reisner 2628b411b363SPhilipp Reisner return rv; 2629b411b363SPhilipp Reisner } 2630b411b363SPhilipp Reisner 2631b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2632b411b363SPhilipp Reisner { 26336184ea21SAndreas Gruenbacher int hg, rv = -100; 263444ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2635b411b363SPhilipp Reisner 263644ed167dSPhilipp Reisner rcu_read_lock(); 263744ed167dSPhilipp Reisner after_sb_1p = rcu_dereference(mdev->tconn->net_conf)->after_sb_1p; 263844ed167dSPhilipp Reisner rcu_read_unlock(); 263944ed167dSPhilipp Reisner switch (after_sb_1p) { 2640b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2641b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2642b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2643b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2644b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 264544ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2646b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2647b411b363SPhilipp Reisner break; 2648b411b363SPhilipp Reisner case ASB_DISCONNECT: 2649b411b363SPhilipp Reisner break; 2650b411b363SPhilipp Reisner case ASB_CONSENSUS: 2651b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2652b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2653b411b363SPhilipp Reisner rv = hg; 2654b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2655b411b363SPhilipp Reisner rv = hg; 2656b411b363SPhilipp Reisner break; 2657b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2658b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2659b411b363SPhilipp Reisner break; 2660b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2661b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2662b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2663b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2664b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2665bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2666bb437946SAndreas Gruenbacher 2667bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2668b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2669b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2670b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2671bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2672bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2673b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2674b411b363SPhilipp Reisner } else { 2675b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2676b411b363SPhilipp Reisner rv = hg; 2677b411b363SPhilipp Reisner } 2678b411b363SPhilipp Reisner } else 2679b411b363SPhilipp Reisner rv = hg; 2680b411b363SPhilipp Reisner } 2681b411b363SPhilipp Reisner 2682b411b363SPhilipp Reisner return rv; 2683b411b363SPhilipp Reisner } 2684b411b363SPhilipp Reisner 2685b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2686b411b363SPhilipp Reisner { 26876184ea21SAndreas Gruenbacher int hg, rv = -100; 268844ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2689b411b363SPhilipp Reisner 269044ed167dSPhilipp Reisner rcu_read_lock(); 269144ed167dSPhilipp Reisner after_sb_2p = rcu_dereference(mdev->tconn->net_conf)->after_sb_2p; 269244ed167dSPhilipp Reisner rcu_read_unlock(); 269344ed167dSPhilipp Reisner switch (after_sb_2p) { 2694b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2695b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2696b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2697b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2698b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2699b411b363SPhilipp Reisner case ASB_CONSENSUS: 2700b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 270144ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2702b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2703b411b363SPhilipp Reisner break; 2704b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2705b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2706b411b363SPhilipp Reisner break; 2707b411b363SPhilipp Reisner case ASB_DISCONNECT: 2708b411b363SPhilipp Reisner break; 2709b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2710b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2711b411b363SPhilipp Reisner if (hg == -1) { 2712bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2713bb437946SAndreas Gruenbacher 2714b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2715b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2716b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2717bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2718bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2719b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2720b411b363SPhilipp Reisner } else { 2721b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2722b411b363SPhilipp Reisner rv = hg; 2723b411b363SPhilipp Reisner } 2724b411b363SPhilipp Reisner } else 2725b411b363SPhilipp Reisner rv = hg; 2726b411b363SPhilipp Reisner } 2727b411b363SPhilipp Reisner 2728b411b363SPhilipp Reisner return rv; 2729b411b363SPhilipp Reisner } 2730b411b363SPhilipp Reisner 2731b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2732b411b363SPhilipp Reisner u64 bits, u64 flags) 2733b411b363SPhilipp Reisner { 2734b411b363SPhilipp Reisner if (!uuid) { 2735b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2736b411b363SPhilipp Reisner return; 2737b411b363SPhilipp Reisner } 2738b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2739b411b363SPhilipp Reisner text, 2740b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2741b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2742b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2743b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2744b411b363SPhilipp Reisner (unsigned long long)bits, 2745b411b363SPhilipp Reisner (unsigned long long)flags); 2746b411b363SPhilipp Reisner } 2747b411b363SPhilipp Reisner 2748b411b363SPhilipp Reisner /* 2749b411b363SPhilipp Reisner 100 after split brain try auto recover 2750b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2751b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2752b411b363SPhilipp Reisner 0 no Sync 2753b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2754b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2755b411b363SPhilipp Reisner -100 after split brain, disconnect 2756b411b363SPhilipp Reisner -1000 unrelated data 27574a23f264SPhilipp Reisner -1091 requires proto 91 27584a23f264SPhilipp Reisner -1096 requires proto 96 2759b411b363SPhilipp Reisner */ 2760b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2761b411b363SPhilipp Reisner { 2762b411b363SPhilipp Reisner u64 self, peer; 2763b411b363SPhilipp Reisner int i, j; 2764b411b363SPhilipp Reisner 2765b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2766b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2767b411b363SPhilipp Reisner 2768b411b363SPhilipp Reisner *rule_nr = 10; 2769b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2770b411b363SPhilipp Reisner return 0; 2771b411b363SPhilipp Reisner 2772b411b363SPhilipp Reisner *rule_nr = 20; 2773b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2774b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2775b411b363SPhilipp Reisner return -2; 2776b411b363SPhilipp Reisner 2777b411b363SPhilipp Reisner *rule_nr = 30; 2778b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2779b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2780b411b363SPhilipp Reisner return 2; 2781b411b363SPhilipp Reisner 2782b411b363SPhilipp Reisner if (self == peer) { 2783b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2784b411b363SPhilipp Reisner 2785b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2786b411b363SPhilipp Reisner 278731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27884a23f264SPhilipp Reisner return -1091; 2789b411b363SPhilipp Reisner 2790b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2791b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2792b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 279339a1aa7fSPhilipp Reisner drbd_uuid_move_history(mdev); 279439a1aa7fSPhilipp Reisner mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[UI_BITMAP]; 279539a1aa7fSPhilipp Reisner mdev->ldev->md.uuid[UI_BITMAP] = 0; 2796b411b363SPhilipp Reisner 2797b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2798b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2799b411b363SPhilipp Reisner *rule_nr = 34; 2800b411b363SPhilipp Reisner } else { 2801b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2802b411b363SPhilipp Reisner *rule_nr = 36; 2803b411b363SPhilipp Reisner } 2804b411b363SPhilipp Reisner 2805b411b363SPhilipp Reisner return 1; 2806b411b363SPhilipp Reisner } 2807b411b363SPhilipp Reisner 2808b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2809b411b363SPhilipp Reisner 281031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28114a23f264SPhilipp Reisner return -1091; 2812b411b363SPhilipp Reisner 2813b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2814b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2815b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2816b411b363SPhilipp Reisner 2817b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2818b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2819b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2820b411b363SPhilipp Reisner 2821b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2822b411b363SPhilipp Reisner *rule_nr = 35; 2823b411b363SPhilipp Reisner } else { 2824b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2825b411b363SPhilipp Reisner *rule_nr = 37; 2826b411b363SPhilipp Reisner } 2827b411b363SPhilipp Reisner 2828b411b363SPhilipp Reisner return -1; 2829b411b363SPhilipp Reisner } 2830b411b363SPhilipp Reisner 2831b411b363SPhilipp Reisner /* Common power [off|failure] */ 2832b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2833b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2834b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2835b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2836b411b363SPhilipp Reisner *rule_nr = 40; 2837b411b363SPhilipp Reisner 2838b411b363SPhilipp Reisner switch (rct) { 2839b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2840b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2841b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2842b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 2843427c0434SLars Ellenberg dc = test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags); 2844b411b363SPhilipp Reisner return dc ? -1 : 1; 2845b411b363SPhilipp Reisner } 2846b411b363SPhilipp Reisner } 2847b411b363SPhilipp Reisner 2848b411b363SPhilipp Reisner *rule_nr = 50; 2849b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2850b411b363SPhilipp Reisner if (self == peer) 2851b411b363SPhilipp Reisner return -1; 2852b411b363SPhilipp Reisner 2853b411b363SPhilipp Reisner *rule_nr = 51; 2854b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2855b411b363SPhilipp Reisner if (self == peer) { 285631890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 28574a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 28584a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 28594a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2860b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2861b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2862b411b363SPhilipp Reisner 286331890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28644a23f264SPhilipp Reisner return -1091; 2865b411b363SPhilipp Reisner 2866b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2867b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 28684a23f264SPhilipp Reisner 28691882e22dSLars Ellenberg dev_info(DEV, "Lost last syncUUID packet, corrected:\n"); 28704a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 28714a23f264SPhilipp Reisner 2872b411b363SPhilipp Reisner return -1; 2873b411b363SPhilipp Reisner } 2874b411b363SPhilipp Reisner } 2875b411b363SPhilipp Reisner 2876b411b363SPhilipp Reisner *rule_nr = 60; 2877b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2878b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2879b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2880b411b363SPhilipp Reisner if (self == peer) 2881b411b363SPhilipp Reisner return -2; 2882b411b363SPhilipp Reisner } 2883b411b363SPhilipp Reisner 2884b411b363SPhilipp Reisner *rule_nr = 70; 2885b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2886b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2887b411b363SPhilipp Reisner if (self == peer) 2888b411b363SPhilipp Reisner return 1; 2889b411b363SPhilipp Reisner 2890b411b363SPhilipp Reisner *rule_nr = 71; 2891b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2892b411b363SPhilipp Reisner if (self == peer) { 289331890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 28944a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 28954a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 28964a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2897b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2898b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2899b411b363SPhilipp Reisner 290031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 29014a23f264SPhilipp Reisner return -1091; 2902b411b363SPhilipp Reisner 290339a1aa7fSPhilipp Reisner __drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 290439a1aa7fSPhilipp Reisner __drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2905b411b363SPhilipp Reisner 29064a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2907b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2908b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2909b411b363SPhilipp Reisner 2910b411b363SPhilipp Reisner return 1; 2911b411b363SPhilipp Reisner } 2912b411b363SPhilipp Reisner } 2913b411b363SPhilipp Reisner 2914b411b363SPhilipp Reisner 2915b411b363SPhilipp Reisner *rule_nr = 80; 2916d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2917b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2918b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2919b411b363SPhilipp Reisner if (self == peer) 2920b411b363SPhilipp Reisner return 2; 2921b411b363SPhilipp Reisner } 2922b411b363SPhilipp Reisner 2923b411b363SPhilipp Reisner *rule_nr = 90; 2924b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2925b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2926b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2927b411b363SPhilipp Reisner return 100; 2928b411b363SPhilipp Reisner 2929b411b363SPhilipp Reisner *rule_nr = 100; 2930b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2931b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2932b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2933b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2934b411b363SPhilipp Reisner if (self == peer) 2935b411b363SPhilipp Reisner return -100; 2936b411b363SPhilipp Reisner } 2937b411b363SPhilipp Reisner } 2938b411b363SPhilipp Reisner 2939b411b363SPhilipp Reisner return -1000; 2940b411b363SPhilipp Reisner } 2941b411b363SPhilipp Reisner 2942b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2943b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2944b411b363SPhilipp Reisner */ 2945b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2946b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2947b411b363SPhilipp Reisner { 2948b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2949b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 295044ed167dSPhilipp Reisner struct net_conf *nc; 29516dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 2952b411b363SPhilipp Reisner 2953b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2954b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2955b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2956b411b363SPhilipp Reisner 2957b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 295839a1aa7fSPhilipp Reisner 295939a1aa7fSPhilipp Reisner spin_lock_irq(&mdev->ldev->md.uuid_lock); 2960b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2961b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2962b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2963b411b363SPhilipp Reisner 2964b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 296539a1aa7fSPhilipp Reisner spin_unlock_irq(&mdev->ldev->md.uuid_lock); 2966b411b363SPhilipp Reisner 2967b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2968b411b363SPhilipp Reisner 2969b411b363SPhilipp Reisner if (hg == -1000) { 2970b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2971b411b363SPhilipp Reisner return C_MASK; 2972b411b363SPhilipp Reisner } 29734a23f264SPhilipp Reisner if (hg < -1000) { 29744a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2975b411b363SPhilipp Reisner return C_MASK; 2976b411b363SPhilipp Reisner } 2977b411b363SPhilipp Reisner 2978b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2979b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2980b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2981b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2982b411b363SPhilipp Reisner if (f) 2983b411b363SPhilipp Reisner hg = hg*2; 2984b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2985b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2986b411b363SPhilipp Reisner } 2987b411b363SPhilipp Reisner 29883a11a487SAdam Gandelman if (abs(hg) == 100) 29893a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 29903a11a487SAdam Gandelman 299144ed167dSPhilipp Reisner rcu_read_lock(); 299244ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 299344ed167dSPhilipp Reisner 299444ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 2995b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2996b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2997b411b363SPhilipp Reisner int forced = (hg == -100); 2998b411b363SPhilipp Reisner 2999b411b363SPhilipp Reisner switch (pcount) { 3000b411b363SPhilipp Reisner case 0: 3001b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 3002b411b363SPhilipp Reisner break; 3003b411b363SPhilipp Reisner case 1: 3004b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 3005b411b363SPhilipp Reisner break; 3006b411b363SPhilipp Reisner case 2: 3007b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 3008b411b363SPhilipp Reisner break; 3009b411b363SPhilipp Reisner } 3010b411b363SPhilipp Reisner if (abs(hg) < 100) { 3011b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 3012b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3013b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3014b411b363SPhilipp Reisner if (forced) { 3015b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 3016b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3017b411b363SPhilipp Reisner hg = hg*2; 3018b411b363SPhilipp Reisner } 3019b411b363SPhilipp Reisner } 3020b411b363SPhilipp Reisner } 3021b411b363SPhilipp Reisner 3022b411b363SPhilipp Reisner if (hg == -100) { 302308b165baSPhilipp Reisner if (test_bit(DISCARD_MY_DATA, &mdev->flags) && !(mdev->p_uuid[UI_FLAGS]&1)) 3024b411b363SPhilipp Reisner hg = -1; 302508b165baSPhilipp Reisner if (!test_bit(DISCARD_MY_DATA, &mdev->flags) && (mdev->p_uuid[UI_FLAGS]&1)) 3026b411b363SPhilipp Reisner hg = 1; 3027b411b363SPhilipp Reisner 3028b411b363SPhilipp Reisner if (abs(hg) < 100) 3029b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 3030b411b363SPhilipp Reisner "Sync from %s node\n", 3031b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3032b411b363SPhilipp Reisner } 303344ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 30346dff2902SAndreas Gruenbacher tentative = nc->tentative; 303544ed167dSPhilipp Reisner rcu_read_unlock(); 3036b411b363SPhilipp Reisner 3037b411b363SPhilipp Reisner if (hg == -100) { 3038580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3039580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3040580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3041580b9767SLars Ellenberg * to that disk, in a way... */ 30423a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 3043b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 3044b411b363SPhilipp Reisner return C_MASK; 3045b411b363SPhilipp Reisner } 3046b411b363SPhilipp Reisner 3047b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3048b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 3049b411b363SPhilipp Reisner return C_MASK; 3050b411b363SPhilipp Reisner } 3051b411b363SPhilipp Reisner 3052b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3053b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 305444ed167dSPhilipp Reisner switch (rr_conflict) { 3055b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3056b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 3057b411b363SPhilipp Reisner /* fall through */ 3058b411b363SPhilipp Reisner case ASB_DISCONNECT: 3059b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 3060b411b363SPhilipp Reisner return C_MASK; 3061b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3062b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 3063b411b363SPhilipp Reisner "assumption\n"); 3064b411b363SPhilipp Reisner } 3065b411b363SPhilipp Reisner } 3066b411b363SPhilipp Reisner 30676dff2902SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 3068cf14c2e9SPhilipp Reisner if (hg == 0) 3069cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 3070cf14c2e9SPhilipp Reisner else 3071cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 3072cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3073cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3074cf14c2e9SPhilipp Reisner return C_MASK; 3075cf14c2e9SPhilipp Reisner } 3076cf14c2e9SPhilipp Reisner 3077b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3078b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 307920ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 308020ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3081b411b363SPhilipp Reisner return C_MASK; 3082b411b363SPhilipp Reisner } 3083b411b363SPhilipp Reisner 3084b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3085b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3086b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3087b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3088b411b363SPhilipp Reisner } else { 3089b411b363SPhilipp Reisner rv = C_CONNECTED; 3090b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 3091b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 3092b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 3093b411b363SPhilipp Reisner } 3094b411b363SPhilipp Reisner } 3095b411b363SPhilipp Reisner 3096b411b363SPhilipp Reisner return rv; 3097b411b363SPhilipp Reisner } 3098b411b363SPhilipp Reisner 3099f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3100b411b363SPhilipp Reisner { 3101b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3102f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3103f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3104b411b363SPhilipp Reisner 3105b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3106f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3107f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3108b411b363SPhilipp Reisner 3109b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3110f179d76dSPhilipp Reisner return peer; 3111b411b363SPhilipp Reisner } 3112b411b363SPhilipp Reisner 3113e2857216SAndreas Gruenbacher static int receive_protocol(struct drbd_tconn *tconn, struct packet_info *pi) 3114b411b363SPhilipp Reisner { 3115e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3116036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3117036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3118036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3119036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 3120accdbcc5SAndreas Gruenbacher struct crypto_hash *peer_integrity_tfm = NULL; 31217aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3122b411b363SPhilipp Reisner 3123b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3124b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3125b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3126b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3127b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3128cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 31296139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3130cf14c2e9SPhilipp Reisner 313186db0618SAndreas Gruenbacher if (tconn->agreed_pro_version >= 87) { 313286db0618SAndreas Gruenbacher int err; 313386db0618SAndreas Gruenbacher 313488104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 313586db0618SAndreas Gruenbacher return -EIO; 313688104ca4SAndreas Gruenbacher err = drbd_recv_all(tconn, integrity_alg, pi->size); 313786db0618SAndreas Gruenbacher if (err) 313886db0618SAndreas Gruenbacher return err; 313988104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3140036b17eaSPhilipp Reisner } 314186db0618SAndreas Gruenbacher 31427d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 31437204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 3144cf14c2e9SPhilipp Reisner 3145cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 31467204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 3147b411b363SPhilipp Reisner 314844ed167dSPhilipp Reisner rcu_read_lock(); 314944ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 315044ed167dSPhilipp Reisner 3151036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 3152d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "protocol"); 315344ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3154b411b363SPhilipp Reisner } 3155b411b363SPhilipp Reisner 3156f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 3157d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-0pri"); 315844ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3159b411b363SPhilipp Reisner } 3160b411b363SPhilipp Reisner 3161f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 3162d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-1pri"); 316344ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3164b411b363SPhilipp Reisner } 3165b411b363SPhilipp Reisner 3166f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 3167d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-2pri"); 316844ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3169b411b363SPhilipp Reisner } 3170b411b363SPhilipp Reisner 31716139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 3172d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "discard-my-data"); 317344ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3174b411b363SPhilipp Reisner } 3175b411b363SPhilipp Reisner 317644ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 3177d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "allow-two-primaries"); 317844ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3179b411b363SPhilipp Reisner } 3180b411b363SPhilipp Reisner 3181036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 3182d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "data-integrity-alg"); 3183036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3184036b17eaSPhilipp Reisner } 3185036b17eaSPhilipp Reisner 318686db0618SAndreas Gruenbacher rcu_read_unlock(); 3187fbc12f45SAndreas Gruenbacher } 31887d4c782cSAndreas Gruenbacher 31897d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 31907d4c782cSAndreas Gruenbacher int hash_size; 31917d4c782cSAndreas Gruenbacher 31927d4c782cSAndreas Gruenbacher /* 31937d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 31947d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 31957d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 31967d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 31977d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 31987d4c782cSAndreas Gruenbacher * change. 31997d4c782cSAndreas Gruenbacher */ 32007d4c782cSAndreas Gruenbacher 32017d4c782cSAndreas Gruenbacher peer_integrity_tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 32027d4c782cSAndreas Gruenbacher if (!peer_integrity_tfm) { 32037d4c782cSAndreas Gruenbacher conn_err(tconn, "peer data-integrity-alg %s not supported\n", 32047d4c782cSAndreas Gruenbacher integrity_alg); 32057d4c782cSAndreas Gruenbacher goto disconnect; 32067d4c782cSAndreas Gruenbacher } 32077d4c782cSAndreas Gruenbacher 32087d4c782cSAndreas Gruenbacher hash_size = crypto_hash_digestsize(peer_integrity_tfm); 32097d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 32107d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 32117d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 32127d4c782cSAndreas Gruenbacher conn_err(tconn, "Allocation of buffers for data integrity checking failed\n"); 32137d4c782cSAndreas Gruenbacher goto disconnect; 32147d4c782cSAndreas Gruenbacher } 32157d4c782cSAndreas Gruenbacher } 32167d4c782cSAndreas Gruenbacher 32177d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 32187d4c782cSAndreas Gruenbacher if (!new_net_conf) { 32197d4c782cSAndreas Gruenbacher conn_err(tconn, "Allocation of new net_conf failed\n"); 32207d4c782cSAndreas Gruenbacher goto disconnect; 32217d4c782cSAndreas Gruenbacher } 32227d4c782cSAndreas Gruenbacher 32237d4c782cSAndreas Gruenbacher mutex_lock(&tconn->data.mutex); 32247d4c782cSAndreas Gruenbacher mutex_lock(&tconn->conf_update); 32257d4c782cSAndreas Gruenbacher old_net_conf = tconn->net_conf; 32267d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 32277d4c782cSAndreas Gruenbacher 32287d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 32297d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 32307d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 32317d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 32327d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 32337d4c782cSAndreas Gruenbacher 32347d4c782cSAndreas Gruenbacher rcu_assign_pointer(tconn->net_conf, new_net_conf); 32357d4c782cSAndreas Gruenbacher mutex_unlock(&tconn->conf_update); 32367d4c782cSAndreas Gruenbacher mutex_unlock(&tconn->data.mutex); 32377d4c782cSAndreas Gruenbacher 32387d4c782cSAndreas Gruenbacher crypto_free_hash(tconn->peer_integrity_tfm); 32397d4c782cSAndreas Gruenbacher kfree(tconn->int_dig_in); 32407d4c782cSAndreas Gruenbacher kfree(tconn->int_dig_vv); 32417d4c782cSAndreas Gruenbacher tconn->peer_integrity_tfm = peer_integrity_tfm; 32427d4c782cSAndreas Gruenbacher tconn->int_dig_in = int_dig_in; 32437d4c782cSAndreas Gruenbacher tconn->int_dig_vv = int_dig_vv; 32447d4c782cSAndreas Gruenbacher 32457d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 32467d4c782cSAndreas Gruenbacher conn_info(tconn, "peer data-integrity-alg: %s\n", 32477d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 32487d4c782cSAndreas Gruenbacher 32497d4c782cSAndreas Gruenbacher synchronize_rcu(); 32507d4c782cSAndreas Gruenbacher kfree(old_net_conf); 325182bc0194SAndreas Gruenbacher return 0; 3252b411b363SPhilipp Reisner 325344ed167dSPhilipp Reisner disconnect_rcu_unlock: 325444ed167dSPhilipp Reisner rcu_read_unlock(); 3255b411b363SPhilipp Reisner disconnect: 3256b792c35cSAndreas Gruenbacher crypto_free_hash(peer_integrity_tfm); 3257036b17eaSPhilipp Reisner kfree(int_dig_in); 3258036b17eaSPhilipp Reisner kfree(int_dig_vv); 32597204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 326082bc0194SAndreas Gruenbacher return -EIO; 3261b411b363SPhilipp Reisner } 3262b411b363SPhilipp Reisner 3263b411b363SPhilipp Reisner /* helper function 3264b411b363SPhilipp Reisner * input: alg name, feature name 3265b411b363SPhilipp Reisner * return: NULL (alg name was "") 3266b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3267b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 3268b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 3269b411b363SPhilipp Reisner const char *alg, const char *name) 3270b411b363SPhilipp Reisner { 3271b411b363SPhilipp Reisner struct crypto_hash *tfm; 3272b411b363SPhilipp Reisner 3273b411b363SPhilipp Reisner if (!alg[0]) 3274b411b363SPhilipp Reisner return NULL; 3275b411b363SPhilipp Reisner 3276b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3277b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3278b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3279b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3280b411b363SPhilipp Reisner return tfm; 3281b411b363SPhilipp Reisner } 3282b411b363SPhilipp Reisner return tfm; 3283b411b363SPhilipp Reisner } 3284b411b363SPhilipp Reisner 32854a76b161SAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_tconn *tconn, struct packet_info *pi) 3286b411b363SPhilipp Reisner { 32874a76b161SAndreas Gruenbacher void *buffer = tconn->data.rbuf; 32884a76b161SAndreas Gruenbacher int size = pi->size; 32894a76b161SAndreas Gruenbacher 32904a76b161SAndreas Gruenbacher while (size) { 32914a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 32924a76b161SAndreas Gruenbacher s = drbd_recv(tconn, buffer, s); 32934a76b161SAndreas Gruenbacher if (s <= 0) { 32944a76b161SAndreas Gruenbacher if (s < 0) 32954a76b161SAndreas Gruenbacher return s; 32964a76b161SAndreas Gruenbacher break; 32974a76b161SAndreas Gruenbacher } 32984a76b161SAndreas Gruenbacher size -= s; 32994a76b161SAndreas Gruenbacher } 33004a76b161SAndreas Gruenbacher if (size) 33014a76b161SAndreas Gruenbacher return -EIO; 33024a76b161SAndreas Gruenbacher return 0; 33034a76b161SAndreas Gruenbacher } 33044a76b161SAndreas Gruenbacher 33054a76b161SAndreas Gruenbacher /* 33064a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 33074a76b161SAndreas Gruenbacher * 33084a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 33094a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 33104a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 33114a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 33124a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 33134a76b161SAndreas Gruenbacher * 33144a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 33154a76b161SAndreas Gruenbacher */ 33164a76b161SAndreas Gruenbacher static int config_unknown_volume(struct drbd_tconn *tconn, struct packet_info *pi) 33174a76b161SAndreas Gruenbacher { 33182fcb8f30SAndreas Gruenbacher conn_warn(tconn, "%s packet received for volume %u, which is not configured locally\n", 33192fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 33204a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 33214a76b161SAndreas Gruenbacher } 33224a76b161SAndreas Gruenbacher 33234a76b161SAndreas Gruenbacher static int receive_SyncParam(struct drbd_tconn *tconn, struct packet_info *pi) 33244a76b161SAndreas Gruenbacher { 33254a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3326e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3327b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3328b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3329b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 33302ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3331813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 33324a76b161SAndreas Gruenbacher const int apv = tconn->agreed_pro_version; 3333813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3334778f271dSPhilipp Reisner int fifo_size = 0; 333582bc0194SAndreas Gruenbacher int err; 3336b411b363SPhilipp Reisner 33374a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 33384a76b161SAndreas Gruenbacher if (!mdev) 33394a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 33404a76b161SAndreas Gruenbacher 3341b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3342b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3343b411b363SPhilipp Reisner + SHARED_SECRET_MAX 33448e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 33458e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3346b411b363SPhilipp Reisner 3347e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3348b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3349e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 335082bc0194SAndreas Gruenbacher return -EIO; 3351b411b363SPhilipp Reisner } 3352b411b363SPhilipp Reisner 3353b411b363SPhilipp Reisner if (apv <= 88) { 3354e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3355e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 33568e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3357e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3358e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3359b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 33608e26f9ccSPhilipp Reisner } else { 3361e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3362e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3363b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 3364b411b363SPhilipp Reisner } 3365b411b363SPhilipp Reisner 3366b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3367e658983aSAndreas Gruenbacher p = pi->data; 3368b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3369b411b363SPhilipp Reisner 3370e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, header_size); 337182bc0194SAndreas Gruenbacher if (err) 337282bc0194SAndreas Gruenbacher return err; 3373b411b363SPhilipp Reisner 3374813472ceSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3375813472ceSPhilipp Reisner old_net_conf = mdev->tconn->net_conf; 3376813472ceSPhilipp Reisner if (get_ldev(mdev)) { 3377daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3378daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3379813472ceSPhilipp Reisner put_ldev(mdev); 3380813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3381daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3382daeda1ccSPhilipp Reisner return -ENOMEM; 3383f399002eSLars Ellenberg } 3384b411b363SPhilipp Reisner 3385daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3386daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3387daeda1ccSPhilipp Reisner 33886394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3389813472ceSPhilipp Reisner } 3390daeda1ccSPhilipp Reisner 3391b411b363SPhilipp Reisner if (apv >= 88) { 3392b411b363SPhilipp Reisner if (apv == 88) { 3393e4bad1bcSPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 3394e4bad1bcSPhilipp Reisner dev_err(DEV, "verify-alg of wrong size, " 3395e4bad1bcSPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3396b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3397813472ceSPhilipp Reisner err = -EIO; 3398813472ceSPhilipp Reisner goto reconnect; 3399b411b363SPhilipp Reisner } 3400b411b363SPhilipp Reisner 340182bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size); 3402813472ceSPhilipp Reisner if (err) 3403813472ceSPhilipp Reisner goto reconnect; 3404b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3405b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3406b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3407b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3408b411b363SPhilipp Reisner 3409b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3410b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3411b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3412b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3413b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3414b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3415b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3416b411b363SPhilipp Reisner } 3417b411b363SPhilipp Reisner 34182ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3419b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3420b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 34212ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3422b411b363SPhilipp Reisner goto disconnect; 3423b411b363SPhilipp Reisner } 3424b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3425b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3426b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3427b411b363SPhilipp Reisner verify_tfm = NULL; 3428b411b363SPhilipp Reisner goto disconnect; 3429b411b363SPhilipp Reisner } 3430b411b363SPhilipp Reisner } 3431b411b363SPhilipp Reisner 34322ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3433b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3434b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 34352ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3436b411b363SPhilipp Reisner goto disconnect; 3437b411b363SPhilipp Reisner } 3438b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3439b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3440b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3441b411b363SPhilipp Reisner csums_tfm = NULL; 3442b411b363SPhilipp Reisner goto disconnect; 3443b411b363SPhilipp Reisner } 3444b411b363SPhilipp Reisner } 3445b411b363SPhilipp Reisner 3446813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3447daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3448daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3449daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3450daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3451778f271dSPhilipp Reisner 3452daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 34539958c857SPhilipp Reisner if (fifo_size != mdev->rs_plan_s->size) { 3454813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3455813472ceSPhilipp Reisner if (!new_plan) { 3456778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3457f399002eSLars Ellenberg put_ldev(mdev); 3458778f271dSPhilipp Reisner goto disconnect; 3459778f271dSPhilipp Reisner } 3460778f271dSPhilipp Reisner } 34618e26f9ccSPhilipp Reisner } 3462b411b363SPhilipp Reisner 346391fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 34642ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 34652ec91e0eSPhilipp Reisner if (!new_net_conf) { 346691fd4dadSPhilipp Reisner dev_err(DEV, "Allocation of new net_conf failed\n"); 346791fd4dadSPhilipp Reisner goto disconnect; 346891fd4dadSPhilipp Reisner } 346991fd4dadSPhilipp Reisner 34702ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 347191fd4dadSPhilipp Reisner 3472b411b363SPhilipp Reisner if (verify_tfm) { 34732ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 34742ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3475f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3476f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3477b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3478b411b363SPhilipp Reisner } 3479b411b363SPhilipp Reisner if (csums_tfm) { 34802ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 34812ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3482f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3483f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3484b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3485b411b363SPhilipp Reisner } 34862ec91e0eSPhilipp Reisner rcu_assign_pointer(tconn->net_conf, new_net_conf); 348791fd4dadSPhilipp Reisner } 348891fd4dadSPhilipp Reisner } 348991fd4dadSPhilipp Reisner 3490813472ceSPhilipp Reisner if (new_disk_conf) { 3491daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3492813472ceSPhilipp Reisner put_ldev(mdev); 3493778f271dSPhilipp Reisner } 3494813472ceSPhilipp Reisner 3495813472ceSPhilipp Reisner if (new_plan) { 3496813472ceSPhilipp Reisner old_plan = mdev->rs_plan_s; 3497813472ceSPhilipp Reisner rcu_assign_pointer(mdev->rs_plan_s, new_plan); 3498813472ceSPhilipp Reisner } 3499daeda1ccSPhilipp Reisner 3500daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3501daeda1ccSPhilipp Reisner synchronize_rcu(); 3502daeda1ccSPhilipp Reisner if (new_net_conf) 3503daeda1ccSPhilipp Reisner kfree(old_net_conf); 3504daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3505813472ceSPhilipp Reisner kfree(old_plan); 3506daeda1ccSPhilipp Reisner 350782bc0194SAndreas Gruenbacher return 0; 3508b411b363SPhilipp Reisner 3509813472ceSPhilipp Reisner reconnect: 3510813472ceSPhilipp Reisner if (new_disk_conf) { 3511813472ceSPhilipp Reisner put_ldev(mdev); 3512813472ceSPhilipp Reisner kfree(new_disk_conf); 3513813472ceSPhilipp Reisner } 3514813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3515813472ceSPhilipp Reisner return -EIO; 3516813472ceSPhilipp Reisner 3517b411b363SPhilipp Reisner disconnect: 3518813472ceSPhilipp Reisner kfree(new_plan); 3519813472ceSPhilipp Reisner if (new_disk_conf) { 3520813472ceSPhilipp Reisner put_ldev(mdev); 3521813472ceSPhilipp Reisner kfree(new_disk_conf); 3522813472ceSPhilipp Reisner } 3523a0095508SPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3524b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3525b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3526b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3527b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3528b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 352938fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 353082bc0194SAndreas Gruenbacher return -EIO; 3531b411b363SPhilipp Reisner } 3532b411b363SPhilipp Reisner 3533b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3534b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3535b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3536b411b363SPhilipp Reisner { 3537b411b363SPhilipp Reisner sector_t d; 3538b411b363SPhilipp Reisner if (a == 0 || b == 0) 3539b411b363SPhilipp Reisner return; 3540b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3541b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3542b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3543b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3544b411b363SPhilipp Reisner } 3545b411b363SPhilipp Reisner 35464a76b161SAndreas Gruenbacher static int receive_sizes(struct drbd_tconn *tconn, struct packet_info *pi) 3547b411b363SPhilipp Reisner { 35484a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3549e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3550b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3551b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3552b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3553e89b591cSPhilipp Reisner enum dds_flags ddsf; 3554b411b363SPhilipp Reisner 35554a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 35564a76b161SAndreas Gruenbacher if (!mdev) 35574a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 35584a76b161SAndreas Gruenbacher 3559b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3560b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3561b411b363SPhilipp Reisner 3562b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3563b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3564b411b363SPhilipp Reisner mdev->p_size = p_size; 3565b411b363SPhilipp Reisner 3566b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3567daeda1ccSPhilipp Reisner rcu_read_lock(); 3568daeda1ccSPhilipp Reisner my_usize = rcu_dereference(mdev->ldev->disk_conf)->disk_size; 3569daeda1ccSPhilipp Reisner rcu_read_unlock(); 3570daeda1ccSPhilipp Reisner 3571b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3572b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3573b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3574daeda1ccSPhilipp Reisner p_usize, my_usize); 3575b411b363SPhilipp Reisner 3576b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3577b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3578b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3579daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3580b411b363SPhilipp Reisner 3581b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3582b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3583ef5e44a6SPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, p_usize, 0) < 3584b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3585b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3586b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3587b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 358838fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3589b411b363SPhilipp Reisner put_ldev(mdev); 359082bc0194SAndreas Gruenbacher return -EIO; 3591b411b363SPhilipp Reisner } 3592daeda1ccSPhilipp Reisner 3593daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3594daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3595daeda1ccSPhilipp Reisner 3596daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3597daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3598daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3599daeda1ccSPhilipp Reisner put_ldev(mdev); 3600daeda1ccSPhilipp Reisner return -ENOMEM; 3601daeda1ccSPhilipp Reisner } 3602daeda1ccSPhilipp Reisner 3603daeda1ccSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3604daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3605daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3606daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3607daeda1ccSPhilipp Reisner 3608daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3609daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3610daeda1ccSPhilipp Reisner synchronize_rcu(); 3611daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3612daeda1ccSPhilipp Reisner 3613daeda1ccSPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3614daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3615daeda1ccSPhilipp Reisner } 3616daeda1ccSPhilipp Reisner 3617b411b363SPhilipp Reisner put_ldev(mdev); 3618b411b363SPhilipp Reisner } 3619b411b363SPhilipp Reisner 3620e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3621b411b363SPhilipp Reisner if (get_ldev(mdev)) { 362224c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3623b411b363SPhilipp Reisner put_ldev(mdev); 3624b411b363SPhilipp Reisner if (dd == dev_size_error) 362582bc0194SAndreas Gruenbacher return -EIO; 3626b411b363SPhilipp Reisner drbd_md_sync(mdev); 3627b411b363SPhilipp Reisner } else { 3628b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3629b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3630b411b363SPhilipp Reisner } 3631b411b363SPhilipp Reisner 363299432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 363399432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 363499432fccSPhilipp Reisner 3635b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3636b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3637b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3638b411b363SPhilipp Reisner ldsc = 1; 3639b411b363SPhilipp Reisner } 3640b411b363SPhilipp Reisner 3641b411b363SPhilipp Reisner put_ldev(mdev); 3642b411b363SPhilipp Reisner } 3643b411b363SPhilipp Reisner 3644b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3645b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3646b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3647b411b363SPhilipp Reisner /* we have different sizes, probably peer 3648b411b363SPhilipp Reisner * needs to know my new size... */ 3649e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3650b411b363SPhilipp Reisner } 3651b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3652b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3653b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3654e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3655e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3656e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3657b411b363SPhilipp Reisner else 3658e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3659e89b591cSPhilipp Reisner } else 3660b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3661b411b363SPhilipp Reisner } 3662b411b363SPhilipp Reisner } 3663b411b363SPhilipp Reisner 366482bc0194SAndreas Gruenbacher return 0; 3665b411b363SPhilipp Reisner } 3666b411b363SPhilipp Reisner 36674a76b161SAndreas Gruenbacher static int receive_uuids(struct drbd_tconn *tconn, struct packet_info *pi) 3668b411b363SPhilipp Reisner { 36694a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3670e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3671b411b363SPhilipp Reisner u64 *p_uuid; 367262b0da3aSLars Ellenberg int i, updated_uuids = 0; 3673b411b363SPhilipp Reisner 36744a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 36754a76b161SAndreas Gruenbacher if (!mdev) 36764a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 36774a76b161SAndreas Gruenbacher 3678b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3679b411b363SPhilipp Reisner 3680b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3681b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3682b411b363SPhilipp Reisner 3683b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3684b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3685b411b363SPhilipp Reisner 3686b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3687b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3688b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3689b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3690b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3691b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 369238fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 369382bc0194SAndreas Gruenbacher return -EIO; 3694b411b363SPhilipp Reisner } 3695b411b363SPhilipp Reisner 3696b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3697b411b363SPhilipp Reisner int skip_initial_sync = 3698b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 369931890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3700b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3701b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3702b411b363SPhilipp Reisner if (skip_initial_sync) { 3703b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3704b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 370520ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 370620ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3707b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3708b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3709b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3710b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3711b411b363SPhilipp Reisner drbd_md_sync(mdev); 371262b0da3aSLars Ellenberg updated_uuids = 1; 3713b411b363SPhilipp Reisner } 3714b411b363SPhilipp Reisner put_ldev(mdev); 371518a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 371618a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 371718a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 371818a50fa2SPhilipp Reisner for me. */ 371962b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3720b411b363SPhilipp Reisner } 3721b411b363SPhilipp Reisner 3722b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3723b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3724b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3725b411b363SPhilipp Reisner new disk state... */ 37268410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 37278410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3728b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 372962b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 373062b0da3aSLars Ellenberg 373162b0da3aSLars Ellenberg if (updated_uuids) 373262b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3733b411b363SPhilipp Reisner 373482bc0194SAndreas Gruenbacher return 0; 3735b411b363SPhilipp Reisner } 3736b411b363SPhilipp Reisner 3737b411b363SPhilipp Reisner /** 3738b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3739b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3740b411b363SPhilipp Reisner */ 3741b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3742b411b363SPhilipp Reisner { 3743b411b363SPhilipp Reisner union drbd_state ms; 3744b411b363SPhilipp Reisner 3745b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3746369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 3747b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3748b411b363SPhilipp Reisner 3749b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3750b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3751b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3752b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3753b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3754b411b363SPhilipp Reisner }; 3755b411b363SPhilipp Reisner 3756b411b363SPhilipp Reisner ms.i = ps.i; 3757b411b363SPhilipp Reisner 3758b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3759b411b363SPhilipp Reisner ms.peer = ps.role; 3760b411b363SPhilipp Reisner ms.role = ps.peer; 3761b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3762b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3763b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3764b411b363SPhilipp Reisner 3765b411b363SPhilipp Reisner return ms; 3766b411b363SPhilipp Reisner } 3767b411b363SPhilipp Reisner 37684a76b161SAndreas Gruenbacher static int receive_req_state(struct drbd_tconn *tconn, struct packet_info *pi) 3769b411b363SPhilipp Reisner { 37704a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3771e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3772b411b363SPhilipp Reisner union drbd_state mask, val; 3773bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3774b411b363SPhilipp Reisner 37754a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 37764a76b161SAndreas Gruenbacher if (!mdev) 37774a76b161SAndreas Gruenbacher return -EIO; 37784a76b161SAndreas Gruenbacher 3779b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3780b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3781b411b363SPhilipp Reisner 3782427c0434SLars Ellenberg if (test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags) && 37838410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3784b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 378582bc0194SAndreas Gruenbacher return 0; 3786b411b363SPhilipp Reisner } 3787b411b363SPhilipp Reisner 3788b411b363SPhilipp Reisner mask = convert_state(mask); 3789b411b363SPhilipp Reisner val = convert_state(val); 3790b411b363SPhilipp Reisner 3791b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3792b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3793047cd4a6SPhilipp Reisner 3794b411b363SPhilipp Reisner drbd_md_sync(mdev); 3795b411b363SPhilipp Reisner 379682bc0194SAndreas Gruenbacher return 0; 3797b411b363SPhilipp Reisner } 3798b411b363SPhilipp Reisner 3799e2857216SAndreas Gruenbacher static int receive_req_conn_state(struct drbd_tconn *tconn, struct packet_info *pi) 3800dfafcc8aSPhilipp Reisner { 3801e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3802dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3803dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3804dfafcc8aSPhilipp Reisner 3805dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3806dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3807dfafcc8aSPhilipp Reisner 3808427c0434SLars Ellenberg if (test_bit(RESOLVE_CONFLICTS, &tconn->flags) && 3809dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3810dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 381182bc0194SAndreas Gruenbacher return 0; 3812dfafcc8aSPhilipp Reisner } 3813dfafcc8aSPhilipp Reisner 3814dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3815dfafcc8aSPhilipp Reisner val = convert_state(val); 3816dfafcc8aSPhilipp Reisner 3817778bcf2eSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3818dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3819dfafcc8aSPhilipp Reisner 382082bc0194SAndreas Gruenbacher return 0; 3821dfafcc8aSPhilipp Reisner } 3822dfafcc8aSPhilipp Reisner 38234a76b161SAndreas Gruenbacher static int receive_state(struct drbd_tconn *tconn, struct packet_info *pi) 3824b411b363SPhilipp Reisner { 38254a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3826e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 38274ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3828b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 382965d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3830b411b363SPhilipp Reisner int rv; 3831b411b363SPhilipp Reisner 38324a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 38334a76b161SAndreas Gruenbacher if (!mdev) 38344a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 38354a76b161SAndreas Gruenbacher 3836b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3837b411b363SPhilipp Reisner 3838b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3839b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3840b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3841b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3842b411b363SPhilipp Reisner } 3843b411b363SPhilipp Reisner 384487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3845b411b363SPhilipp Reisner retry: 384678bae59bSPhilipp Reisner os = ns = drbd_read_state(mdev); 384787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3848b411b363SPhilipp Reisner 3849b8853dbdSPhilipp Reisner /* If some other part of the code (asender thread, timeout) 3850b8853dbdSPhilipp Reisner * already decided to close the connection again, 3851b8853dbdSPhilipp Reisner * we must not "re-establish" it here. */ 3852b8853dbdSPhilipp Reisner if (os.conn <= C_TEAR_DOWN) 385358ffa580SLars Ellenberg return -ECONNRESET; 3854b8853dbdSPhilipp Reisner 38559bcd2521SPhilipp Reisner /* If this is the "end of sync" confirmation, usually the peer disk 38569bcd2521SPhilipp Reisner * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 38579bcd2521SPhilipp Reisner * set) resync started in PausedSyncT, or if the timing of pause-/ 38589bcd2521SPhilipp Reisner * unpause-sync events has been "just right", the peer disk may 38599bcd2521SPhilipp Reisner * transition from D_CONSISTENT to D_UP_TO_DATE as well. 38609bcd2521SPhilipp Reisner */ 38619bcd2521SPhilipp Reisner if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 38629bcd2521SPhilipp Reisner real_peer_disk == D_UP_TO_DATE && 3863e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3864e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3865e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3866e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3867e9ef7bb6SLars Ellenberg * syncing states. 3868e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3869e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3870e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3871e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3872e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3873e9ef7bb6SLars Ellenberg 3874e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3875e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3876e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3877e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3878e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3879e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3880e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 388182bc0194SAndreas Gruenbacher return 0; 3882e9ef7bb6SLars Ellenberg } 3883e9ef7bb6SLars Ellenberg } 3884e9ef7bb6SLars Ellenberg 388558ffa580SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 388658ffa580SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 388758ffa580SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 388858ffa580SLars Ellenberg ov_out_of_sync_print(mdev); 388958ffa580SLars Ellenberg drbd_resync_finished(mdev); 389058ffa580SLars Ellenberg return 0; 389158ffa580SLars Ellenberg } 389258ffa580SLars Ellenberg 3893e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3894e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3895e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3896e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3897e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3898e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3899e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3900e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3901e9ef7bb6SLars Ellenberg 39024ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 39034ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3904b411b363SPhilipp Reisner 390567531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 390667531718SPhilipp Reisner ns.conn = C_BEHIND; 390767531718SPhilipp Reisner 3908b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3909b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3910b411b363SPhilipp Reisner int cr; /* consider resync */ 3911b411b363SPhilipp Reisner 3912b411b363SPhilipp Reisner /* if we established a new connection */ 39134ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3914b411b363SPhilipp Reisner /* if we had an established connection 3915b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 39164ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3917b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 39184ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3919b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3920b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3921b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3922b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3923b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 39244ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3925b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3926b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3927b411b363SPhilipp Reisner 3928b411b363SPhilipp Reisner if (cr) 39294ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3930b411b363SPhilipp Reisner 3931b411b363SPhilipp Reisner put_ldev(mdev); 39324ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 39334ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3934b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 393582f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3936b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3937b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3938b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3939580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3940b411b363SPhilipp Reisner } else { 39418169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 394282bc0194SAndreas Gruenbacher return -EIO; 39434ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 394438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 394582bc0194SAndreas Gruenbacher return -EIO; 3946b411b363SPhilipp Reisner } 3947b411b363SPhilipp Reisner } 3948b411b363SPhilipp Reisner } 3949b411b363SPhilipp Reisner 395087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 395178bae59bSPhilipp Reisner if (os.i != drbd_read_state(mdev).i) 3952b411b363SPhilipp Reisner goto retry; 3953b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3954b411b363SPhilipp Reisner ns.peer = peer_state.role; 3955b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3956b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 39574ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3958b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 39594ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 39602aebfabbSPhilipp Reisner if (ns.pdsk == D_CONSISTENT && drbd_suspended(mdev) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3961481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 39628554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3963481c6f50SPhilipp Reisner for temporal network outages! */ 396487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3965481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 39662f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3967481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3968481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 396938fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 397082bc0194SAndreas Gruenbacher return -EIO; 3971481c6f50SPhilipp Reisner } 397265d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 397378bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 397487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3975b411b363SPhilipp Reisner 3976b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 397738fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 397882bc0194SAndreas Gruenbacher return -EIO; 3979b411b363SPhilipp Reisner } 3980b411b363SPhilipp Reisner 39814ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 39824ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3983b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3984b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3985b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3986b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3987b411b363SPhilipp Reisner drbd_send_uuids(mdev); 398843de7c85SPhilipp Reisner drbd_send_current_state(mdev); 3989b411b363SPhilipp Reisner } 3990b411b363SPhilipp Reisner } 3991b411b363SPhilipp Reisner 399208b165baSPhilipp Reisner clear_bit(DISCARD_MY_DATA, &mdev->flags); 3993b411b363SPhilipp Reisner 3994b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3995b411b363SPhilipp Reisner 399682bc0194SAndreas Gruenbacher return 0; 3997b411b363SPhilipp Reisner } 3998b411b363SPhilipp Reisner 39994a76b161SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_tconn *tconn, struct packet_info *pi) 4000b411b363SPhilipp Reisner { 40014a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4002e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 40034a76b161SAndreas Gruenbacher 40044a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 40054a76b161SAndreas Gruenbacher if (!mdev) 40064a76b161SAndreas Gruenbacher return -EIO; 4007b411b363SPhilipp Reisner 4008b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 4009b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 4010c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 4011b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 4012b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 4013b411b363SPhilipp Reisner 4014b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 4015b411b363SPhilipp Reisner 4016b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4017b411b363SPhilipp Reisner _not_ be rotated into the history */ 4018b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 4019b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 4020b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 4021b411b363SPhilipp Reisner 402262b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 4023b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 4024b411b363SPhilipp Reisner 4025b411b363SPhilipp Reisner put_ldev(mdev); 4026b411b363SPhilipp Reisner } else 4027b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 4028b411b363SPhilipp Reisner 402982bc0194SAndreas Gruenbacher return 0; 4030b411b363SPhilipp Reisner } 4031b411b363SPhilipp Reisner 40322c46407dSAndreas Gruenbacher /** 40332c46407dSAndreas Gruenbacher * receive_bitmap_plain 40342c46407dSAndreas Gruenbacher * 40352c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40362c46407dSAndreas Gruenbacher * code upon failure. 40372c46407dSAndreas Gruenbacher */ 40382c46407dSAndreas Gruenbacher static int 403950d0b1adSAndreas Gruenbacher receive_bitmap_plain(struct drbd_conf *mdev, unsigned int size, 4040e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4041b411b363SPhilipp Reisner { 404250d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 404350d0b1adSAndreas Gruenbacher drbd_header_size(mdev->tconn); 4044e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 404550d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4046e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 40472c46407dSAndreas Gruenbacher int err; 4048b411b363SPhilipp Reisner 404950d0b1adSAndreas Gruenbacher if (want != size) { 405050d0b1adSAndreas Gruenbacher dev_err(DEV, "%s:want (%u) != size (%u)\n", __func__, want, size); 40512c46407dSAndreas Gruenbacher return -EIO; 4052b411b363SPhilipp Reisner } 4053b411b363SPhilipp Reisner if (want == 0) 40542c46407dSAndreas Gruenbacher return 0; 4055e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, want); 405682bc0194SAndreas Gruenbacher if (err) 40572c46407dSAndreas Gruenbacher return err; 4058b411b363SPhilipp Reisner 4059e658983aSAndreas Gruenbacher drbd_bm_merge_lel(mdev, c->word_offset, num_words, p); 4060b411b363SPhilipp Reisner 4061b411b363SPhilipp Reisner c->word_offset += num_words; 4062b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4063b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4064b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4065b411b363SPhilipp Reisner 40662c46407dSAndreas Gruenbacher return 1; 4067b411b363SPhilipp Reisner } 4068b411b363SPhilipp Reisner 4069a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4070a02d1240SAndreas Gruenbacher { 4071a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4072a02d1240SAndreas Gruenbacher } 4073a02d1240SAndreas Gruenbacher 4074a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4075a02d1240SAndreas Gruenbacher { 4076a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4077a02d1240SAndreas Gruenbacher } 4078a02d1240SAndreas Gruenbacher 4079a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4080a02d1240SAndreas Gruenbacher { 4081a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4082a02d1240SAndreas Gruenbacher } 4083a02d1240SAndreas Gruenbacher 40842c46407dSAndreas Gruenbacher /** 40852c46407dSAndreas Gruenbacher * recv_bm_rle_bits 40862c46407dSAndreas Gruenbacher * 40872c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40882c46407dSAndreas Gruenbacher * code upon failure. 40892c46407dSAndreas Gruenbacher */ 40902c46407dSAndreas Gruenbacher static int 4091b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 4092b411b363SPhilipp Reisner struct p_compressed_bm *p, 4093c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4094c6d25cfeSPhilipp Reisner unsigned int len) 4095b411b363SPhilipp Reisner { 4096b411b363SPhilipp Reisner struct bitstream bs; 4097b411b363SPhilipp Reisner u64 look_ahead; 4098b411b363SPhilipp Reisner u64 rl; 4099b411b363SPhilipp Reisner u64 tmp; 4100b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4101b411b363SPhilipp Reisner unsigned long e; 4102a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4103b411b363SPhilipp Reisner int have; 4104b411b363SPhilipp Reisner int bits; 4105b411b363SPhilipp Reisner 4106a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4107b411b363SPhilipp Reisner 4108b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4109b411b363SPhilipp Reisner if (bits < 0) 41102c46407dSAndreas Gruenbacher return -EIO; 4111b411b363SPhilipp Reisner 4112b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4113b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4114b411b363SPhilipp Reisner if (bits <= 0) 41152c46407dSAndreas Gruenbacher return -EIO; 4116b411b363SPhilipp Reisner 4117b411b363SPhilipp Reisner if (toggle) { 4118b411b363SPhilipp Reisner e = s + rl -1; 4119b411b363SPhilipp Reisner if (e >= c->bm_bits) { 4120b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 41212c46407dSAndreas Gruenbacher return -EIO; 4122b411b363SPhilipp Reisner } 4123b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 4124b411b363SPhilipp Reisner } 4125b411b363SPhilipp Reisner 4126b411b363SPhilipp Reisner if (have < bits) { 4127b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4128b411b363SPhilipp Reisner have, bits, look_ahead, 4129b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4130b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 41312c46407dSAndreas Gruenbacher return -EIO; 4132b411b363SPhilipp Reisner } 4133b411b363SPhilipp Reisner look_ahead >>= bits; 4134b411b363SPhilipp Reisner have -= bits; 4135b411b363SPhilipp Reisner 4136b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4137b411b363SPhilipp Reisner if (bits < 0) 41382c46407dSAndreas Gruenbacher return -EIO; 4139b411b363SPhilipp Reisner look_ahead |= tmp << have; 4140b411b363SPhilipp Reisner have += bits; 4141b411b363SPhilipp Reisner } 4142b411b363SPhilipp Reisner 4143b411b363SPhilipp Reisner c->bit_offset = s; 4144b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4145b411b363SPhilipp Reisner 41462c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4147b411b363SPhilipp Reisner } 4148b411b363SPhilipp Reisner 41492c46407dSAndreas Gruenbacher /** 41502c46407dSAndreas Gruenbacher * decode_bitmap_c 41512c46407dSAndreas Gruenbacher * 41522c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 41532c46407dSAndreas Gruenbacher * code upon failure. 41542c46407dSAndreas Gruenbacher */ 41552c46407dSAndreas Gruenbacher static int 4156b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 4157b411b363SPhilipp Reisner struct p_compressed_bm *p, 4158c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4159c6d25cfeSPhilipp Reisner unsigned int len) 4160b411b363SPhilipp Reisner { 4161a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 4162e658983aSAndreas Gruenbacher return recv_bm_rle_bits(mdev, p, c, len - sizeof(*p)); 4163b411b363SPhilipp Reisner 4164b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4165b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4166b411b363SPhilipp Reisner * during all our tests. */ 4167b411b363SPhilipp Reisner 4168b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 416938fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 41702c46407dSAndreas Gruenbacher return -EIO; 4171b411b363SPhilipp Reisner } 4172b411b363SPhilipp Reisner 4173b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 4174b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4175b411b363SPhilipp Reisner { 4176b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 417750d0b1adSAndreas Gruenbacher unsigned int header_size = drbd_header_size(mdev->tconn); 417850d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 417950d0b1adSAndreas Gruenbacher unsigned int plain = 418050d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 418150d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 418250d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 418350d0b1adSAndreas Gruenbacher unsigned int r; 4184b411b363SPhilipp Reisner 4185b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4186b411b363SPhilipp Reisner if (total == 0) 4187b411b363SPhilipp Reisner return; 4188b411b363SPhilipp Reisner 4189b411b363SPhilipp Reisner /* don't report if not compressed */ 4190b411b363SPhilipp Reisner if (total >= plain) 4191b411b363SPhilipp Reisner return; 4192b411b363SPhilipp Reisner 4193b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4194b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4195b411b363SPhilipp Reisner : (1000 * total / plain); 4196b411b363SPhilipp Reisner 4197b411b363SPhilipp Reisner if (r > 1000) 4198b411b363SPhilipp Reisner r = 1000; 4199b411b363SPhilipp Reisner 4200b411b363SPhilipp Reisner r = 1000 - r; 4201b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4202b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4203b411b363SPhilipp Reisner direction, 4204b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4205b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4206b411b363SPhilipp Reisner total, r/10, r % 10); 4207b411b363SPhilipp Reisner } 4208b411b363SPhilipp Reisner 4209b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4210b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4211b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4212b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4213b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4214b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4215b411b363SPhilipp Reisner 4216b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 42174a76b161SAndreas Gruenbacher static int receive_bitmap(struct drbd_tconn *tconn, struct packet_info *pi) 4218b411b363SPhilipp Reisner { 42194a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4220b411b363SPhilipp Reisner struct bm_xfer_ctx c; 42212c46407dSAndreas Gruenbacher int err; 42224a76b161SAndreas Gruenbacher 42234a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 42244a76b161SAndreas Gruenbacher if (!mdev) 42254a76b161SAndreas Gruenbacher return -EIO; 4226b411b363SPhilipp Reisner 422720ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 422820ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 422920ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4230b411b363SPhilipp Reisner 4231b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4232b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 4233b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 4234b411b363SPhilipp Reisner }; 4235b411b363SPhilipp Reisner 42362c46407dSAndreas Gruenbacher for(;;) { 4237e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 4238e658983aSAndreas Gruenbacher err = receive_bitmap_plain(mdev, pi->size, pi->data, &c); 4239e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4240b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4241b411b363SPhilipp Reisner * and the feature is enabled! */ 4242e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4243b411b363SPhilipp Reisner 424450d0b1adSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(tconn)) { 4245b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 424682bc0194SAndreas Gruenbacher err = -EIO; 4247b411b363SPhilipp Reisner goto out; 4248b411b363SPhilipp Reisner } 4249e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4250e2857216SAndreas Gruenbacher dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", pi->size); 425182bc0194SAndreas Gruenbacher err = -EIO; 425278fcbdaeSAndreas Gruenbacher goto out; 4253b411b363SPhilipp Reisner } 4254e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, pi->size); 4255e658983aSAndreas Gruenbacher if (err) 4256e658983aSAndreas Gruenbacher goto out; 4257e2857216SAndreas Gruenbacher err = decode_bitmap_c(mdev, p, &c, pi->size); 4258b411b363SPhilipp Reisner } else { 4259e2857216SAndreas Gruenbacher dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 426082bc0194SAndreas Gruenbacher err = -EIO; 4261b411b363SPhilipp Reisner goto out; 4262b411b363SPhilipp Reisner } 4263b411b363SPhilipp Reisner 4264e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 426550d0b1adSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(tconn) + pi->size; 4266b411b363SPhilipp Reisner 42672c46407dSAndreas Gruenbacher if (err <= 0) { 42682c46407dSAndreas Gruenbacher if (err < 0) 42692c46407dSAndreas Gruenbacher goto out; 4270b411b363SPhilipp Reisner break; 42712c46407dSAndreas Gruenbacher } 4272e2857216SAndreas Gruenbacher err = drbd_recv_header(mdev->tconn, pi); 427382bc0194SAndreas Gruenbacher if (err) 4274b411b363SPhilipp Reisner goto out; 42752c46407dSAndreas Gruenbacher } 4276b411b363SPhilipp Reisner 4277b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 4278b411b363SPhilipp Reisner 4279b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 4280de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4281de1f8e4aSAndreas Gruenbacher 428282bc0194SAndreas Gruenbacher err = drbd_send_bitmap(mdev); 428382bc0194SAndreas Gruenbacher if (err) 4284b411b363SPhilipp Reisner goto out; 4285b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4286de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 4287de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 4288b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 4289b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4290b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4291b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 4292b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 4293b411b363SPhilipp Reisner } 429482bc0194SAndreas Gruenbacher err = 0; 4295b411b363SPhilipp Reisner 4296b411b363SPhilipp Reisner out: 429720ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 429882bc0194SAndreas Gruenbacher if (!err && mdev->state.conn == C_WF_BITMAP_S) 4299b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 430082bc0194SAndreas Gruenbacher return err; 4301b411b363SPhilipp Reisner } 4302b411b363SPhilipp Reisner 43034a76b161SAndreas Gruenbacher static int receive_skip(struct drbd_tconn *tconn, struct packet_info *pi) 4304b411b363SPhilipp Reisner { 43054a76b161SAndreas Gruenbacher conn_warn(tconn, "skipping unknown optional packet type %d, l: %d!\n", 4306e2857216SAndreas Gruenbacher pi->cmd, pi->size); 43072de876efSPhilipp Reisner 43084a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 43092de876efSPhilipp Reisner } 43102de876efSPhilipp Reisner 43114a76b161SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_tconn *tconn, struct packet_info *pi) 4312b411b363SPhilipp Reisner { 4313b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4314b411b363SPhilipp Reisner * with the data requests being unplugged */ 43154a76b161SAndreas Gruenbacher drbd_tcp_quickack(tconn->data.socket); 4316b411b363SPhilipp Reisner 431782bc0194SAndreas Gruenbacher return 0; 4318b411b363SPhilipp Reisner } 4319b411b363SPhilipp Reisner 43204a76b161SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_tconn *tconn, struct packet_info *pi) 432173a01a18SPhilipp Reisner { 43224a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4323e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 43244a76b161SAndreas Gruenbacher 43254a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 43264a76b161SAndreas Gruenbacher if (!mdev) 43274a76b161SAndreas Gruenbacher return -EIO; 432873a01a18SPhilipp Reisner 4329f735e363SLars Ellenberg switch (mdev->state.conn) { 4330f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4331f735e363SLars Ellenberg case C_WF_BITMAP_T: 4332f735e363SLars Ellenberg case C_BEHIND: 4333f735e363SLars Ellenberg break; 4334f735e363SLars Ellenberg default: 4335f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4336f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 4337f735e363SLars Ellenberg } 4338f735e363SLars Ellenberg 433973a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 434073a01a18SPhilipp Reisner 434182bc0194SAndreas Gruenbacher return 0; 434273a01a18SPhilipp Reisner } 434373a01a18SPhilipp Reisner 434402918be2SPhilipp Reisner struct data_cmd { 434502918be2SPhilipp Reisner int expect_payload; 434602918be2SPhilipp Reisner size_t pkt_size; 43474a76b161SAndreas Gruenbacher int (*fn)(struct drbd_tconn *, struct packet_info *); 4348b411b363SPhilipp Reisner }; 4349b411b363SPhilipp Reisner 435002918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 43514a76b161SAndreas Gruenbacher [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 43524a76b161SAndreas Gruenbacher [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 43534a76b161SAndreas Gruenbacher [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 43544a76b161SAndreas Gruenbacher [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4355e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4356e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4357e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 43584a76b161SAndreas Gruenbacher [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 43594a76b161SAndreas Gruenbacher [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4360e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4361e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 43624a76b161SAndreas Gruenbacher [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 43634a76b161SAndreas Gruenbacher [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 43644a76b161SAndreas Gruenbacher [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 43654a76b161SAndreas Gruenbacher [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 43664a76b161SAndreas Gruenbacher [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 43674a76b161SAndreas Gruenbacher [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 43684a76b161SAndreas Gruenbacher [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 43694a76b161SAndreas Gruenbacher [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 43704a76b161SAndreas Gruenbacher [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 43714a76b161SAndreas Gruenbacher [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 43724a76b161SAndreas Gruenbacher [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 43734a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4374036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 437502918be2SPhilipp Reisner }; 437602918be2SPhilipp Reisner 4377eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 4378b411b363SPhilipp Reisner { 437977351055SPhilipp Reisner struct packet_info pi; 438002918be2SPhilipp Reisner size_t shs; /* sub header size */ 438182bc0194SAndreas Gruenbacher int err; 4382b411b363SPhilipp Reisner 4383eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 4384deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4385deebe195SAndreas Gruenbacher 4386eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 438769bc7bc3SAndreas Gruenbacher if (drbd_recv_header(tconn, &pi)) 438802918be2SPhilipp Reisner goto err_out; 438902918be2SPhilipp Reisner 4390deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 43914a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 43922fcb8f30SAndreas Gruenbacher conn_err(tconn, "Unexpected data packet %s (0x%04x)", 43932fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 439402918be2SPhilipp Reisner goto err_out; 43950b33a916SLars Ellenberg } 4396b411b363SPhilipp Reisner 4397e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4398e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 43992fcb8f30SAndreas Gruenbacher conn_err(tconn, "No payload expected %s l:%d\n", 44002fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4401c13f7e1aSLars Ellenberg goto err_out; 4402c13f7e1aSLars Ellenberg } 4403c13f7e1aSLars Ellenberg 4404c13f7e1aSLars Ellenberg if (shs) { 4405e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, pi.data, shs); 4406a5c31904SAndreas Gruenbacher if (err) 440702918be2SPhilipp Reisner goto err_out; 4408e2857216SAndreas Gruenbacher pi.size -= shs; 4409b411b363SPhilipp Reisner } 441002918be2SPhilipp Reisner 44114a76b161SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 44124a76b161SAndreas Gruenbacher if (err) { 44139f5bdc33SAndreas Gruenbacher conn_err(tconn, "error receiving %s, e: %d l: %d!\n", 44149f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 441502918be2SPhilipp Reisner goto err_out; 4416b411b363SPhilipp Reisner } 4417b411b363SPhilipp Reisner } 441882bc0194SAndreas Gruenbacher return; 441902918be2SPhilipp Reisner 442002918be2SPhilipp Reisner err_out: 4421bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4422b411b363SPhilipp Reisner } 4423b411b363SPhilipp Reisner 44240e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 4425b411b363SPhilipp Reisner { 4426b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4427b411b363SPhilipp Reisner 4428b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 44290e29d163SPhilipp Reisner barr.w.tconn = tconn; 4430b411b363SPhilipp Reisner init_completion(&barr.done); 4431d5b27b01SLars Ellenberg drbd_queue_work(&tconn->sender_work, &barr.w); 4432b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4433b411b363SPhilipp Reisner } 4434b411b363SPhilipp Reisner 443581fa2e67SPhilipp Reisner static void conn_disconnect(struct drbd_tconn *tconn) 4436b411b363SPhilipp Reisner { 4437c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 4438bbeb641cSPhilipp Reisner enum drbd_conns oc; 4439376694a0SPhilipp Reisner int vnr; 4440b411b363SPhilipp Reisner 4441bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4442b411b363SPhilipp Reisner return; 4443b411b363SPhilipp Reisner 4444b8853dbdSPhilipp Reisner /* We are about to start the cleanup after connection loss. 4445b8853dbdSPhilipp Reisner * Make sure drbd_make_request knows about that. 4446b8853dbdSPhilipp Reisner * Usually we should be in some network failure state already, 4447b8853dbdSPhilipp Reisner * but just in case we are not, we fix it up here. 4448b8853dbdSPhilipp Reisner */ 4449b8853dbdSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4450b8853dbdSPhilipp Reisner 4451b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4452360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4453360cc740SPhilipp Reisner drbd_free_sock(tconn); 4454360cc740SPhilipp Reisner 4455c141ebdaSPhilipp Reisner rcu_read_lock(); 4456c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 4457c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 4458c141ebdaSPhilipp Reisner rcu_read_unlock(); 4459c141ebdaSPhilipp Reisner drbd_disconnected(mdev); 4460c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 4461c141ebdaSPhilipp Reisner rcu_read_lock(); 4462c141ebdaSPhilipp Reisner } 4463c141ebdaSPhilipp Reisner rcu_read_unlock(); 4464c141ebdaSPhilipp Reisner 446512038a3aSPhilipp Reisner if (!list_empty(&tconn->current_epoch->list)) 446612038a3aSPhilipp Reisner conn_err(tconn, "ASSERTION FAILED: tconn->current_epoch->list not empty\n"); 446712038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 446812038a3aSPhilipp Reisner atomic_set(&tconn->current_epoch->epoch_size, 0); 4469b6dd1a89SLars Ellenberg tconn->send.seen_any_write_yet = false; 447012038a3aSPhilipp Reisner 4471360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4472360cc740SPhilipp Reisner 4473cb703454SPhilipp Reisner if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN) 4474cb703454SPhilipp Reisner conn_try_outdate_peer_async(tconn); 4475cb703454SPhilipp Reisner 4476360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4477bbeb641cSPhilipp Reisner oc = tconn->cstate; 4478bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4479376694a0SPhilipp Reisner _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4480bbeb641cSPhilipp Reisner 4481360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4482360cc740SPhilipp Reisner 4483f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4484d9cc6e23SLars Ellenberg conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4485360cc740SPhilipp Reisner } 4486360cc740SPhilipp Reisner 4487c141ebdaSPhilipp Reisner static int drbd_disconnected(struct drbd_conf *mdev) 4488360cc740SPhilipp Reisner { 4489360cc740SPhilipp Reisner unsigned int i; 4490b411b363SPhilipp Reisner 449185719573SPhilipp Reisner /* wait for current activity to cease. */ 449287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4493b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4494b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4495b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 449687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4497b411b363SPhilipp Reisner 4498b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4499b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4500b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4501b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4502b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4503b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4504b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4505b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4506b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4507b411b363SPhilipp Reisner * on the fly. */ 4508b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4509b411b363SPhilipp Reisner mdev->rs_total = 0; 4510b411b363SPhilipp Reisner mdev->rs_failed = 0; 4511b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4512b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4513b411b363SPhilipp Reisner 4514b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4515b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4516b411b363SPhilipp Reisner 4517b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4518b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4519b411b363SPhilipp Reisner * to be "canceled" */ 4520a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 4521b411b363SPhilipp Reisner 4522a990be46SAndreas Gruenbacher drbd_finish_peer_reqs(mdev); 4523b411b363SPhilipp Reisner 4524d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 4525d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 4526d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 4527d10b4ea3SPhilipp Reisner drbd_flush_workqueue(mdev); 4528d10b4ea3SPhilipp Reisner 452908332d73SLars Ellenberg /* need to do it again, drbd_finish_peer_reqs() may have populated it 453008332d73SLars Ellenberg * again via drbd_try_clear_on_disk_bm(). */ 453108332d73SLars Ellenberg drbd_rs_cancel_all(mdev); 453208332d73SLars Ellenberg 4533b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4534b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4535b411b363SPhilipp Reisner 45362aebfabbSPhilipp Reisner if (!drbd_suspended(mdev)) 45372f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4538b411b363SPhilipp Reisner 4539b411b363SPhilipp Reisner drbd_md_sync(mdev); 4540b411b363SPhilipp Reisner 454120ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 454220ceb2b2SLars Ellenberg * if any. */ 454320ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 454420ceb2b2SLars Ellenberg 4545b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4546b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4547b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4548b411b363SPhilipp Reisner * 4549b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4550b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4551b411b363SPhilipp Reisner */ 45527721f567SAndreas Gruenbacher i = drbd_free_peer_reqs(mdev, &mdev->net_ee); 4553b411b363SPhilipp Reisner if (i) 4554b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4555435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4556435f0740SLars Ellenberg if (i) 4557435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4558b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4559b411b363SPhilipp Reisner if (i) 456045bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4561b411b363SPhilipp Reisner 4562b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4563b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4564b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4565b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4566b411b363SPhilipp Reisner 4567360cc740SPhilipp Reisner return 0; 4568b411b363SPhilipp Reisner } 4569b411b363SPhilipp Reisner 4570b411b363SPhilipp Reisner /* 4571b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4572b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4573b411b363SPhilipp Reisner * 4574b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4575b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4576b411b363SPhilipp Reisner * 4577b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4578b411b363SPhilipp Reisner */ 45796038178eSAndreas Gruenbacher static int drbd_send_features(struct drbd_tconn *tconn) 4580b411b363SPhilipp Reisner { 45819f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 45829f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4583b411b363SPhilipp Reisner 45849f5bdc33SAndreas Gruenbacher sock = &tconn->data; 45859f5bdc33SAndreas Gruenbacher p = conn_prepare_command(tconn, sock); 45869f5bdc33SAndreas Gruenbacher if (!p) 4587e8d17b01SAndreas Gruenbacher return -EIO; 4588b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4589b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4590b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 45919f5bdc33SAndreas Gruenbacher return conn_send_command(tconn, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4592b411b363SPhilipp Reisner } 4593b411b363SPhilipp Reisner 4594b411b363SPhilipp Reisner /* 4595b411b363SPhilipp Reisner * return values: 4596b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4597b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4598b411b363SPhilipp Reisner * -1 peer talks different language, 4599b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4600b411b363SPhilipp Reisner */ 46016038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn) 4602b411b363SPhilipp Reisner { 460365d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 4604e658983aSAndreas Gruenbacher struct p_connection_features *p; 4605e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 460677351055SPhilipp Reisner struct packet_info pi; 4607a5c31904SAndreas Gruenbacher int err; 4608b411b363SPhilipp Reisner 46096038178eSAndreas Gruenbacher err = drbd_send_features(tconn); 4610e8d17b01SAndreas Gruenbacher if (err) 4611b411b363SPhilipp Reisner return 0; 4612b411b363SPhilipp Reisner 461369bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 461469bc7bc3SAndreas Gruenbacher if (err) 4615b411b363SPhilipp Reisner return 0; 4616b411b363SPhilipp Reisner 46176038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 46186038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 461977351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4620b411b363SPhilipp Reisner return -1; 4621b411b363SPhilipp Reisner } 4622b411b363SPhilipp Reisner 462377351055SPhilipp Reisner if (pi.size != expect) { 46246038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures length: %u, received: %u\n", 462577351055SPhilipp Reisner expect, pi.size); 4626b411b363SPhilipp Reisner return -1; 4627b411b363SPhilipp Reisner } 4628b411b363SPhilipp Reisner 4629e658983aSAndreas Gruenbacher p = pi.data; 4630e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, p, expect); 4631a5c31904SAndreas Gruenbacher if (err) 4632b411b363SPhilipp Reisner return 0; 4633b411b363SPhilipp Reisner 4634b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4635b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4636b411b363SPhilipp Reisner if (p->protocol_max == 0) 4637b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4638b411b363SPhilipp Reisner 4639b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4640b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4641b411b363SPhilipp Reisner goto incompat; 4642b411b363SPhilipp Reisner 464365d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4644b411b363SPhilipp Reisner 464565d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 464665d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4647b411b363SPhilipp Reisner 4648b411b363SPhilipp Reisner return 1; 4649b411b363SPhilipp Reisner 4650b411b363SPhilipp Reisner incompat: 465165d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4652b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4653b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4654b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4655b411b363SPhilipp Reisner return -1; 4656b411b363SPhilipp Reisner } 4657b411b363SPhilipp Reisner 4658b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 465913e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4660b411b363SPhilipp Reisner { 4661b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4662b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4663b10d96cbSJohannes Thoma return -1; 4664b411b363SPhilipp Reisner } 4665b411b363SPhilipp Reisner #else 4666b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4667b10d96cbSJohannes Thoma 4668b10d96cbSJohannes Thoma /* Return value: 4669b10d96cbSJohannes Thoma 1 - auth succeeded, 4670b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4671b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4672b10d96cbSJohannes Thoma */ 4673b10d96cbSJohannes Thoma 467413e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4675b411b363SPhilipp Reisner { 46769f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4677b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4678b411b363SPhilipp Reisner struct scatterlist sg; 4679b411b363SPhilipp Reisner char *response = NULL; 4680b411b363SPhilipp Reisner char *right_response = NULL; 4681b411b363SPhilipp Reisner char *peers_ch = NULL; 468244ed167dSPhilipp Reisner unsigned int key_len; 468344ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4684b411b363SPhilipp Reisner unsigned int resp_size; 4685b411b363SPhilipp Reisner struct hash_desc desc; 468677351055SPhilipp Reisner struct packet_info pi; 468744ed167dSPhilipp Reisner struct net_conf *nc; 468869bc7bc3SAndreas Gruenbacher int err, rv; 4689b411b363SPhilipp Reisner 46909f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 46919f5bdc33SAndreas Gruenbacher 469244ed167dSPhilipp Reisner rcu_read_lock(); 469344ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 469444ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 469544ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 469644ed167dSPhilipp Reisner rcu_read_unlock(); 469744ed167dSPhilipp Reisner 469813e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4699b411b363SPhilipp Reisner desc.flags = 0; 4700b411b363SPhilipp Reisner 470144ed167dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, (u8 *)secret, key_len); 4702b411b363SPhilipp Reisner if (rv) { 470313e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4704b10d96cbSJohannes Thoma rv = -1; 4705b411b363SPhilipp Reisner goto fail; 4706b411b363SPhilipp Reisner } 4707b411b363SPhilipp Reisner 4708b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4709b411b363SPhilipp Reisner 47109f5bdc33SAndreas Gruenbacher sock = &tconn->data; 47119f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 47129f5bdc33SAndreas Gruenbacher rv = 0; 47139f5bdc33SAndreas Gruenbacher goto fail; 47149f5bdc33SAndreas Gruenbacher } 4715e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_CHALLENGE, 0, 47169f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4717b411b363SPhilipp Reisner if (!rv) 4718b411b363SPhilipp Reisner goto fail; 4719b411b363SPhilipp Reisner 472069bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 472169bc7bc3SAndreas Gruenbacher if (err) { 472269bc7bc3SAndreas Gruenbacher rv = 0; 4723b411b363SPhilipp Reisner goto fail; 472469bc7bc3SAndreas Gruenbacher } 4725b411b363SPhilipp Reisner 472677351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 472713e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 472877351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4729b411b363SPhilipp Reisner rv = 0; 4730b411b363SPhilipp Reisner goto fail; 4731b411b363SPhilipp Reisner } 4732b411b363SPhilipp Reisner 473377351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 473413e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4735b10d96cbSJohannes Thoma rv = -1; 4736b411b363SPhilipp Reisner goto fail; 4737b411b363SPhilipp Reisner } 4738b411b363SPhilipp Reisner 473977351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4740b411b363SPhilipp Reisner if (peers_ch == NULL) { 474113e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4742b10d96cbSJohannes Thoma rv = -1; 4743b411b363SPhilipp Reisner goto fail; 4744b411b363SPhilipp Reisner } 4745b411b363SPhilipp Reisner 4746a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, peers_ch, pi.size); 4747a5c31904SAndreas Gruenbacher if (err) { 4748b411b363SPhilipp Reisner rv = 0; 4749b411b363SPhilipp Reisner goto fail; 4750b411b363SPhilipp Reisner } 4751b411b363SPhilipp Reisner 475213e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4753b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4754b411b363SPhilipp Reisner if (response == NULL) { 475513e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4756b10d96cbSJohannes Thoma rv = -1; 4757b411b363SPhilipp Reisner goto fail; 4758b411b363SPhilipp Reisner } 4759b411b363SPhilipp Reisner 4760b411b363SPhilipp Reisner sg_init_table(&sg, 1); 476177351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4762b411b363SPhilipp Reisner 4763b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4764b411b363SPhilipp Reisner if (rv) { 476513e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4766b10d96cbSJohannes Thoma rv = -1; 4767b411b363SPhilipp Reisner goto fail; 4768b411b363SPhilipp Reisner } 4769b411b363SPhilipp Reisner 47709f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 47719f5bdc33SAndreas Gruenbacher rv = 0; 47729f5bdc33SAndreas Gruenbacher goto fail; 47739f5bdc33SAndreas Gruenbacher } 4774e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_RESPONSE, 0, 47759f5bdc33SAndreas Gruenbacher response, resp_size); 4776b411b363SPhilipp Reisner if (!rv) 4777b411b363SPhilipp Reisner goto fail; 4778b411b363SPhilipp Reisner 477969bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 478069bc7bc3SAndreas Gruenbacher if (err) { 478169bc7bc3SAndreas Gruenbacher rv = 0; 4782b411b363SPhilipp Reisner goto fail; 478369bc7bc3SAndreas Gruenbacher } 4784b411b363SPhilipp Reisner 478577351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 478613e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 478777351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4788b411b363SPhilipp Reisner rv = 0; 4789b411b363SPhilipp Reisner goto fail; 4790b411b363SPhilipp Reisner } 4791b411b363SPhilipp Reisner 479277351055SPhilipp Reisner if (pi.size != resp_size) { 479313e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4794b411b363SPhilipp Reisner rv = 0; 4795b411b363SPhilipp Reisner goto fail; 4796b411b363SPhilipp Reisner } 4797b411b363SPhilipp Reisner 4798a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, response , resp_size); 4799a5c31904SAndreas Gruenbacher if (err) { 4800b411b363SPhilipp Reisner rv = 0; 4801b411b363SPhilipp Reisner goto fail; 4802b411b363SPhilipp Reisner } 4803b411b363SPhilipp Reisner 4804b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 48052d1ee87dSJulia Lawall if (right_response == NULL) { 480613e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4807b10d96cbSJohannes Thoma rv = -1; 4808b411b363SPhilipp Reisner goto fail; 4809b411b363SPhilipp Reisner } 4810b411b363SPhilipp Reisner 4811b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4812b411b363SPhilipp Reisner 4813b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4814b411b363SPhilipp Reisner if (rv) { 481513e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4816b10d96cbSJohannes Thoma rv = -1; 4817b411b363SPhilipp Reisner goto fail; 4818b411b363SPhilipp Reisner } 4819b411b363SPhilipp Reisner 4820b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4821b411b363SPhilipp Reisner 4822b411b363SPhilipp Reisner if (rv) 482344ed167dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes HMAC\n", 482444ed167dSPhilipp Reisner resp_size); 4825b10d96cbSJohannes Thoma else 4826b10d96cbSJohannes Thoma rv = -1; 4827b411b363SPhilipp Reisner 4828b411b363SPhilipp Reisner fail: 4829b411b363SPhilipp Reisner kfree(peers_ch); 4830b411b363SPhilipp Reisner kfree(response); 4831b411b363SPhilipp Reisner kfree(right_response); 4832b411b363SPhilipp Reisner 4833b411b363SPhilipp Reisner return rv; 4834b411b363SPhilipp Reisner } 4835b411b363SPhilipp Reisner #endif 4836b411b363SPhilipp Reisner 4837b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4838b411b363SPhilipp Reisner { 4839392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4840b411b363SPhilipp Reisner int h; 4841b411b363SPhilipp Reisner 48424d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4843b411b363SPhilipp Reisner 4844b411b363SPhilipp Reisner do { 484581fa2e67SPhilipp Reisner h = conn_connect(tconn); 4846b411b363SPhilipp Reisner if (h == 0) { 484781fa2e67SPhilipp Reisner conn_disconnect(tconn); 484820ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4849b411b363SPhilipp Reisner } 4850b411b363SPhilipp Reisner if (h == -1) { 48514d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4852bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4853b411b363SPhilipp Reisner } 4854b411b363SPhilipp Reisner } while (h == 0); 4855b411b363SPhilipp Reisner 485691fd4dadSPhilipp Reisner if (h > 0) 48574d641dd7SPhilipp Reisner drbdd(tconn); 4858b411b363SPhilipp Reisner 485981fa2e67SPhilipp Reisner conn_disconnect(tconn); 4860b411b363SPhilipp Reisner 48614d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4862b411b363SPhilipp Reisner return 0; 4863b411b363SPhilipp Reisner } 4864b411b363SPhilipp Reisner 4865b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4866b411b363SPhilipp Reisner 4867e05e1e59SAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4868b411b363SPhilipp Reisner { 4869e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4870b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4871b411b363SPhilipp Reisner 4872fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4873fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4874fc3b10a4SPhilipp Reisner } else { 4875fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4876fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4877fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4878fc3b10a4SPhilipp Reisner } 4879fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4880e4f78edeSPhilipp Reisner 48812735a594SAndreas Gruenbacher return 0; 4882fc3b10a4SPhilipp Reisner } 4883e4f78edeSPhilipp Reisner 48841952e916SAndreas Gruenbacher static int got_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4885e4f78edeSPhilipp Reisner { 48861952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4887e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4888e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4889e4f78edeSPhilipp Reisner 48901952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48911952e916SAndreas Gruenbacher if (!mdev) 48922735a594SAndreas Gruenbacher return -EIO; 48931952e916SAndreas Gruenbacher 48944d0fc3fdSPhilipp Reisner if (test_bit(CONN_WD_ST_CHG_REQ, &tconn->flags)) { 48954d0fc3fdSPhilipp Reisner D_ASSERT(tconn->agreed_pro_version < 100); 48964d0fc3fdSPhilipp Reisner return got_conn_RqSReply(tconn, pi); 48974d0fc3fdSPhilipp Reisner } 48984d0fc3fdSPhilipp Reisner 4899e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4900e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4901e4f78edeSPhilipp Reisner } else { 4902e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4903e4f78edeSPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4904e4f78edeSPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4905e4f78edeSPhilipp Reisner } 4906e4f78edeSPhilipp Reisner wake_up(&mdev->state_wait); 4907e4f78edeSPhilipp Reisner 49082735a594SAndreas Gruenbacher return 0; 4909b411b363SPhilipp Reisner } 4910b411b363SPhilipp Reisner 4911e05e1e59SAndreas Gruenbacher static int got_Ping(struct drbd_tconn *tconn, struct packet_info *pi) 4912b411b363SPhilipp Reisner { 49132735a594SAndreas Gruenbacher return drbd_send_ping_ack(tconn); 4914b411b363SPhilipp Reisner 4915b411b363SPhilipp Reisner } 4916b411b363SPhilipp Reisner 4917e05e1e59SAndreas Gruenbacher static int got_PingAck(struct drbd_tconn *tconn, struct packet_info *pi) 4918b411b363SPhilipp Reisner { 4919b411b363SPhilipp Reisner /* restore idle timeout */ 49202a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 49212a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 49222a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4923b411b363SPhilipp Reisner 49242735a594SAndreas Gruenbacher return 0; 4925b411b363SPhilipp Reisner } 4926b411b363SPhilipp Reisner 49271952e916SAndreas Gruenbacher static int got_IsInSync(struct drbd_tconn *tconn, struct packet_info *pi) 4928b411b363SPhilipp Reisner { 49291952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4930e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4931b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4932b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4933b411b363SPhilipp Reisner 49341952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49351952e916SAndreas Gruenbacher if (!mdev) 49362735a594SAndreas Gruenbacher return -EIO; 49371952e916SAndreas Gruenbacher 493831890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4939b411b363SPhilipp Reisner 4940b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4941b411b363SPhilipp Reisner 49421d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4943b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4944b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4945b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4946b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 49471d53f09eSLars Ellenberg put_ldev(mdev); 49481d53f09eSLars Ellenberg } 4949b411b363SPhilipp Reisner dec_rs_pending(mdev); 4950778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4951b411b363SPhilipp Reisner 49522735a594SAndreas Gruenbacher return 0; 4953b411b363SPhilipp Reisner } 4954b411b363SPhilipp Reisner 4955bc9c5c41SAndreas Gruenbacher static int 4956bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4957bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4958bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4959b411b363SPhilipp Reisner { 4960b411b363SPhilipp Reisner struct drbd_request *req; 4961b411b363SPhilipp Reisner struct bio_and_error m; 4962b411b363SPhilipp Reisner 496387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4964bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4965b411b363SPhilipp Reisner if (unlikely(!req)) { 496687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 496785997675SAndreas Gruenbacher return -EIO; 4968b411b363SPhilipp Reisner } 4969b411b363SPhilipp Reisner __req_mod(req, what, &m); 497087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4971b411b363SPhilipp Reisner 4972b411b363SPhilipp Reisner if (m.bio) 4973b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 497485997675SAndreas Gruenbacher return 0; 4975b411b363SPhilipp Reisner } 4976b411b363SPhilipp Reisner 49771952e916SAndreas Gruenbacher static int got_BlockAck(struct drbd_tconn *tconn, struct packet_info *pi) 4978b411b363SPhilipp Reisner { 49791952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4980e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4981b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4982b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4983b411b363SPhilipp Reisner enum drbd_req_event what; 4984b411b363SPhilipp Reisner 49851952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49861952e916SAndreas Gruenbacher if (!mdev) 49872735a594SAndreas Gruenbacher return -EIO; 49881952e916SAndreas Gruenbacher 4989b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4990b411b363SPhilipp Reisner 4991579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4992b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4993b411b363SPhilipp Reisner dec_rs_pending(mdev); 49942735a594SAndreas Gruenbacher return 0; 4995b411b363SPhilipp Reisner } 4996e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4997b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 49988554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4999b411b363SPhilipp Reisner break; 5000b411b363SPhilipp Reisner case P_WRITE_ACK: 50018554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 5002b411b363SPhilipp Reisner break; 5003b411b363SPhilipp Reisner case P_RECV_ACK: 50048554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 5005b411b363SPhilipp Reisner break; 5006d4dabbe2SLars Ellenberg case P_SUPERSEDED: 5007d4dabbe2SLars Ellenberg what = CONFLICT_RESOLVED; 50087be8da07SAndreas Gruenbacher break; 50097be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 50107be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5011b411b363SPhilipp Reisner break; 5012b411b363SPhilipp Reisner default: 50132735a594SAndreas Gruenbacher BUG(); 5014b411b363SPhilipp Reisner } 5015b411b363SPhilipp Reisner 50162735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 5017bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 5018bc9c5c41SAndreas Gruenbacher what, false); 5019b411b363SPhilipp Reisner } 5020b411b363SPhilipp Reisner 50211952e916SAndreas Gruenbacher static int got_NegAck(struct drbd_tconn *tconn, struct packet_info *pi) 5022b411b363SPhilipp Reisner { 50231952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5024e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5025b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 50262deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 502785997675SAndreas Gruenbacher int err; 5028b411b363SPhilipp Reisner 50291952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50301952e916SAndreas Gruenbacher if (!mdev) 50312735a594SAndreas Gruenbacher return -EIO; 50321952e916SAndreas Gruenbacher 5033b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5034b411b363SPhilipp Reisner 5035579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5036b411b363SPhilipp Reisner dec_rs_pending(mdev); 5037b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 50382735a594SAndreas Gruenbacher return 0; 5039b411b363SPhilipp Reisner } 50402deb8336SPhilipp Reisner 504185997675SAndreas Gruenbacher err = validate_req_change_req_state(mdev, p->block_id, sector, 5042bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 5043303d1448SPhilipp Reisner NEG_ACKED, true); 504485997675SAndreas Gruenbacher if (err) { 50452deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 50462deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5047c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 50482deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 50492deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 5050c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 50512deb8336SPhilipp Reisner } 50522735a594SAndreas Gruenbacher return 0; 5053b411b363SPhilipp Reisner } 5054b411b363SPhilipp Reisner 50551952e916SAndreas Gruenbacher static int got_NegDReply(struct drbd_tconn *tconn, struct packet_info *pi) 5056b411b363SPhilipp Reisner { 50571952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5058e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5059b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5060b411b363SPhilipp Reisner 50611952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50621952e916SAndreas Gruenbacher if (!mdev) 50632735a594SAndreas Gruenbacher return -EIO; 50641952e916SAndreas Gruenbacher 5065b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 50667be8da07SAndreas Gruenbacher 5067380207d0SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u.\n", 5068b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5069b411b363SPhilipp Reisner 50702735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 5071bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 50728554df1cSAndreas Gruenbacher NEG_ACKED, false); 5073b411b363SPhilipp Reisner } 5074b411b363SPhilipp Reisner 50751952e916SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_tconn *tconn, struct packet_info *pi) 5076b411b363SPhilipp Reisner { 50771952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5078b411b363SPhilipp Reisner sector_t sector; 5079b411b363SPhilipp Reisner int size; 5080e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 50811952e916SAndreas Gruenbacher 50821952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50831952e916SAndreas Gruenbacher if (!mdev) 50842735a594SAndreas Gruenbacher return -EIO; 5085b411b363SPhilipp Reisner 5086b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5087b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5088b411b363SPhilipp Reisner 5089b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5090b411b363SPhilipp Reisner 5091b411b363SPhilipp Reisner dec_rs_pending(mdev); 5092b411b363SPhilipp Reisner 5093b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 5094b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 5095e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5096d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5097b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 5098d612d309SPhilipp Reisner case P_RS_CANCEL: 5099d612d309SPhilipp Reisner break; 5100d612d309SPhilipp Reisner default: 51012735a594SAndreas Gruenbacher BUG(); 5102d612d309SPhilipp Reisner } 5103b411b363SPhilipp Reisner put_ldev(mdev); 5104b411b363SPhilipp Reisner } 5105b411b363SPhilipp Reisner 51062735a594SAndreas Gruenbacher return 0; 5107b411b363SPhilipp Reisner } 5108b411b363SPhilipp Reisner 51091952e916SAndreas Gruenbacher static int got_BarrierAck(struct drbd_tconn *tconn, struct packet_info *pi) 5110b411b363SPhilipp Reisner { 5111e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 51129ed57dcbSLars Ellenberg struct drbd_conf *mdev; 51139ed57dcbSLars Ellenberg int vnr; 51141952e916SAndreas Gruenbacher 51159ed57dcbSLars Ellenberg tl_release(tconn, p->barrier, be32_to_cpu(p->set_size)); 5116b411b363SPhilipp Reisner 51179ed57dcbSLars Ellenberg rcu_read_lock(); 51189ed57dcbSLars Ellenberg idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5119c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 5120c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 512136baf611SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->flags)) { 5122370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 5123370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 5124c4752ef1SPhilipp Reisner } 51259ed57dcbSLars Ellenberg } 51269ed57dcbSLars Ellenberg rcu_read_unlock(); 5127c4752ef1SPhilipp Reisner 51282735a594SAndreas Gruenbacher return 0; 5129b411b363SPhilipp Reisner } 5130b411b363SPhilipp Reisner 51311952e916SAndreas Gruenbacher static int got_OVResult(struct drbd_tconn *tconn, struct packet_info *pi) 5132b411b363SPhilipp Reisner { 51331952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5134e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5135b411b363SPhilipp Reisner struct drbd_work *w; 5136b411b363SPhilipp Reisner sector_t sector; 5137b411b363SPhilipp Reisner int size; 5138b411b363SPhilipp Reisner 51391952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 51401952e916SAndreas Gruenbacher if (!mdev) 51412735a594SAndreas Gruenbacher return -EIO; 51421952e916SAndreas Gruenbacher 5143b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5144b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5145b411b363SPhilipp Reisner 5146b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5147b411b363SPhilipp Reisner 5148b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 51498f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 5150b411b363SPhilipp Reisner else 51518f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5152b411b363SPhilipp Reisner 51531d53f09eSLars Ellenberg if (!get_ldev(mdev)) 51542735a594SAndreas Gruenbacher return 0; 51551d53f09eSLars Ellenberg 5156b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 5157b411b363SPhilipp Reisner dec_rs_pending(mdev); 5158b411b363SPhilipp Reisner 5159ea5442afSLars Ellenberg --mdev->ov_left; 5160ea5442afSLars Ellenberg 5161ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5162ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 5163ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 5164ea5442afSLars Ellenberg 5165ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 5166b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 5167b411b363SPhilipp Reisner if (w) { 5168b411b363SPhilipp Reisner w->cb = w_ov_finished; 5169a21e9298SPhilipp Reisner w->mdev = mdev; 5170d5b27b01SLars Ellenberg drbd_queue_work(&mdev->tconn->sender_work, w); 5171b411b363SPhilipp Reisner } else { 5172b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 51738f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5174b411b363SPhilipp Reisner drbd_resync_finished(mdev); 5175b411b363SPhilipp Reisner } 5176b411b363SPhilipp Reisner } 51771d53f09eSLars Ellenberg put_ldev(mdev); 51782735a594SAndreas Gruenbacher return 0; 5179b411b363SPhilipp Reisner } 5180b411b363SPhilipp Reisner 51811952e916SAndreas Gruenbacher static int got_skip(struct drbd_tconn *tconn, struct packet_info *pi) 51820ced55a3SPhilipp Reisner { 51832735a594SAndreas Gruenbacher return 0; 51840ced55a3SPhilipp Reisner } 51850ced55a3SPhilipp Reisner 5186a990be46SAndreas Gruenbacher static int tconn_finish_peer_reqs(struct drbd_tconn *tconn) 518732862ec7SPhilipp Reisner { 5188082a3439SPhilipp Reisner struct drbd_conf *mdev; 5189c141ebdaSPhilipp Reisner int vnr, not_empty = 0; 519032862ec7SPhilipp Reisner 519132862ec7SPhilipp Reisner do { 519232862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 519332862ec7SPhilipp Reisner flush_signals(current); 5194c141ebdaSPhilipp Reisner 5195c141ebdaSPhilipp Reisner rcu_read_lock(); 5196c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5197c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 5198c141ebdaSPhilipp Reisner rcu_read_unlock(); 5199d3fcb490SPhilipp Reisner if (drbd_finish_peer_reqs(mdev)) { 5200c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5201c141ebdaSPhilipp Reisner return 1; 5202082a3439SPhilipp Reisner } 5203c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5204c141ebdaSPhilipp Reisner rcu_read_lock(); 5205d3fcb490SPhilipp Reisner } 520632862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 5207082a3439SPhilipp Reisner 5208082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 5209c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5210082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 5211082a3439SPhilipp Reisner if (not_empty) 5212082a3439SPhilipp Reisner break; 5213082a3439SPhilipp Reisner } 5214082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 5215c141ebdaSPhilipp Reisner rcu_read_unlock(); 521632862ec7SPhilipp Reisner } while (not_empty); 521732862ec7SPhilipp Reisner 521832862ec7SPhilipp Reisner return 0; 521932862ec7SPhilipp Reisner } 522032862ec7SPhilipp Reisner 52217201b972SAndreas Gruenbacher struct asender_cmd { 52227201b972SAndreas Gruenbacher size_t pkt_size; 52231952e916SAndreas Gruenbacher int (*fn)(struct drbd_tconn *tconn, struct packet_info *); 52247201b972SAndreas Gruenbacher }; 52257201b972SAndreas Gruenbacher 52267201b972SAndreas Gruenbacher static struct asender_cmd asender_tbl[] = { 5227e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5228e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 52291952e916SAndreas Gruenbacher [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 52301952e916SAndreas Gruenbacher [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 52311952e916SAndreas Gruenbacher [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5232d4dabbe2SLars Ellenberg [P_SUPERSEDED] = { sizeof(struct p_block_ack), got_BlockAck }, 52331952e916SAndreas Gruenbacher [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 52341952e916SAndreas Gruenbacher [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 52351952e916SAndreas Gruenbacher [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 52361952e916SAndreas Gruenbacher [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 52371952e916SAndreas Gruenbacher [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 52381952e916SAndreas Gruenbacher [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 52391952e916SAndreas Gruenbacher [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 52401952e916SAndreas Gruenbacher [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 52411952e916SAndreas Gruenbacher [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 52421952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 52431952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 52447201b972SAndreas Gruenbacher }; 52457201b972SAndreas Gruenbacher 5246b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5247b411b363SPhilipp Reisner { 5248392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 5249b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 525077351055SPhilipp Reisner struct packet_info pi; 5251257d0af6SPhilipp Reisner int rv; 5252e658983aSAndreas Gruenbacher void *buf = tconn->meta.rbuf; 5253b411b363SPhilipp Reisner int received = 0; 525452b061a4SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 525552b061a4SAndreas Gruenbacher int expect = header_size; 525644ed167dSPhilipp Reisner bool ping_timeout_active = false; 525744ed167dSPhilipp Reisner struct net_conf *nc; 5258bb77d34eSAndreas Gruenbacher int ping_timeo, tcp_cork, ping_int; 5259b411b363SPhilipp Reisner 5260b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 5261b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 5262b411b363SPhilipp Reisner 5263e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 526480822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 526544ed167dSPhilipp Reisner 526644ed167dSPhilipp Reisner rcu_read_lock(); 526744ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 526844ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 5269bb77d34eSAndreas Gruenbacher tcp_cork = nc->tcp_cork; 527044ed167dSPhilipp Reisner ping_int = nc->ping_int; 527144ed167dSPhilipp Reisner rcu_read_unlock(); 527244ed167dSPhilipp Reisner 527332862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 5274a17647aaSAndreas Gruenbacher if (drbd_send_ping(tconn)) { 527532862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 5276841ce241SAndreas Gruenbacher goto reconnect; 5277841ce241SAndreas Gruenbacher } 527844ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 527944ed167dSPhilipp Reisner ping_timeout_active = true; 5280b411b363SPhilipp Reisner } 5281b411b363SPhilipp Reisner 528232862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 528332862ec7SPhilipp Reisner much to send */ 5284bb77d34eSAndreas Gruenbacher if (tcp_cork) 528532862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 5286a990be46SAndreas Gruenbacher if (tconn_finish_peer_reqs(tconn)) { 5287a990be46SAndreas Gruenbacher conn_err(tconn, "tconn_finish_peer_reqs() failed\n"); 5288b411b363SPhilipp Reisner goto reconnect; 5289082a3439SPhilipp Reisner } 5290b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 5291bb77d34eSAndreas Gruenbacher if (tcp_cork) 529232862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 5293b411b363SPhilipp Reisner 5294b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5295b411b363SPhilipp Reisner if (signal_pending(current)) 5296b411b363SPhilipp Reisner continue; 5297b411b363SPhilipp Reisner 529832862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 529932862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5300b411b363SPhilipp Reisner 5301b411b363SPhilipp Reisner flush_signals(current); 5302b411b363SPhilipp Reisner 5303b411b363SPhilipp Reisner /* Note: 5304b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5305b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5306b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5307b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5308b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5309b411b363SPhilipp Reisner * rv == expected: full header or command 5310b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5311b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5312b411b363SPhilipp Reisner */ 5313b411b363SPhilipp Reisner if (likely(rv > 0)) { 5314b411b363SPhilipp Reisner received += rv; 5315b411b363SPhilipp Reisner buf += rv; 5316b411b363SPhilipp Reisner } else if (rv == 0) { 5317b66623e3SPhilipp Reisner if (test_bit(DISCONNECT_SENT, &tconn->flags)) { 5318b66623e3SPhilipp Reisner long t; 5319b66623e3SPhilipp Reisner rcu_read_lock(); 5320b66623e3SPhilipp Reisner t = rcu_dereference(tconn->net_conf)->ping_timeo * HZ/10; 5321b66623e3SPhilipp Reisner rcu_read_unlock(); 5322b66623e3SPhilipp Reisner 5323b66623e3SPhilipp Reisner t = wait_event_timeout(tconn->ping_wait, 5324b66623e3SPhilipp Reisner tconn->cstate < C_WF_REPORT_PARAMS, 5325b66623e3SPhilipp Reisner t); 5326b66623e3SPhilipp Reisner if (t) 5327b66623e3SPhilipp Reisner break; 5328b66623e3SPhilipp Reisner } 532932862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 5330b411b363SPhilipp Reisner goto reconnect; 5331b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5332cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5333cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 533432862ec7SPhilipp Reisner if (time_after(tconn->last_received, 533532862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 5336cb6518cbSLars Ellenberg continue; 5337f36af18cSLars Ellenberg if (ping_timeout_active) { 533832862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 5339b411b363SPhilipp Reisner goto reconnect; 5340b411b363SPhilipp Reisner } 534132862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 5342b411b363SPhilipp Reisner continue; 5343b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5344b411b363SPhilipp Reisner continue; 5345b411b363SPhilipp Reisner } else { 534632862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 5347b411b363SPhilipp Reisner goto reconnect; 5348b411b363SPhilipp Reisner } 5349b411b363SPhilipp Reisner 5350b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5351e658983aSAndreas Gruenbacher if (decode_header(tconn, tconn->meta.rbuf, &pi)) 5352b411b363SPhilipp Reisner goto reconnect; 53537201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 53541952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 53552fcb8f30SAndreas Gruenbacher conn_err(tconn, "Unexpected meta packet %s (0x%04x)\n", 53562fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5357b411b363SPhilipp Reisner goto disconnect; 5358b411b363SPhilipp Reisner } 5359e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 536052b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 536132862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 536277351055SPhilipp Reisner pi.cmd, pi.size); 5363b411b363SPhilipp Reisner goto reconnect; 5364b411b363SPhilipp Reisner } 5365257d0af6SPhilipp Reisner } 5366b411b363SPhilipp Reisner if (received == expect) { 53672735a594SAndreas Gruenbacher bool err; 5368a4fbda8eSPhilipp Reisner 53692735a594SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 53702735a594SAndreas Gruenbacher if (err) { 53711952e916SAndreas Gruenbacher conn_err(tconn, "%pf failed\n", cmd->fn); 5372b411b363SPhilipp Reisner goto reconnect; 53731952e916SAndreas Gruenbacher } 5374b411b363SPhilipp Reisner 5375a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 5376a4fbda8eSPhilipp Reisner 537744ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 537844ed167dSPhilipp Reisner /* restore idle timeout */ 537944ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 538044ed167dSPhilipp Reisner ping_timeout_active = false; 538144ed167dSPhilipp Reisner } 5382f36af18cSLars Ellenberg 5383e658983aSAndreas Gruenbacher buf = tconn->meta.rbuf; 5384b411b363SPhilipp Reisner received = 0; 538552b061a4SAndreas Gruenbacher expect = header_size; 5386b411b363SPhilipp Reisner cmd = NULL; 5387b411b363SPhilipp Reisner } 5388b411b363SPhilipp Reisner } 5389b411b363SPhilipp Reisner 5390b411b363SPhilipp Reisner if (0) { 5391b411b363SPhilipp Reisner reconnect: 5392bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5393b411b363SPhilipp Reisner } 5394b411b363SPhilipp Reisner if (0) { 5395b411b363SPhilipp Reisner disconnect: 5396bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 5397b411b363SPhilipp Reisner } 539832862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5399b411b363SPhilipp Reisner 540032862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 5401b411b363SPhilipp Reisner 5402b411b363SPhilipp Reisner return 0; 5403b411b363SPhilipp Reisner } 5404