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: 4287be8da07SAndreas Gruenbacher * e_end_block, and e_end_resync_block, e_send_discard_write. 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); 507b411b363SPhilipp Reisner 508b411b363SPhilipp Reisner for (;;) { 509de0ff338SPhilipp Reisner rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags); 510b411b363SPhilipp Reisner if (rv == size) 511b411b363SPhilipp Reisner break; 512b411b363SPhilipp Reisner 513b411b363SPhilipp Reisner /* Note: 514b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 515b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 516b411b363SPhilipp Reisner */ 517b411b363SPhilipp Reisner 518b411b363SPhilipp Reisner if (rv < 0) { 519b411b363SPhilipp Reisner if (rv == -ECONNRESET) 520de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 521b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 522de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 523b411b363SPhilipp Reisner break; 524b411b363SPhilipp Reisner } else if (rv == 0) { 525de0ff338SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 526b411b363SPhilipp Reisner break; 527b411b363SPhilipp Reisner } else { 528b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 529b411b363SPhilipp Reisner * after we read a partial message 530b411b363SPhilipp Reisner */ 531b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 532b411b363SPhilipp Reisner break; 533b411b363SPhilipp Reisner } 534b411b363SPhilipp Reisner }; 535b411b363SPhilipp Reisner 536b411b363SPhilipp Reisner set_fs(oldfs); 537b411b363SPhilipp Reisner 538b411b363SPhilipp Reisner if (rv != size) 539bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 540b411b363SPhilipp Reisner 541b411b363SPhilipp Reisner return rv; 542b411b363SPhilipp Reisner } 543b411b363SPhilipp Reisner 544c6967746SAndreas Gruenbacher static int drbd_recv_all(struct drbd_tconn *tconn, void *buf, size_t size) 545c6967746SAndreas Gruenbacher { 546c6967746SAndreas Gruenbacher int err; 547c6967746SAndreas Gruenbacher 548c6967746SAndreas Gruenbacher err = drbd_recv(tconn, buf, size); 549c6967746SAndreas Gruenbacher if (err != size) { 550c6967746SAndreas Gruenbacher if (err >= 0) 551c6967746SAndreas Gruenbacher err = -EIO; 552c6967746SAndreas Gruenbacher } else 553c6967746SAndreas Gruenbacher err = 0; 554c6967746SAndreas Gruenbacher return err; 555c6967746SAndreas Gruenbacher } 556c6967746SAndreas Gruenbacher 557a5c31904SAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_tconn *tconn, void *buf, size_t size) 558a5c31904SAndreas Gruenbacher { 559a5c31904SAndreas Gruenbacher int err; 560a5c31904SAndreas Gruenbacher 561a5c31904SAndreas Gruenbacher err = drbd_recv_all(tconn, buf, size); 562a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 563a5c31904SAndreas Gruenbacher conn_warn(tconn, "short read (expected size %d)\n", (int)size); 564a5c31904SAndreas Gruenbacher return err; 565a5c31904SAndreas Gruenbacher } 566a5c31904SAndreas Gruenbacher 5675dbf1673SLars Ellenberg /* quoting tcp(7): 5685dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5695dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5705dbf1673SLars Ellenberg * This is our wrapper to do so. 5715dbf1673SLars Ellenberg */ 5725dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5735dbf1673SLars Ellenberg unsigned int rcv) 5745dbf1673SLars Ellenberg { 5755dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5765dbf1673SLars Ellenberg if (snd) { 5775dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5785dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5795dbf1673SLars Ellenberg } 5805dbf1673SLars Ellenberg if (rcv) { 5815dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5825dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5835dbf1673SLars Ellenberg } 5845dbf1673SLars Ellenberg } 5855dbf1673SLars Ellenberg 586eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 587b411b363SPhilipp Reisner { 588b411b363SPhilipp Reisner const char *what; 589b411b363SPhilipp Reisner struct socket *sock; 590b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 59144ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 59244ed167dSPhilipp Reisner struct net_conf *nc; 59344ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 59469ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 595b411b363SPhilipp Reisner int disconnect_on_error = 1; 596b411b363SPhilipp Reisner 59744ed167dSPhilipp Reisner rcu_read_lock(); 59844ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 59944ed167dSPhilipp Reisner if (!nc) { 60044ed167dSPhilipp Reisner rcu_read_unlock(); 601b411b363SPhilipp Reisner return NULL; 60244ed167dSPhilipp Reisner } 60344ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 60444ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 60569ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 606089c075dSAndreas Gruenbacher rcu_read_unlock(); 60744ed167dSPhilipp Reisner 608089c075dSAndreas Gruenbacher my_addr_len = min_t(int, tconn->my_addr_len, sizeof(src_in6)); 609089c075dSAndreas Gruenbacher memcpy(&src_in6, &tconn->my_addr, my_addr_len); 61044ed167dSPhilipp Reisner 611089c075dSAndreas Gruenbacher if (((struct sockaddr *)&tconn->my_addr)->sa_family == AF_INET6) 61244ed167dSPhilipp Reisner src_in6.sin6_port = 0; 61344ed167dSPhilipp Reisner else 61444ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 61544ed167dSPhilipp Reisner 616089c075dSAndreas Gruenbacher peer_addr_len = min_t(int, tconn->peer_addr_len, sizeof(src_in6)); 617089c075dSAndreas Gruenbacher memcpy(&peer_in6, &tconn->peer_addr, peer_addr_len); 618b411b363SPhilipp Reisner 619b411b363SPhilipp Reisner what = "sock_create_kern"; 62044ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family, 621b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 622b411b363SPhilipp Reisner if (err < 0) { 623b411b363SPhilipp Reisner sock = NULL; 624b411b363SPhilipp Reisner goto out; 625b411b363SPhilipp Reisner } 626b411b363SPhilipp Reisner 627b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 62869ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 62944ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 630b411b363SPhilipp Reisner 631b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 632b411b363SPhilipp Reisner * for the outgoing connections. 633b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 634b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 635b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 636b411b363SPhilipp Reisner * a free one dynamically. 637b411b363SPhilipp Reisner */ 638b411b363SPhilipp Reisner what = "bind before connect"; 63944ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 640b411b363SPhilipp Reisner if (err < 0) 641b411b363SPhilipp Reisner goto out; 642b411b363SPhilipp Reisner 643b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 644b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 645b411b363SPhilipp Reisner disconnect_on_error = 0; 646b411b363SPhilipp Reisner what = "connect"; 64744ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 648b411b363SPhilipp Reisner 649b411b363SPhilipp Reisner out: 650b411b363SPhilipp Reisner if (err < 0) { 651b411b363SPhilipp Reisner if (sock) { 652b411b363SPhilipp Reisner sock_release(sock); 653b411b363SPhilipp Reisner sock = NULL; 654b411b363SPhilipp Reisner } 655b411b363SPhilipp Reisner switch (-err) { 656b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 657b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 658b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 659b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 660b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 661b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 662b411b363SPhilipp Reisner disconnect_on_error = 0; 663b411b363SPhilipp Reisner break; 664b411b363SPhilipp Reisner default: 665eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 666b411b363SPhilipp Reisner } 667b411b363SPhilipp Reisner if (disconnect_on_error) 668bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 669b411b363SPhilipp Reisner } 67044ed167dSPhilipp Reisner 671b411b363SPhilipp Reisner return sock; 672b411b363SPhilipp Reisner } 673b411b363SPhilipp Reisner 6747a426fd8SPhilipp Reisner struct accept_wait_data { 6757a426fd8SPhilipp Reisner struct drbd_tconn *tconn; 6767a426fd8SPhilipp Reisner struct socket *s_listen; 6777a426fd8SPhilipp Reisner struct completion door_bell; 6787a426fd8SPhilipp Reisner void (*original_sk_state_change)(struct sock *sk); 6797a426fd8SPhilipp Reisner 6807a426fd8SPhilipp Reisner }; 6817a426fd8SPhilipp Reisner 6827a426fd8SPhilipp Reisner static void incomming_connection(struct sock *sk) 6837a426fd8SPhilipp Reisner { 6847a426fd8SPhilipp Reisner struct accept_wait_data *ad = sk->sk_user_data; 6857a426fd8SPhilipp Reisner struct drbd_tconn *tconn = ad->tconn; 6867a426fd8SPhilipp Reisner 6877a426fd8SPhilipp Reisner if (sk->sk_state != TCP_ESTABLISHED) 6887a426fd8SPhilipp Reisner conn_warn(tconn, "unexpected tcp state change. sk_state = %d\n", sk->sk_state); 6897a426fd8SPhilipp Reisner 6907a426fd8SPhilipp Reisner write_lock_bh(&sk->sk_callback_lock); 6917a426fd8SPhilipp Reisner sk->sk_state_change = ad->original_sk_state_change; 6927a426fd8SPhilipp Reisner sk->sk_user_data = NULL; 6937a426fd8SPhilipp Reisner write_unlock_bh(&sk->sk_callback_lock); 6947a426fd8SPhilipp Reisner 6957a426fd8SPhilipp Reisner sk->sk_state_change(sk); 6967a426fd8SPhilipp Reisner complete(&ad->door_bell); 6977a426fd8SPhilipp Reisner } 6987a426fd8SPhilipp Reisner 6997a426fd8SPhilipp Reisner static int prepare_listen_socket(struct drbd_tconn *tconn, struct accept_wait_data *ad) 700b411b363SPhilipp Reisner { 7011f3e509bSPhilipp Reisner int err, sndbuf_size, rcvbuf_size, my_addr_len; 70244ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 7031f3e509bSPhilipp Reisner struct socket *s_listen; 70444ed167dSPhilipp Reisner struct net_conf *nc; 705b411b363SPhilipp Reisner const char *what; 706b411b363SPhilipp Reisner 70744ed167dSPhilipp Reisner rcu_read_lock(); 70844ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 70944ed167dSPhilipp Reisner if (!nc) { 71044ed167dSPhilipp Reisner rcu_read_unlock(); 7117a426fd8SPhilipp Reisner return -EIO; 71244ed167dSPhilipp Reisner } 71344ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 71444ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 71544ed167dSPhilipp Reisner rcu_read_unlock(); 716b411b363SPhilipp Reisner 717089c075dSAndreas Gruenbacher my_addr_len = min_t(int, tconn->my_addr_len, sizeof(struct sockaddr_in6)); 718089c075dSAndreas Gruenbacher memcpy(&my_addr, &tconn->my_addr, my_addr_len); 719089c075dSAndreas Gruenbacher 720b411b363SPhilipp Reisner what = "sock_create_kern"; 72144ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family, 722b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 723b411b363SPhilipp Reisner if (err) { 724b411b363SPhilipp Reisner s_listen = NULL; 725b411b363SPhilipp Reisner goto out; 726b411b363SPhilipp Reisner } 727b411b363SPhilipp Reisner 728b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 72944ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 730b411b363SPhilipp Reisner 731b411b363SPhilipp Reisner what = "bind before listen"; 73244ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 733b411b363SPhilipp Reisner if (err < 0) 734b411b363SPhilipp Reisner goto out; 735b411b363SPhilipp Reisner 7367a426fd8SPhilipp Reisner ad->s_listen = s_listen; 7377a426fd8SPhilipp Reisner write_lock_bh(&s_listen->sk->sk_callback_lock); 7387a426fd8SPhilipp Reisner ad->original_sk_state_change = s_listen->sk->sk_state_change; 7397a426fd8SPhilipp Reisner s_listen->sk->sk_state_change = incomming_connection; 7407a426fd8SPhilipp Reisner s_listen->sk->sk_user_data = ad; 7417a426fd8SPhilipp Reisner write_unlock_bh(&s_listen->sk->sk_callback_lock); 7427a426fd8SPhilipp Reisner 7432820fd39SPhilipp Reisner what = "listen"; 7442820fd39SPhilipp Reisner err = s_listen->ops->listen(s_listen, 5); 7452820fd39SPhilipp Reisner if (err < 0) 7462820fd39SPhilipp Reisner goto out; 7472820fd39SPhilipp Reisner 7487a426fd8SPhilipp Reisner return 0; 7491f3e509bSPhilipp Reisner out: 7501f3e509bSPhilipp Reisner if (s_listen) 7511f3e509bSPhilipp Reisner sock_release(s_listen); 7521f3e509bSPhilipp Reisner if (err < 0) { 7531f3e509bSPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7541f3e509bSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 7551f3e509bSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 7561f3e509bSPhilipp Reisner } 7571f3e509bSPhilipp Reisner } 7581f3e509bSPhilipp Reisner 7597a426fd8SPhilipp Reisner return -EIO; 7601f3e509bSPhilipp Reisner } 7611f3e509bSPhilipp Reisner 7627a426fd8SPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn, struct accept_wait_data *ad) 7631f3e509bSPhilipp Reisner { 7641f3e509bSPhilipp Reisner int timeo, connect_int, err = 0; 7651f3e509bSPhilipp Reisner struct socket *s_estab = NULL; 7661f3e509bSPhilipp Reisner struct net_conf *nc; 7671f3e509bSPhilipp Reisner 7681f3e509bSPhilipp Reisner rcu_read_lock(); 7691f3e509bSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 7701f3e509bSPhilipp Reisner if (!nc) { 7711f3e509bSPhilipp Reisner rcu_read_unlock(); 7721f3e509bSPhilipp Reisner return NULL; 7731f3e509bSPhilipp Reisner } 7741f3e509bSPhilipp Reisner connect_int = nc->connect_int; 7751f3e509bSPhilipp Reisner rcu_read_unlock(); 7761f3e509bSPhilipp Reisner 7771f3e509bSPhilipp Reisner timeo = connect_int * HZ; 7781f3e509bSPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 7791f3e509bSPhilipp Reisner 7807a426fd8SPhilipp Reisner err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); 7817a426fd8SPhilipp Reisner if (err <= 0) 7827a426fd8SPhilipp Reisner return NULL; 7831f3e509bSPhilipp Reisner 7847a426fd8SPhilipp Reisner err = kernel_accept(ad->s_listen, &s_estab, 0); 785b411b363SPhilipp Reisner if (err < 0) { 786b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7871f3e509bSPhilipp Reisner conn_err(tconn, "accept failed, err = %d\n", err); 788bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 789b411b363SPhilipp Reisner } 790b411b363SPhilipp Reisner } 791b411b363SPhilipp Reisner 792b411b363SPhilipp Reisner return s_estab; 793b411b363SPhilipp Reisner } 794b411b363SPhilipp Reisner 795e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *, void *, struct packet_info *); 796b411b363SPhilipp Reisner 7979f5bdc33SAndreas Gruenbacher static int send_first_packet(struct drbd_tconn *tconn, struct drbd_socket *sock, 7989f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7999f5bdc33SAndreas Gruenbacher { 8009f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) 8019f5bdc33SAndreas Gruenbacher return -EIO; 802e658983aSAndreas Gruenbacher return conn_send_command(tconn, sock, cmd, 0, NULL, 0); 803b411b363SPhilipp Reisner } 804b411b363SPhilipp Reisner 8059f5bdc33SAndreas Gruenbacher static int receive_first_packet(struct drbd_tconn *tconn, struct socket *sock) 806b411b363SPhilipp Reisner { 8079f5bdc33SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 8089f5bdc33SAndreas Gruenbacher struct packet_info pi; 8099f5bdc33SAndreas Gruenbacher int err; 810b411b363SPhilipp Reisner 8119f5bdc33SAndreas Gruenbacher err = drbd_recv_short(sock, tconn->data.rbuf, header_size, 0); 8129f5bdc33SAndreas Gruenbacher if (err != header_size) { 8139f5bdc33SAndreas Gruenbacher if (err >= 0) 8149f5bdc33SAndreas Gruenbacher err = -EIO; 8159f5bdc33SAndreas Gruenbacher return err; 8169f5bdc33SAndreas Gruenbacher } 8179f5bdc33SAndreas Gruenbacher err = decode_header(tconn, tconn->data.rbuf, &pi); 8189f5bdc33SAndreas Gruenbacher if (err) 8199f5bdc33SAndreas Gruenbacher return err; 8209f5bdc33SAndreas Gruenbacher return pi.cmd; 821b411b363SPhilipp Reisner } 822b411b363SPhilipp Reisner 823b411b363SPhilipp Reisner /** 824b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 825b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 826b411b363SPhilipp Reisner */ 827dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 828b411b363SPhilipp Reisner { 829b411b363SPhilipp Reisner int rr; 830b411b363SPhilipp Reisner char tb[4]; 831b411b363SPhilipp Reisner 832b411b363SPhilipp Reisner if (!*sock) 83381e84650SAndreas Gruenbacher return false; 834b411b363SPhilipp Reisner 835dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 836b411b363SPhilipp Reisner 837b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 83881e84650SAndreas Gruenbacher return true; 839b411b363SPhilipp Reisner } else { 840b411b363SPhilipp Reisner sock_release(*sock); 841b411b363SPhilipp Reisner *sock = NULL; 84281e84650SAndreas Gruenbacher return false; 843b411b363SPhilipp Reisner } 844b411b363SPhilipp Reisner } 8452325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8462325eb66SPhilipp Reisner in a connection */ 847c141ebdaSPhilipp Reisner int drbd_connected(struct drbd_conf *mdev) 848907599e0SPhilipp Reisner { 8490829f5edSAndreas Gruenbacher int err; 850907599e0SPhilipp Reisner 851907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 852907599e0SPhilipp Reisner mdev->peer_seq = 0; 853907599e0SPhilipp Reisner 8548410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 8558410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 8568410da8fSPhilipp Reisner &mdev->own_state_mutex; 8578410da8fSPhilipp Reisner 8580829f5edSAndreas Gruenbacher err = drbd_send_sync_param(mdev); 8590829f5edSAndreas Gruenbacher if (!err) 8600829f5edSAndreas Gruenbacher err = drbd_send_sizes(mdev, 0, 0); 8610829f5edSAndreas Gruenbacher if (!err) 8620829f5edSAndreas Gruenbacher err = drbd_send_uuids(mdev); 8630829f5edSAndreas Gruenbacher if (!err) 86443de7c85SPhilipp Reisner err = drbd_send_current_state(mdev); 865907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 866907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 8678b924f1dSPhilipp Reisner mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */ 8680829f5edSAndreas Gruenbacher return err; 869907599e0SPhilipp Reisner } 870907599e0SPhilipp Reisner 871b411b363SPhilipp Reisner /* 872b411b363SPhilipp Reisner * return values: 873b411b363SPhilipp Reisner * 1 yes, we have a valid connection 874b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 875b411b363SPhilipp Reisner * -1 peer talks different language, 876b411b363SPhilipp Reisner * no point in trying again, please go standalone. 877b411b363SPhilipp Reisner * -2 We do not have a network config... 878b411b363SPhilipp Reisner */ 87981fa2e67SPhilipp Reisner static int conn_connect(struct drbd_tconn *tconn) 880b411b363SPhilipp Reisner { 8817da35862SPhilipp Reisner struct drbd_socket sock, msock; 882c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 88344ed167dSPhilipp Reisner struct net_conf *nc; 88492f14951SPhilipp Reisner int vnr, timeout, h, ok; 88508b165baSPhilipp Reisner bool discard_my_data; 886a1096a6eSPhilipp Reisner enum drbd_state_rv rv; 8877a426fd8SPhilipp Reisner struct accept_wait_data ad = { 8887a426fd8SPhilipp Reisner .tconn = tconn, 8897a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 8907a426fd8SPhilipp Reisner }; 891b411b363SPhilipp Reisner 892bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 893b411b363SPhilipp Reisner return -2; 894b411b363SPhilipp Reisner 8957da35862SPhilipp Reisner mutex_init(&sock.mutex); 8967da35862SPhilipp Reisner sock.sbuf = tconn->data.sbuf; 8977da35862SPhilipp Reisner sock.rbuf = tconn->data.rbuf; 8987da35862SPhilipp Reisner sock.socket = NULL; 8997da35862SPhilipp Reisner mutex_init(&msock.mutex); 9007da35862SPhilipp Reisner msock.sbuf = tconn->meta.sbuf; 9017da35862SPhilipp Reisner msock.rbuf = tconn->meta.rbuf; 9027da35862SPhilipp Reisner msock.socket = NULL; 9037da35862SPhilipp Reisner 904907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 9050916e0e3SAndreas Gruenbacher 9060916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 9070916e0e3SAndreas Gruenbacher tconn->agreed_pro_version = 80; 908b411b363SPhilipp Reisner 9097a426fd8SPhilipp Reisner if (prepare_listen_socket(tconn, &ad)) 9107a426fd8SPhilipp Reisner return 0; 9117a426fd8SPhilipp Reisner 912b411b363SPhilipp Reisner do { 9132bf89621SAndreas Gruenbacher struct socket *s; 9142bf89621SAndreas Gruenbacher 915907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 916b411b363SPhilipp Reisner if (s) { 9177da35862SPhilipp Reisner if (!sock.socket) { 9187da35862SPhilipp Reisner sock.socket = s; 9197da35862SPhilipp Reisner send_first_packet(tconn, &sock, P_INITIAL_DATA); 9207da35862SPhilipp Reisner } else if (!msock.socket) { 9217da35862SPhilipp Reisner msock.socket = s; 9227da35862SPhilipp Reisner send_first_packet(tconn, &msock, P_INITIAL_META); 923b411b363SPhilipp Reisner } else { 92481fa2e67SPhilipp Reisner conn_err(tconn, "Logic error in conn_connect()\n"); 925b411b363SPhilipp Reisner goto out_release_sockets; 926b411b363SPhilipp Reisner } 927b411b363SPhilipp Reisner } 928b411b363SPhilipp Reisner 9297da35862SPhilipp Reisner if (sock.socket && msock.socket) { 9307da35862SPhilipp Reisner rcu_read_lock(); 9317da35862SPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 9327da35862SPhilipp Reisner timeout = nc->ping_timeo * HZ / 10; 9337da35862SPhilipp Reisner rcu_read_unlock(); 9347da35862SPhilipp Reisner schedule_timeout_interruptible(timeout); 9357da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9367da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 937b411b363SPhilipp Reisner if (ok) 938b411b363SPhilipp Reisner break; 939b411b363SPhilipp Reisner } 940b411b363SPhilipp Reisner 941b411b363SPhilipp Reisner retry: 9427a426fd8SPhilipp Reisner s = drbd_wait_for_connect(tconn, &ad); 943b411b363SPhilipp Reisner if (s) { 94492f14951SPhilipp Reisner int fp = receive_first_packet(tconn, s); 9457da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9467da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 94792f14951SPhilipp Reisner switch (fp) { 948e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9497da35862SPhilipp Reisner if (sock.socket) { 950907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 9517da35862SPhilipp Reisner sock_release(sock.socket); 95280c6eed4SPhilipp Reisner sock.socket = s; 95380c6eed4SPhilipp Reisner goto randomize; 954b411b363SPhilipp Reisner } 9557da35862SPhilipp Reisner sock.socket = s; 956b411b363SPhilipp Reisner break; 957e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 95880c6eed4SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 9597da35862SPhilipp Reisner if (msock.socket) { 960907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 9617da35862SPhilipp Reisner sock_release(msock.socket); 96280c6eed4SPhilipp Reisner msock.socket = s; 96380c6eed4SPhilipp Reisner goto randomize; 964b411b363SPhilipp Reisner } 9657da35862SPhilipp Reisner msock.socket = s; 966b411b363SPhilipp Reisner break; 967b411b363SPhilipp Reisner default: 968907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 969b411b363SPhilipp Reisner sock_release(s); 97080c6eed4SPhilipp Reisner randomize: 971b411b363SPhilipp Reisner if (random32() & 1) 972b411b363SPhilipp Reisner goto retry; 973b411b363SPhilipp Reisner } 974b411b363SPhilipp Reisner } 975b411b363SPhilipp Reisner 976bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 977b411b363SPhilipp Reisner goto out_release_sockets; 978b411b363SPhilipp Reisner if (signal_pending(current)) { 979b411b363SPhilipp Reisner flush_signals(current); 980b411b363SPhilipp Reisner smp_rmb(); 981907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 982b411b363SPhilipp Reisner goto out_release_sockets; 983b411b363SPhilipp Reisner } 984b411b363SPhilipp Reisner 9857da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9867da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 987b666dbf8SPhilipp Reisner } while (!ok); 988b411b363SPhilipp Reisner 9897a426fd8SPhilipp Reisner if (ad.s_listen) 9907a426fd8SPhilipp Reisner sock_release(ad.s_listen); 9917a426fd8SPhilipp Reisner 9927da35862SPhilipp Reisner sock.socket->sk->sk_reuse = 1; /* SO_REUSEADDR */ 9937da35862SPhilipp Reisner msock.socket->sk->sk_reuse = 1; /* SO_REUSEADDR */ 9942bf89621SAndreas Gruenbacher 9957da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 9967da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 997b411b363SPhilipp Reisner 9987da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 9997da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 1000b411b363SPhilipp Reisner 1001b411b363SPhilipp Reisner /* NOT YET ... 10027da35862SPhilipp Reisner * sock.socket->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 10037da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 10046038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 1005b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 100644ed167dSPhilipp Reisner rcu_read_lock(); 100744ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 1008b411b363SPhilipp Reisner 10097da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 10107da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 101144ed167dSPhilipp Reisner 10127da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 101344ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 101408b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 101544ed167dSPhilipp Reisner rcu_read_unlock(); 101644ed167dSPhilipp Reisner 10177da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 1018b411b363SPhilipp Reisner 1019b411b363SPhilipp Reisner /* we don't want delays. 102025985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10217da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10227da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1023b411b363SPhilipp Reisner 10247da35862SPhilipp Reisner tconn->data.socket = sock.socket; 10257da35862SPhilipp Reisner tconn->meta.socket = msock.socket; 1026907599e0SPhilipp Reisner tconn->last_received = jiffies; 1027b411b363SPhilipp Reisner 10286038178eSAndreas Gruenbacher h = drbd_do_features(tconn); 1029b411b363SPhilipp Reisner if (h <= 0) 1030b411b363SPhilipp Reisner return h; 1031b411b363SPhilipp Reisner 1032907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 1033b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 1034907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 1035b10d96cbSJohannes Thoma case -1: 1036907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 1037b411b363SPhilipp Reisner return -1; 1038b10d96cbSJohannes Thoma case 0: 1039907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 1040b10d96cbSJohannes Thoma return 0; 1041b411b363SPhilipp Reisner } 1042b411b363SPhilipp Reisner } 1043b411b363SPhilipp Reisner 10447da35862SPhilipp Reisner tconn->data.socket->sk->sk_sndtimeo = timeout; 10457da35862SPhilipp Reisner tconn->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1046b411b363SPhilipp Reisner 1047387eb308SAndreas Gruenbacher if (drbd_send_protocol(tconn) == -EOPNOTSUPP) 10487e2455c1SPhilipp Reisner return -1; 1049b411b363SPhilipp Reisner 1050a1096a6eSPhilipp Reisner set_bit(STATE_SENT, &tconn->flags); 1051a1096a6eSPhilipp Reisner 1052c141ebdaSPhilipp Reisner rcu_read_lock(); 1053c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 1054c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 1055c141ebdaSPhilipp Reisner rcu_read_unlock(); 105608b165baSPhilipp Reisner 105708b165baSPhilipp Reisner if (discard_my_data) 105808b165baSPhilipp Reisner set_bit(DISCARD_MY_DATA, &mdev->flags); 105908b165baSPhilipp Reisner else 106008b165baSPhilipp Reisner clear_bit(DISCARD_MY_DATA, &mdev->flags); 106108b165baSPhilipp Reisner 1062c141ebdaSPhilipp Reisner drbd_connected(mdev); 1063c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 1064c141ebdaSPhilipp Reisner rcu_read_lock(); 1065c141ebdaSPhilipp Reisner } 1066c141ebdaSPhilipp Reisner rcu_read_unlock(); 1067c141ebdaSPhilipp Reisner 1068a1096a6eSPhilipp Reisner rv = conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1069a1096a6eSPhilipp Reisner if (rv < SS_SUCCESS) { 1070a1096a6eSPhilipp Reisner clear_bit(STATE_SENT, &tconn->flags); 1071823bd832SPhilipp Reisner return 0; 1072a1096a6eSPhilipp Reisner } 1073823bd832SPhilipp Reisner 1074823bd832SPhilipp Reisner drbd_thread_start(&tconn->asender); 1075823bd832SPhilipp Reisner 107608b165baSPhilipp Reisner mutex_lock(&tconn->conf_update); 107708b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 107808b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 107908b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 108008b165baSPhilipp Reisner * just to clear a single value. */ 108108b165baSPhilipp Reisner tconn->net_conf->discard_my_data = 0; 108208b165baSPhilipp Reisner mutex_unlock(&tconn->conf_update); 108308b165baSPhilipp Reisner 1084d3fcb490SPhilipp Reisner return h; 1085b411b363SPhilipp Reisner 1086b411b363SPhilipp Reisner out_release_sockets: 10877a426fd8SPhilipp Reisner if (ad.s_listen) 10887a426fd8SPhilipp Reisner sock_release(ad.s_listen); 10897da35862SPhilipp Reisner if (sock.socket) 10907da35862SPhilipp Reisner sock_release(sock.socket); 10917da35862SPhilipp Reisner if (msock.socket) 10927da35862SPhilipp Reisner sock_release(msock.socket); 1093b411b363SPhilipp Reisner return -1; 1094b411b363SPhilipp Reisner } 1095b411b363SPhilipp Reisner 1096e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *tconn, void *header, struct packet_info *pi) 1097b411b363SPhilipp Reisner { 1098e658983aSAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 1099e658983aSAndreas Gruenbacher 11000c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 11010c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 11020c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 11030c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 11040c8e36d9SAndreas Gruenbacher conn_err(tconn, "Header padding is not zero\n"); 11050c8e36d9SAndreas Gruenbacher return -EINVAL; 11060c8e36d9SAndreas Gruenbacher } 11070c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11080c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11090c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11100c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1111e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1112e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1113e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1114b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1115eefc2f7dSPhilipp Reisner pi->vnr = 0; 1116e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1117e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1118e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1119e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1120e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 112177351055SPhilipp Reisner pi->vnr = 0; 112202918be2SPhilipp Reisner } else { 1123e658983aSAndreas Gruenbacher conn_err(tconn, "Wrong magic value 0x%08x in protocol version %d\n", 1124e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1125e658983aSAndreas Gruenbacher tconn->agreed_pro_version); 11268172f3e9SAndreas Gruenbacher return -EINVAL; 1127b411b363SPhilipp Reisner } 1128e658983aSAndreas Gruenbacher pi->data = header + header_size; 11298172f3e9SAndreas Gruenbacher return 0; 1130257d0af6SPhilipp Reisner } 1131257d0af6SPhilipp Reisner 11329ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 1133257d0af6SPhilipp Reisner { 1134e658983aSAndreas Gruenbacher void *buffer = tconn->data.rbuf; 113569bc7bc3SAndreas Gruenbacher int err; 1136257d0af6SPhilipp Reisner 1137e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, buffer, drbd_header_size(tconn)); 1138a5c31904SAndreas Gruenbacher if (err) 113969bc7bc3SAndreas Gruenbacher return err; 1140257d0af6SPhilipp Reisner 1141e658983aSAndreas Gruenbacher err = decode_header(tconn, buffer, pi); 11429ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 1143b411b363SPhilipp Reisner 114469bc7bc3SAndreas Gruenbacher return err; 1145b411b363SPhilipp Reisner } 1146b411b363SPhilipp Reisner 11474b0007c0SPhilipp Reisner static void drbd_flush(struct drbd_tconn *tconn) 1148b411b363SPhilipp Reisner { 1149b411b363SPhilipp Reisner int rv; 11504b0007c0SPhilipp Reisner struct drbd_conf *mdev; 11514b0007c0SPhilipp Reisner int vnr; 1152b411b363SPhilipp Reisner 11534b0007c0SPhilipp Reisner if (tconn->write_ordering >= WO_bdev_flush) { 1154615e087fSLars Ellenberg rcu_read_lock(); 11554b0007c0SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 1156615e087fSLars Ellenberg if (!get_ldev(mdev)) 1157615e087fSLars Ellenberg continue; 1158615e087fSLars Ellenberg kref_get(&mdev->kref); 1159615e087fSLars Ellenberg rcu_read_unlock(); 11604b0007c0SPhilipp Reisner 1161615e087fSLars Ellenberg rv = blkdev_issue_flush(mdev->ldev->backing_bdev, 1162615e087fSLars Ellenberg GFP_NOIO, NULL); 1163b411b363SPhilipp Reisner if (rv) { 1164a67b813cSPhilipp Reisner dev_info(DEV, "local disk flush failed with status %d\n", rv); 1165b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1166b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1167b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 11684b0007c0SPhilipp Reisner drbd_bump_write_ordering(tconn, WO_drain_io); 1169615e087fSLars Ellenberg } 1170615e087fSLars Ellenberg put_ldev(mdev); 1171615e087fSLars Ellenberg kref_put(&mdev->kref, &drbd_minor_destroy); 1172615e087fSLars Ellenberg 1173615e087fSLars Ellenberg rcu_read_lock(); 1174615e087fSLars Ellenberg if (rv) 11754b0007c0SPhilipp Reisner break; 1176b411b363SPhilipp Reisner } 1177615e087fSLars Ellenberg rcu_read_unlock(); 1178b411b363SPhilipp Reisner } 1179b411b363SPhilipp Reisner } 1180b411b363SPhilipp Reisner 1181b411b363SPhilipp Reisner /** 1182b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1183b411b363SPhilipp Reisner * @mdev: DRBD device. 1184b411b363SPhilipp Reisner * @epoch: Epoch object. 1185b411b363SPhilipp Reisner * @ev: Epoch event. 1186b411b363SPhilipp Reisner */ 11871e9dd291SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_tconn *tconn, 1188b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1189b411b363SPhilipp Reisner enum epoch_event ev) 1190b411b363SPhilipp Reisner { 11912451fc3bSPhilipp Reisner int epoch_size; 1192b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1193b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1194b411b363SPhilipp Reisner 119512038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 1196b411b363SPhilipp Reisner do { 1197b411b363SPhilipp Reisner next_epoch = NULL; 1198b411b363SPhilipp Reisner 1199b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1200b411b363SPhilipp Reisner 1201b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1202b411b363SPhilipp Reisner case EV_PUT: 1203b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1204b411b363SPhilipp Reisner break; 1205b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1206b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1207b411b363SPhilipp Reisner break; 1208b411b363SPhilipp Reisner case EV_BECAME_LAST: 1209b411b363SPhilipp Reisner /* nothing to do*/ 1210b411b363SPhilipp Reisner break; 1211b411b363SPhilipp Reisner } 1212b411b363SPhilipp Reisner 1213b411b363SPhilipp Reisner if (epoch_size != 0 && 1214b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 121585d73513SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1216b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 121712038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 12189ed57dcbSLars Ellenberg drbd_send_b_ack(epoch->tconn, epoch->barrier_nr, epoch_size); 121912038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 1220b411b363SPhilipp Reisner } 12219ed57dcbSLars Ellenberg #if 0 12229ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 12239ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 122485d73513SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 12259ed57dcbSLars Ellenberg dec_unacked(epoch->tconn); 12269ed57dcbSLars Ellenberg #endif 1227b411b363SPhilipp Reisner 122812038a3aSPhilipp Reisner if (tconn->current_epoch != epoch) { 1229b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1230b411b363SPhilipp Reisner list_del(&epoch->list); 1231b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 123212038a3aSPhilipp Reisner tconn->epochs--; 1233b411b363SPhilipp Reisner kfree(epoch); 1234b411b363SPhilipp Reisner 1235b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1236b411b363SPhilipp Reisner rv = FE_DESTROYED; 1237b411b363SPhilipp Reisner } else { 1238b411b363SPhilipp Reisner epoch->flags = 0; 1239b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1240698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1241b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1242b411b363SPhilipp Reisner rv = FE_RECYCLED; 1243b411b363SPhilipp Reisner } 1244b411b363SPhilipp Reisner } 1245b411b363SPhilipp Reisner 1246b411b363SPhilipp Reisner if (!next_epoch) 1247b411b363SPhilipp Reisner break; 1248b411b363SPhilipp Reisner 1249b411b363SPhilipp Reisner epoch = next_epoch; 1250b411b363SPhilipp Reisner } while (1); 1251b411b363SPhilipp Reisner 125212038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 1253b411b363SPhilipp Reisner 1254b411b363SPhilipp Reisner return rv; 1255b411b363SPhilipp Reisner } 1256b411b363SPhilipp Reisner 1257b411b363SPhilipp Reisner /** 1258b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 12594b0007c0SPhilipp Reisner * @tconn: DRBD connection. 1260b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1261b411b363SPhilipp Reisner */ 12624b0007c0SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_tconn *tconn, enum write_ordering_e wo) 1263b411b363SPhilipp Reisner { 1264daeda1ccSPhilipp Reisner struct disk_conf *dc; 12654b0007c0SPhilipp Reisner struct drbd_conf *mdev; 1266b411b363SPhilipp Reisner enum write_ordering_e pwo; 12674b0007c0SPhilipp Reisner int vnr; 1268b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1269b411b363SPhilipp Reisner [WO_none] = "none", 1270b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1271b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1272b411b363SPhilipp Reisner }; 1273b411b363SPhilipp Reisner 12744b0007c0SPhilipp Reisner pwo = tconn->write_ordering; 1275b411b363SPhilipp Reisner wo = min(pwo, wo); 1276daeda1ccSPhilipp Reisner rcu_read_lock(); 12774b0007c0SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 127827eb13e9SPhilipp Reisner if (!get_ldev_if_state(mdev, D_ATTACHING)) 12794b0007c0SPhilipp Reisner continue; 1280daeda1ccSPhilipp Reisner dc = rcu_dereference(mdev->ldev->disk_conf); 1281daeda1ccSPhilipp Reisner 128266b2f6b9SAndreas Gruenbacher if (wo == WO_bdev_flush && !dc->disk_flushes) 1283b411b363SPhilipp Reisner wo = WO_drain_io; 1284d0c980e2SAndreas Gruenbacher if (wo == WO_drain_io && !dc->disk_drain) 1285b411b363SPhilipp Reisner wo = WO_none; 12864b0007c0SPhilipp Reisner put_ldev(mdev); 12874b0007c0SPhilipp Reisner } 1288daeda1ccSPhilipp Reisner rcu_read_unlock(); 12894b0007c0SPhilipp Reisner tconn->write_ordering = wo; 12904b0007c0SPhilipp Reisner if (pwo != tconn->write_ordering || wo == WO_bdev_flush) 12914b0007c0SPhilipp Reisner conn_info(tconn, "Method to ensure write ordering: %s\n", write_ordering_str[tconn->write_ordering]); 1292b411b363SPhilipp Reisner } 1293b411b363SPhilipp Reisner 1294b411b363SPhilipp Reisner /** 1295fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 129645bb912bSLars Ellenberg * @mdev: DRBD device. 1297db830c46SAndreas Gruenbacher * @peer_req: peer request 129845bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 129910f6d992SLars Ellenberg * 130010f6d992SLars Ellenberg * May spread the pages to multiple bios, 130110f6d992SLars Ellenberg * depending on bio_add_page restrictions. 130210f6d992SLars Ellenberg * 130310f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 130410f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 130510f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 130610f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 130710f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 130810f6d992SLars Ellenberg * on certain Xen deployments. 130945bb912bSLars Ellenberg */ 131045bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1311fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1312fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 131345bb912bSLars Ellenberg const unsigned rw, const int fault_type) 131445bb912bSLars Ellenberg { 131545bb912bSLars Ellenberg struct bio *bios = NULL; 131645bb912bSLars Ellenberg struct bio *bio; 1317db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1318db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1319db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 132045bb912bSLars Ellenberg unsigned n_bios = 0; 132145bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 132210f6d992SLars Ellenberg int err = -ENOMEM; 132345bb912bSLars Ellenberg 132445bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 132545bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 132645bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 1327da4a75d2SLars Ellenberg * request in more than one bio. 1328da4a75d2SLars Ellenberg * 1329da4a75d2SLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 1330da4a75d2SLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 1331da4a75d2SLars Ellenberg */ 133245bb912bSLars Ellenberg next_bio: 133345bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 133445bb912bSLars Ellenberg if (!bio) { 133545bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 133645bb912bSLars Ellenberg goto fail; 133745bb912bSLars Ellenberg } 1338db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 133945bb912bSLars Ellenberg bio->bi_sector = sector; 134045bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 134145bb912bSLars Ellenberg bio->bi_rw = rw; 1342db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1343fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 134445bb912bSLars Ellenberg 134545bb912bSLars Ellenberg bio->bi_next = bios; 134645bb912bSLars Ellenberg bios = bio; 134745bb912bSLars Ellenberg ++n_bios; 134845bb912bSLars Ellenberg 134945bb912bSLars Ellenberg page_chain_for_each(page) { 135045bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 135145bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 135210f6d992SLars Ellenberg /* A single page must always be possible! 135310f6d992SLars Ellenberg * But in case it fails anyways, 135410f6d992SLars Ellenberg * we deal with it, and complain (below). */ 135510f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 135610f6d992SLars Ellenberg dev_err(DEV, 135710f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 135810f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 135910f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 136010f6d992SLars Ellenberg err = -ENOSPC; 136110f6d992SLars Ellenberg goto fail; 136210f6d992SLars Ellenberg } 136345bb912bSLars Ellenberg goto next_bio; 136445bb912bSLars Ellenberg } 136545bb912bSLars Ellenberg ds -= len; 136645bb912bSLars Ellenberg sector += len >> 9; 136745bb912bSLars Ellenberg --nr_pages; 136845bb912bSLars Ellenberg } 136945bb912bSLars Ellenberg D_ASSERT(page == NULL); 137045bb912bSLars Ellenberg D_ASSERT(ds == 0); 137145bb912bSLars Ellenberg 1372db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 137345bb912bSLars Ellenberg do { 137445bb912bSLars Ellenberg bio = bios; 137545bb912bSLars Ellenberg bios = bios->bi_next; 137645bb912bSLars Ellenberg bio->bi_next = NULL; 137745bb912bSLars Ellenberg 137845bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 137945bb912bSLars Ellenberg } while (bios); 138045bb912bSLars Ellenberg return 0; 138145bb912bSLars Ellenberg 138245bb912bSLars Ellenberg fail: 138345bb912bSLars Ellenberg while (bios) { 138445bb912bSLars Ellenberg bio = bios; 138545bb912bSLars Ellenberg bios = bios->bi_next; 138645bb912bSLars Ellenberg bio_put(bio); 138745bb912bSLars Ellenberg } 138810f6d992SLars Ellenberg return err; 138945bb912bSLars Ellenberg } 139045bb912bSLars Ellenberg 139153840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1392db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 139353840641SAndreas Gruenbacher { 1394db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 139553840641SAndreas Gruenbacher 139653840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 139753840641SAndreas Gruenbacher drbd_clear_interval(i); 139853840641SAndreas Gruenbacher 13996c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 140053840641SAndreas Gruenbacher if (i->waiting) 140153840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 140253840641SAndreas Gruenbacher } 140353840641SAndreas Gruenbacher 140477fede51SPhilipp Reisner void conn_wait_active_ee_empty(struct drbd_tconn *tconn) 140577fede51SPhilipp Reisner { 140677fede51SPhilipp Reisner struct drbd_conf *mdev; 140777fede51SPhilipp Reisner int vnr; 140877fede51SPhilipp Reisner 140977fede51SPhilipp Reisner rcu_read_lock(); 141077fede51SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 141177fede51SPhilipp Reisner kref_get(&mdev->kref); 141277fede51SPhilipp Reisner rcu_read_unlock(); 141377fede51SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 141477fede51SPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 141577fede51SPhilipp Reisner rcu_read_lock(); 141677fede51SPhilipp Reisner } 141777fede51SPhilipp Reisner rcu_read_unlock(); 141877fede51SPhilipp Reisner } 141977fede51SPhilipp Reisner 14204a76b161SAndreas Gruenbacher static int receive_Barrier(struct drbd_tconn *tconn, struct packet_info *pi) 1421b411b363SPhilipp Reisner { 14222451fc3bSPhilipp Reisner int rv; 1423e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1424b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1425b411b363SPhilipp Reisner 14269ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 14279ed57dcbSLars Ellenberg * not a specific (peer)device. 14289ed57dcbSLars Ellenberg */ 142912038a3aSPhilipp Reisner tconn->current_epoch->barrier_nr = p->barrier; 14309ed57dcbSLars Ellenberg tconn->current_epoch->tconn = tconn; 14311e9dd291SPhilipp Reisner rv = drbd_may_finish_epoch(tconn, tconn->current_epoch, EV_GOT_BARRIER_NR); 1432b411b363SPhilipp Reisner 1433b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1434b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1435b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1436b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1437b411b363SPhilipp Reisner * completed. */ 14384b0007c0SPhilipp Reisner switch (tconn->write_ordering) { 1439b411b363SPhilipp Reisner case WO_none: 1440b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 144182bc0194SAndreas Gruenbacher return 0; 1442b411b363SPhilipp Reisner 1443b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1444b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1445b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14462451fc3bSPhilipp Reisner if (epoch) 14472451fc3bSPhilipp Reisner break; 14482451fc3bSPhilipp Reisner else 14499ed57dcbSLars Ellenberg conn_warn(tconn, "Allocation of an epoch failed, slowing down\n"); 14502451fc3bSPhilipp Reisner /* Fall through */ 14512451fc3bSPhilipp Reisner 14522451fc3bSPhilipp Reisner case WO_bdev_flush: 14532451fc3bSPhilipp Reisner case WO_drain_io: 145477fede51SPhilipp Reisner conn_wait_active_ee_empty(tconn); 14554b0007c0SPhilipp Reisner drbd_flush(tconn); 14562451fc3bSPhilipp Reisner 145712038a3aSPhilipp Reisner if (atomic_read(&tconn->current_epoch->epoch_size)) { 14582451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14592451fc3bSPhilipp Reisner if (epoch) 14602451fc3bSPhilipp Reisner break; 1461b411b363SPhilipp Reisner } 1462b411b363SPhilipp Reisner 146382bc0194SAndreas Gruenbacher return 0; 14642451fc3bSPhilipp Reisner default: 14659ed57dcbSLars Ellenberg conn_err(tconn, "Strangeness in tconn->write_ordering %d\n", tconn->write_ordering); 146682bc0194SAndreas Gruenbacher return -EIO; 1467b411b363SPhilipp Reisner } 1468b411b363SPhilipp Reisner 1469b411b363SPhilipp Reisner epoch->flags = 0; 1470b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1471b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1472b411b363SPhilipp Reisner 147312038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 147412038a3aSPhilipp Reisner if (atomic_read(&tconn->current_epoch->epoch_size)) { 147512038a3aSPhilipp Reisner list_add(&epoch->list, &tconn->current_epoch->list); 147612038a3aSPhilipp Reisner tconn->current_epoch = epoch; 147712038a3aSPhilipp Reisner tconn->epochs++; 1478b411b363SPhilipp Reisner } else { 1479b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1480b411b363SPhilipp Reisner kfree(epoch); 1481b411b363SPhilipp Reisner } 148212038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 1483b411b363SPhilipp Reisner 148482bc0194SAndreas Gruenbacher return 0; 1485b411b363SPhilipp Reisner } 1486b411b363SPhilipp Reisner 1487b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1488b411b363SPhilipp Reisner * and from receive_Data */ 1489f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1490f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1491f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1492b411b363SPhilipp Reisner { 14936666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1494db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1495b411b363SPhilipp Reisner struct page *page; 1496a5c31904SAndreas Gruenbacher int dgs, ds, err; 1497a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1498a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 14996b4388acSPhilipp Reisner unsigned long *data; 1500b411b363SPhilipp Reisner 150188104ca4SAndreas Gruenbacher dgs = 0; 150288104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 150388104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 15049f5bdc33SAndreas Gruenbacher /* 15059f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 15069f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 15079f5bdc33SAndreas Gruenbacher */ 1508a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1509a5c31904SAndreas Gruenbacher if (err) 1510b411b363SPhilipp Reisner return NULL; 1511b411b363SPhilipp Reisner data_size -= dgs; 151288104ca4SAndreas Gruenbacher } 1513b411b363SPhilipp Reisner 1514841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1515841ce241SAndreas Gruenbacher return NULL; 1516841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1517841ce241SAndreas Gruenbacher return NULL; 1518b411b363SPhilipp Reisner 15196666032aSLars Ellenberg /* even though we trust out peer, 15206666032aSLars Ellenberg * we sometimes have to double check. */ 15216666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1522fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1523fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 15246666032aSLars Ellenberg (unsigned long long)capacity, 15256666032aSLars Ellenberg (unsigned long long)sector, data_size); 15266666032aSLars Ellenberg return NULL; 15276666032aSLars Ellenberg } 15286666032aSLars Ellenberg 1529b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1530b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1531b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 15320db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, id, sector, data_size, GFP_NOIO); 1533db830c46SAndreas Gruenbacher if (!peer_req) 1534b411b363SPhilipp Reisner return NULL; 153545bb912bSLars Ellenberg 153681a3537aSLars Ellenberg if (!data_size) 153781a3537aSLars Ellenberg return peer_req; 153881a3537aSLars Ellenberg 1539b411b363SPhilipp Reisner ds = data_size; 1540db830c46SAndreas Gruenbacher page = peer_req->pages; 154145bb912bSLars Ellenberg page_chain_for_each(page) { 154245bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 15436b4388acSPhilipp Reisner data = kmap(page); 1544a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 15450cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 15466b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 15476b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 15486b4388acSPhilipp Reisner } 1549b411b363SPhilipp Reisner kunmap(page); 1550a5c31904SAndreas Gruenbacher if (err) { 15513967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1552b411b363SPhilipp Reisner return NULL; 1553b411b363SPhilipp Reisner } 1554a5c31904SAndreas Gruenbacher ds -= len; 1555b411b363SPhilipp Reisner } 1556b411b363SPhilipp Reisner 1557b411b363SPhilipp Reisner if (dgs) { 15585b614abeSAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->peer_integrity_tfm, peer_req, dig_vv); 1559b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1560470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1561470be44aSLars Ellenberg (unsigned long long)sector, data_size); 15623967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1563b411b363SPhilipp Reisner return NULL; 1564b411b363SPhilipp Reisner } 1565b411b363SPhilipp Reisner } 1566b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1567db830c46SAndreas Gruenbacher return peer_req; 1568b411b363SPhilipp Reisner } 1569b411b363SPhilipp Reisner 1570b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1571b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1572b411b363SPhilipp Reisner */ 1573b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1574b411b363SPhilipp Reisner { 1575b411b363SPhilipp Reisner struct page *page; 1576a5c31904SAndreas Gruenbacher int err = 0; 1577b411b363SPhilipp Reisner void *data; 1578b411b363SPhilipp Reisner 1579c3470cdeSLars Ellenberg if (!data_size) 1580fc5be839SAndreas Gruenbacher return 0; 1581c3470cdeSLars Ellenberg 1582c37c8ecfSAndreas Gruenbacher page = drbd_alloc_pages(mdev, 1, 1); 1583b411b363SPhilipp Reisner 1584b411b363SPhilipp Reisner data = kmap(page); 1585b411b363SPhilipp Reisner while (data_size) { 1586fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1587fc5be839SAndreas Gruenbacher 1588a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 1589a5c31904SAndreas Gruenbacher if (err) 1590b411b363SPhilipp Reisner break; 1591a5c31904SAndreas Gruenbacher data_size -= len; 1592b411b363SPhilipp Reisner } 1593b411b363SPhilipp Reisner kunmap(page); 15945cc287e0SAndreas Gruenbacher drbd_free_pages(mdev, page, 0); 1595fc5be839SAndreas Gruenbacher return err; 1596b411b363SPhilipp Reisner } 1597b411b363SPhilipp Reisner 1598b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1599b411b363SPhilipp Reisner sector_t sector, int data_size) 1600b411b363SPhilipp Reisner { 1601b411b363SPhilipp Reisner struct bio_vec *bvec; 1602b411b363SPhilipp Reisner struct bio *bio; 1603a5c31904SAndreas Gruenbacher int dgs, err, i, expect; 1604a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1605a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1606b411b363SPhilipp Reisner 160788104ca4SAndreas Gruenbacher dgs = 0; 160888104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 160988104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 1610a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1611a5c31904SAndreas Gruenbacher if (err) 1612a5c31904SAndreas Gruenbacher return err; 1613b411b363SPhilipp Reisner data_size -= dgs; 161488104ca4SAndreas Gruenbacher } 1615b411b363SPhilipp Reisner 1616b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1617b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1618b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1619b411b363SPhilipp Reisner 1620b411b363SPhilipp Reisner bio = req->master_bio; 1621b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1622b411b363SPhilipp Reisner 1623b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1624a5c31904SAndreas Gruenbacher void *mapped = kmap(bvec->bv_page) + bvec->bv_offset; 1625b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1626a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, mapped, expect); 1627b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1628a5c31904SAndreas Gruenbacher if (err) 1629a5c31904SAndreas Gruenbacher return err; 1630a5c31904SAndreas Gruenbacher data_size -= expect; 1631b411b363SPhilipp Reisner } 1632b411b363SPhilipp Reisner 1633b411b363SPhilipp Reisner if (dgs) { 16345b614abeSAndreas Gruenbacher drbd_csum_bio(mdev, mdev->tconn->peer_integrity_tfm, bio, dig_vv); 1635b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1636b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 163728284cefSAndreas Gruenbacher return -EINVAL; 1638b411b363SPhilipp Reisner } 1639b411b363SPhilipp Reisner } 1640b411b363SPhilipp Reisner 1641b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 164228284cefSAndreas Gruenbacher return 0; 1643b411b363SPhilipp Reisner } 1644b411b363SPhilipp Reisner 1645a990be46SAndreas Gruenbacher /* 1646a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1647a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1648a990be46SAndreas Gruenbacher */ 164999920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1650b411b363SPhilipp Reisner { 16518050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16528050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 165300d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1654db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 165599920dc5SAndreas Gruenbacher int err; 1656b411b363SPhilipp Reisner 1657db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1658b411b363SPhilipp Reisner 1659db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1660db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 166199920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1662b411b363SPhilipp Reisner } else { 1663b411b363SPhilipp Reisner /* Record failure to sync */ 1664db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1665b411b363SPhilipp Reisner 166699920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1667b411b363SPhilipp Reisner } 1668b411b363SPhilipp Reisner dec_unacked(mdev); 1669b411b363SPhilipp Reisner 167099920dc5SAndreas Gruenbacher return err; 1671b411b363SPhilipp Reisner } 1672b411b363SPhilipp Reisner 1673b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1674b411b363SPhilipp Reisner { 1675db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1676b411b363SPhilipp Reisner 1677db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1678db830c46SAndreas Gruenbacher if (!peer_req) 167945bb912bSLars Ellenberg goto fail; 1680b411b363SPhilipp Reisner 1681b411b363SPhilipp Reisner dec_rs_pending(mdev); 1682b411b363SPhilipp Reisner 1683b411b363SPhilipp Reisner inc_unacked(mdev); 1684b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1685b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1686b411b363SPhilipp Reisner 1687db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 168845bb912bSLars Ellenberg 168987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1690db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 169187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1692b411b363SPhilipp Reisner 16930f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1694fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1695e1c1b0fcSAndreas Gruenbacher return 0; 169645bb912bSLars Ellenberg 169710f6d992SLars Ellenberg /* don't care for the reason here */ 169810f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 169987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1700db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 170187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 170222cc37a9SLars Ellenberg 17033967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 170445bb912bSLars Ellenberg fail: 170545bb912bSLars Ellenberg put_ldev(mdev); 1706e1c1b0fcSAndreas Gruenbacher return -EIO; 1707b411b363SPhilipp Reisner } 1708b411b363SPhilipp Reisner 1709668eebc6SAndreas Gruenbacher static struct drbd_request * 1710bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1711bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1712668eebc6SAndreas Gruenbacher { 1713668eebc6SAndreas Gruenbacher struct drbd_request *req; 1714668eebc6SAndreas Gruenbacher 1715bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1716bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 17175e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1718668eebc6SAndreas Gruenbacher return req; 1719c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 17205af172edSAndreas Gruenbacher dev_err(DEV, "%s: failed to find request 0x%lx, sector %llus\n", func, 1721c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1722c3afd8f5SAndreas Gruenbacher } 1723668eebc6SAndreas Gruenbacher return NULL; 1724668eebc6SAndreas Gruenbacher } 1725668eebc6SAndreas Gruenbacher 17264a76b161SAndreas Gruenbacher static int receive_DataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1727b411b363SPhilipp Reisner { 17284a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1729b411b363SPhilipp Reisner struct drbd_request *req; 1730b411b363SPhilipp Reisner sector_t sector; 173182bc0194SAndreas Gruenbacher int err; 1732e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17334a76b161SAndreas Gruenbacher 17344a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 17354a76b161SAndreas Gruenbacher if (!mdev) 17364a76b161SAndreas Gruenbacher return -EIO; 1737b411b363SPhilipp Reisner 1738b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1739b411b363SPhilipp Reisner 174087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1741bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 174287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1743c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 174482bc0194SAndreas Gruenbacher return -EIO; 1745b411b363SPhilipp Reisner 174624c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1747b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1748b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1749e2857216SAndreas Gruenbacher err = recv_dless_read(mdev, req, sector, pi->size); 175082bc0194SAndreas Gruenbacher if (!err) 17518554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1752b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1753b411b363SPhilipp Reisner * I don't think we may complete this just yet 1754b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1755b411b363SPhilipp Reisner 175682bc0194SAndreas Gruenbacher return err; 1757b411b363SPhilipp Reisner } 1758b411b363SPhilipp Reisner 17594a76b161SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1760b411b363SPhilipp Reisner { 17614a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1762b411b363SPhilipp Reisner sector_t sector; 176382bc0194SAndreas Gruenbacher int err; 1764e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17654a76b161SAndreas Gruenbacher 17664a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 17674a76b161SAndreas Gruenbacher if (!mdev) 17684a76b161SAndreas Gruenbacher return -EIO; 1769b411b363SPhilipp Reisner 1770b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1771b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1772b411b363SPhilipp Reisner 1773b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1774b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1775b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1776fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1777e2857216SAndreas Gruenbacher err = recv_resync_read(mdev, sector, pi->size); 1778b411b363SPhilipp Reisner } else { 1779b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1780b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1781b411b363SPhilipp Reisner 1782e2857216SAndreas Gruenbacher err = drbd_drain_block(mdev, pi->size); 1783b411b363SPhilipp Reisner 1784e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 1785b411b363SPhilipp Reisner } 1786b411b363SPhilipp Reisner 1787e2857216SAndreas Gruenbacher atomic_add(pi->size >> 9, &mdev->rs_sect_in); 1788778f271dSPhilipp Reisner 178982bc0194SAndreas Gruenbacher return err; 1790b411b363SPhilipp Reisner } 1791b411b363SPhilipp Reisner 17927be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 17937be8da07SAndreas Gruenbacher sector_t sector, int size) 17947be8da07SAndreas Gruenbacher { 17957be8da07SAndreas Gruenbacher struct drbd_interval *i; 17967be8da07SAndreas Gruenbacher struct drbd_request *req; 17977be8da07SAndreas Gruenbacher 17987be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 17997be8da07SAndreas Gruenbacher if (!i->local) 18007be8da07SAndreas Gruenbacher continue; 18017be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18027be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 18037be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 18047be8da07SAndreas Gruenbacher continue; 18052312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 18062312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 18072312f0b3SLars Ellenberg __req_mod(req, DISCARD_WRITE, NULL); 18087be8da07SAndreas Gruenbacher } 18097be8da07SAndreas Gruenbacher } 18107be8da07SAndreas Gruenbacher 1811a990be46SAndreas Gruenbacher /* 1812a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1813b411b363SPhilipp Reisner */ 181499920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1815b411b363SPhilipp Reisner { 18168050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 18178050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 181800d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1819db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 182099920dc5SAndreas Gruenbacher int err = 0, pcmd; 1821b411b363SPhilipp Reisner 1822303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1823db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1824b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1825b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1826db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1827b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 182899920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, pcmd, peer_req); 1829b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1830db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1831b411b363SPhilipp Reisner } else { 183299920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1833b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1834b411b363SPhilipp Reisner * maybe assert this? */ 1835b411b363SPhilipp Reisner } 1836b411b363SPhilipp Reisner dec_unacked(mdev); 1837b411b363SPhilipp Reisner } 1838b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1839b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1840302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 184187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1842db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1843db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 18447be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 18457be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 184687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1847bb3bfe96SAndreas Gruenbacher } else 1848db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1849b411b363SPhilipp Reisner 18501e9dd291SPhilipp Reisner drbd_may_finish_epoch(mdev->tconn, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1851b411b363SPhilipp Reisner 185299920dc5SAndreas Gruenbacher return err; 1853b411b363SPhilipp Reisner } 1854b411b363SPhilipp Reisner 18557be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1856b411b363SPhilipp Reisner { 18577be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 18588050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 18598050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 186099920dc5SAndreas Gruenbacher int err; 1861b411b363SPhilipp Reisner 186299920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, ack, peer_req); 1863b411b363SPhilipp Reisner dec_unacked(mdev); 1864b411b363SPhilipp Reisner 186599920dc5SAndreas Gruenbacher return err; 1866b411b363SPhilipp Reisner } 1867b411b363SPhilipp Reisner 186899920dc5SAndreas Gruenbacher static int e_send_discard_write(struct drbd_work *w, int unused) 18697be8da07SAndreas Gruenbacher { 18707be8da07SAndreas Gruenbacher return e_send_ack(w, P_DISCARD_WRITE); 18717be8da07SAndreas Gruenbacher } 18727be8da07SAndreas Gruenbacher 187399920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 18747be8da07SAndreas Gruenbacher { 18757be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 18767be8da07SAndreas Gruenbacher 18777be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 18787be8da07SAndreas Gruenbacher P_RETRY_WRITE : P_DISCARD_WRITE); 18797be8da07SAndreas Gruenbacher } 18807be8da07SAndreas Gruenbacher 18813e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 18823e394da1SAndreas Gruenbacher { 18833e394da1SAndreas Gruenbacher /* 18843e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 18853e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 18863e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 18873e394da1SAndreas Gruenbacher */ 18883e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 18893e394da1SAndreas Gruenbacher } 18903e394da1SAndreas Gruenbacher 18913e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 18923e394da1SAndreas Gruenbacher { 18933e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 18943e394da1SAndreas Gruenbacher } 18953e394da1SAndreas Gruenbacher 18967be8da07SAndreas Gruenbacher static bool need_peer_seq(struct drbd_conf *mdev) 18977be8da07SAndreas Gruenbacher { 18987be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 1899302bdeaeSPhilipp Reisner int tp; 19007be8da07SAndreas Gruenbacher 19017be8da07SAndreas Gruenbacher /* 19027be8da07SAndreas Gruenbacher * We only need to keep track of the last packet_seq number of our peer 19037be8da07SAndreas Gruenbacher * if we are in dual-primary mode and we have the discard flag set; see 19047be8da07SAndreas Gruenbacher * handle_write_conflicts(). 19057be8da07SAndreas Gruenbacher */ 1906302bdeaeSPhilipp Reisner 1907302bdeaeSPhilipp Reisner rcu_read_lock(); 1908302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 1909302bdeaeSPhilipp Reisner rcu_read_unlock(); 1910302bdeaeSPhilipp Reisner 1911302bdeaeSPhilipp Reisner return tp && test_bit(DISCARD_CONCURRENT, &tconn->flags); 19127be8da07SAndreas Gruenbacher } 19137be8da07SAndreas Gruenbacher 191443ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 19153e394da1SAndreas Gruenbacher { 19163c13b680SLars Ellenberg unsigned int newest_peer_seq; 19173e394da1SAndreas Gruenbacher 19187be8da07SAndreas Gruenbacher if (need_peer_seq(mdev)) { 19193e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 19203c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 19213c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 19223e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 19233c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 19243c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 19253e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 19263e394da1SAndreas Gruenbacher } 19277be8da07SAndreas Gruenbacher } 19283e394da1SAndreas Gruenbacher 1929d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 1930d93f6302SLars Ellenberg { 1931d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 1932d93f6302SLars Ellenberg } 1933d93f6302SLars Ellenberg 1934d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 19353ea35df8SPhilipp Reisner static bool overlapping_resync_write(struct drbd_conf *mdev, struct drbd_peer_request *peer_req) 1936d93f6302SLars Ellenberg { 1937d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 1938d93f6302SLars Ellenberg bool rv = 0; 1939d93f6302SLars Ellenberg 1940d93f6302SLars Ellenberg spin_lock_irq(&mdev->tconn->req_lock); 1941d93f6302SLars Ellenberg list_for_each_entry(rs_req, &mdev->sync_ee, w.list) { 1942d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 1943d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 1944d93f6302SLars Ellenberg rv = 1; 1945d93f6302SLars Ellenberg break; 1946d93f6302SLars Ellenberg } 1947d93f6302SLars Ellenberg } 1948d93f6302SLars Ellenberg spin_unlock_irq(&mdev->tconn->req_lock); 1949d93f6302SLars Ellenberg 1950d93f6302SLars Ellenberg return rv; 1951d93f6302SLars Ellenberg } 1952d93f6302SLars Ellenberg 1953b411b363SPhilipp Reisner /* Called from receive_Data. 1954b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1955b411b363SPhilipp Reisner * 1956b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1957b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1958b411b363SPhilipp Reisner * been sent. 1959b411b363SPhilipp Reisner * 1960b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1961b411b363SPhilipp Reisner * 1962b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1963b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1964b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1965b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1966b411b363SPhilipp Reisner * 1967b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1968b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1969b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1970b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1971b411b363SPhilipp Reisner * 1972b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1973b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 19747be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1975b411b363SPhilipp Reisner { 1976b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1977b411b363SPhilipp Reisner long timeout; 19787be8da07SAndreas Gruenbacher int ret; 19797be8da07SAndreas Gruenbacher 19807be8da07SAndreas Gruenbacher if (!need_peer_seq(mdev)) 19817be8da07SAndreas Gruenbacher return 0; 19827be8da07SAndreas Gruenbacher 1983b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1984b411b363SPhilipp Reisner for (;;) { 19857be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 19867be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 19877be8da07SAndreas Gruenbacher ret = 0; 1988b411b363SPhilipp Reisner break; 19897be8da07SAndreas Gruenbacher } 1990b411b363SPhilipp Reisner if (signal_pending(current)) { 1991b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1992b411b363SPhilipp Reisner break; 1993b411b363SPhilipp Reisner } 19947be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1995b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 199644ed167dSPhilipp Reisner rcu_read_lock(); 199744ed167dSPhilipp Reisner timeout = rcu_dereference(mdev->tconn->net_conf)->ping_timeo*HZ/10; 199844ed167dSPhilipp Reisner rcu_read_unlock(); 199971b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 2000b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 20017be8da07SAndreas Gruenbacher if (!timeout) { 2002b411b363SPhilipp Reisner ret = -ETIMEDOUT; 200371b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 2004b411b363SPhilipp Reisner break; 2005b411b363SPhilipp Reisner } 2006b411b363SPhilipp Reisner } 2007b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 20087be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 2009b411b363SPhilipp Reisner return ret; 2010b411b363SPhilipp Reisner } 2011b411b363SPhilipp Reisner 2012688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2013688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2014688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 2015688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 201676d2e7ecSPhilipp Reisner { 201776d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 201876d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 2019688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 202076d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 202176d2e7ecSPhilipp Reisner } 202276d2e7ecSPhilipp Reisner 20237be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 20247be8da07SAndreas Gruenbacher unsigned int size) 20257be8da07SAndreas Gruenbacher { 20267be8da07SAndreas Gruenbacher struct drbd_interval *i; 20277be8da07SAndreas Gruenbacher 20287be8da07SAndreas Gruenbacher repeat: 20297be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 20307be8da07SAndreas Gruenbacher struct drbd_request *req; 20317be8da07SAndreas Gruenbacher struct bio_and_error m; 20327be8da07SAndreas Gruenbacher 20337be8da07SAndreas Gruenbacher if (!i->local) 20347be8da07SAndreas Gruenbacher continue; 20357be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 20367be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 20377be8da07SAndreas Gruenbacher continue; 20387be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 20397be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 20407be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 20417be8da07SAndreas Gruenbacher if (m.bio) 20427be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 20437be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 20447be8da07SAndreas Gruenbacher goto repeat; 20457be8da07SAndreas Gruenbacher } 20467be8da07SAndreas Gruenbacher } 20477be8da07SAndreas Gruenbacher 20487be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 20497be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 20507be8da07SAndreas Gruenbacher { 20517be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 20527be8da07SAndreas Gruenbacher bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags); 20537be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 20547be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 20557be8da07SAndreas Gruenbacher struct drbd_interval *i; 20567be8da07SAndreas Gruenbacher bool equal; 20577be8da07SAndreas Gruenbacher int err; 20587be8da07SAndreas Gruenbacher 20597be8da07SAndreas Gruenbacher /* 20607be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 20617be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 20627be8da07SAndreas Gruenbacher */ 20637be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 20647be8da07SAndreas Gruenbacher 20657be8da07SAndreas Gruenbacher repeat: 20667be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 20677be8da07SAndreas Gruenbacher if (i == &peer_req->i) 20687be8da07SAndreas Gruenbacher continue; 20697be8da07SAndreas Gruenbacher 20707be8da07SAndreas Gruenbacher if (!i->local) { 20717be8da07SAndreas Gruenbacher /* 20727be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 20737be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 20747be8da07SAndreas Gruenbacher * earlier peer request to complete. 20757be8da07SAndreas Gruenbacher */ 20767be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 20777be8da07SAndreas Gruenbacher if (err) 20787be8da07SAndreas Gruenbacher goto out; 20797be8da07SAndreas Gruenbacher goto repeat; 20807be8da07SAndreas Gruenbacher } 20817be8da07SAndreas Gruenbacher 20827be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 20837be8da07SAndreas Gruenbacher if (resolve_conflicts) { 20847be8da07SAndreas Gruenbacher /* 20857be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 20867be8da07SAndreas Gruenbacher * overlapping request, it can be discarded; otherwise, 20877be8da07SAndreas Gruenbacher * it will be retried once all overlapping requests 20887be8da07SAndreas Gruenbacher * have completed. 20897be8da07SAndreas Gruenbacher */ 20907be8da07SAndreas Gruenbacher bool discard = i->sector <= sector && i->sector + 20917be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 20927be8da07SAndreas Gruenbacher 20937be8da07SAndreas Gruenbacher if (!equal) 20947be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 20957be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 20967be8da07SAndreas Gruenbacher "assuming %s came first\n", 20977be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 20987be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 20997be8da07SAndreas Gruenbacher discard ? "local" : "remote"); 21007be8da07SAndreas Gruenbacher 21017be8da07SAndreas Gruenbacher inc_unacked(mdev); 21027be8da07SAndreas Gruenbacher peer_req->w.cb = discard ? e_send_discard_write : 21037be8da07SAndreas Gruenbacher e_send_retry_write; 21047be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 21057be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 21067be8da07SAndreas Gruenbacher 21077be8da07SAndreas Gruenbacher err = -ENOENT; 21087be8da07SAndreas Gruenbacher goto out; 21097be8da07SAndreas Gruenbacher } else { 21107be8da07SAndreas Gruenbacher struct drbd_request *req = 21117be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 21127be8da07SAndreas Gruenbacher 21137be8da07SAndreas Gruenbacher if (!equal) 21147be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 21157be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 21167be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 21177be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 21187be8da07SAndreas Gruenbacher 21197be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 21207be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 21217be8da07SAndreas Gruenbacher /* 21227be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 21237be8da07SAndreas Gruenbacher * decide if this request will be discarded or 21247be8da07SAndreas Gruenbacher * retried. Requests that are discarded will 21257be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 21267be8da07SAndreas Gruenbacher * 21277be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 21287be8da07SAndreas Gruenbacher * request to finish locally before submitting 21297be8da07SAndreas Gruenbacher * the conflicting peer request. 21307be8da07SAndreas Gruenbacher */ 21317be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 21327be8da07SAndreas Gruenbacher if (err) { 21337be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 21347be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 21357be8da07SAndreas Gruenbacher CS_HARD); 21367be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 21377be8da07SAndreas Gruenbacher goto out; 21387be8da07SAndreas Gruenbacher } 21397be8da07SAndreas Gruenbacher goto repeat; 21407be8da07SAndreas Gruenbacher } 21417be8da07SAndreas Gruenbacher /* 21427be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 21437be8da07SAndreas Gruenbacher * the new peer request has completed. 21447be8da07SAndreas Gruenbacher */ 21457be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 21467be8da07SAndreas Gruenbacher } 21477be8da07SAndreas Gruenbacher } 21487be8da07SAndreas Gruenbacher err = 0; 21497be8da07SAndreas Gruenbacher 21507be8da07SAndreas Gruenbacher out: 21517be8da07SAndreas Gruenbacher if (err) 21527be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 21537be8da07SAndreas Gruenbacher return err; 21547be8da07SAndreas Gruenbacher } 21557be8da07SAndreas Gruenbacher 2156b411b363SPhilipp Reisner /* mirrored write */ 21574a76b161SAndreas Gruenbacher static int receive_Data(struct drbd_tconn *tconn, struct packet_info *pi) 2158b411b363SPhilipp Reisner { 21594a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2160b411b363SPhilipp Reisner sector_t sector; 2161db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2162e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 21637be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2164b411b363SPhilipp Reisner int rw = WRITE; 2165b411b363SPhilipp Reisner u32 dp_flags; 2166302bdeaeSPhilipp Reisner int err, tp; 21677be8da07SAndreas Gruenbacher 21684a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 21694a76b161SAndreas Gruenbacher if (!mdev) 21704a76b161SAndreas Gruenbacher return -EIO; 21714a76b161SAndreas Gruenbacher 2172b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 217382bc0194SAndreas Gruenbacher int err2; 217482bc0194SAndreas Gruenbacher 21757be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 2176e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 217712038a3aSPhilipp Reisner atomic_inc(&tconn->current_epoch->epoch_size); 2178e2857216SAndreas Gruenbacher err2 = drbd_drain_block(mdev, pi->size); 217982bc0194SAndreas Gruenbacher if (!err) 218082bc0194SAndreas Gruenbacher err = err2; 218182bc0194SAndreas Gruenbacher return err; 2182b411b363SPhilipp Reisner } 2183b411b363SPhilipp Reisner 2184fcefa62eSAndreas Gruenbacher /* 2185fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2186fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2187fcefa62eSAndreas Gruenbacher * end of this function. 2188fcefa62eSAndreas Gruenbacher */ 2189b411b363SPhilipp Reisner 2190b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2191e2857216SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, pi->size); 2192db830c46SAndreas Gruenbacher if (!peer_req) { 2193b411b363SPhilipp Reisner put_ldev(mdev); 219482bc0194SAndreas Gruenbacher return -EIO; 2195b411b363SPhilipp Reisner } 2196b411b363SPhilipp Reisner 2197db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 2198b411b363SPhilipp Reisner 2199688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2200688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 220181a3537aSLars Ellenberg if (peer_req->pages == NULL) { 220281a3537aSLars Ellenberg D_ASSERT(peer_req->i.size == 0); 220381a3537aSLars Ellenberg D_ASSERT(dp_flags & DP_FLUSH); 220481a3537aSLars Ellenberg } 2205688593c5SLars Ellenberg 2206688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2207db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2208688593c5SLars Ellenberg 220912038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 221012038a3aSPhilipp Reisner peer_req->epoch = tconn->current_epoch; 2211db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2212db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 221312038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 2214b411b363SPhilipp Reisner 2215302bdeaeSPhilipp Reisner rcu_read_lock(); 2216302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 2217302bdeaeSPhilipp Reisner rcu_read_unlock(); 2218302bdeaeSPhilipp Reisner if (tp) { 2219302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 22207be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 22217be8da07SAndreas Gruenbacher if (err) 2222b411b363SPhilipp Reisner goto out_interrupted; 222387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 22247be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 22257be8da07SAndreas Gruenbacher if (err) { 222687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 22277be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2228b411b363SPhilipp Reisner put_ldev(mdev); 222982bc0194SAndreas Gruenbacher return 0; 2230b411b363SPhilipp Reisner } 2231b411b363SPhilipp Reisner goto out_interrupted; 2232b411b363SPhilipp Reisner } 22337be8da07SAndreas Gruenbacher } else 223487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2235db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 223687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2237b411b363SPhilipp Reisner 2238d93f6302SLars Ellenberg if (mdev->state.conn == C_SYNC_TARGET) 22393ea35df8SPhilipp Reisner wait_event(mdev->ee_wait, !overlapping_resync_write(mdev, peer_req)); 2240d93f6302SLars Ellenberg 2241303d1448SPhilipp Reisner if (mdev->tconn->agreed_pro_version < 100) { 224244ed167dSPhilipp Reisner rcu_read_lock(); 224344ed167dSPhilipp Reisner switch (rcu_dereference(mdev->tconn->net_conf)->wire_protocol) { 2244b411b363SPhilipp Reisner case DRBD_PROT_C: 2245303d1448SPhilipp Reisner dp_flags |= DP_SEND_WRITE_ACK; 2246303d1448SPhilipp Reisner break; 2247303d1448SPhilipp Reisner case DRBD_PROT_B: 2248303d1448SPhilipp Reisner dp_flags |= DP_SEND_RECEIVE_ACK; 2249303d1448SPhilipp Reisner break; 2250303d1448SPhilipp Reisner } 225144ed167dSPhilipp Reisner rcu_read_unlock(); 2252303d1448SPhilipp Reisner } 2253303d1448SPhilipp Reisner 2254303d1448SPhilipp Reisner if (dp_flags & DP_SEND_WRITE_ACK) { 2255303d1448SPhilipp Reisner peer_req->flags |= EE_SEND_WRITE_ACK; 2256b411b363SPhilipp Reisner inc_unacked(mdev); 2257b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2258b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2259303d1448SPhilipp Reisner } 2260303d1448SPhilipp Reisner 2261303d1448SPhilipp Reisner if (dp_flags & DP_SEND_RECEIVE_ACK) { 2262b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2263b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2264db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2265b411b363SPhilipp Reisner } 2266b411b363SPhilipp Reisner 22676719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2268b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2269db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2270db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2271db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2272181286adSLars Ellenberg drbd_al_begin_io(mdev, &peer_req->i); 2273b411b363SPhilipp Reisner } 2274b411b363SPhilipp Reisner 227582bc0194SAndreas Gruenbacher err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR); 227682bc0194SAndreas Gruenbacher if (!err) 227782bc0194SAndreas Gruenbacher return 0; 2278b411b363SPhilipp Reisner 227910f6d992SLars Ellenberg /* don't care for the reason here */ 228010f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 228187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2282db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2283db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 228487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2285db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2286181286adSLars Ellenberg drbd_al_complete_io(mdev, &peer_req->i); 228722cc37a9SLars Ellenberg 2288b411b363SPhilipp Reisner out_interrupted: 22891e9dd291SPhilipp Reisner drbd_may_finish_epoch(tconn, peer_req->epoch, EV_PUT + EV_CLEANUP); 2290b411b363SPhilipp Reisner put_ldev(mdev); 22913967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 229282bc0194SAndreas Gruenbacher return err; 2293b411b363SPhilipp Reisner } 2294b411b363SPhilipp Reisner 22950f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 22960f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 22970f0601f4SLars Ellenberg * 22980f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 22990f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 23000f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 23010f0601f4SLars Ellenberg * activity, it obviously is "busy". 23020f0601f4SLars Ellenberg * 23030f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 23040f0601f4SLars Ellenberg * to have a short time average so we can react faster. 23050f0601f4SLars Ellenberg */ 2306e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 23070f0601f4SLars Ellenberg { 23080f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 23090f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2310e3555d85SPhilipp Reisner struct lc_element *tmp; 23110f0601f4SLars Ellenberg int curr_events; 23120f0601f4SLars Ellenberg int throttle = 0; 2313daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2314daeda1ccSPhilipp Reisner 2315daeda1ccSPhilipp Reisner rcu_read_lock(); 2316daeda1ccSPhilipp Reisner c_min_rate = rcu_dereference(mdev->ldev->disk_conf)->c_min_rate; 2317daeda1ccSPhilipp Reisner rcu_read_unlock(); 23180f0601f4SLars Ellenberg 23190f0601f4SLars Ellenberg /* feature disabled? */ 2320daeda1ccSPhilipp Reisner if (c_min_rate == 0) 23210f0601f4SLars Ellenberg return 0; 23220f0601f4SLars Ellenberg 2323e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2324e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2325e3555d85SPhilipp Reisner if (tmp) { 2326e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2327e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2328e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2329e3555d85SPhilipp Reisner return 0; 2330e3555d85SPhilipp Reisner } 2331e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2332e3555d85SPhilipp Reisner } 2333e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2334e3555d85SPhilipp Reisner 23350f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 23360f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 23370f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2338e3555d85SPhilipp Reisner 23390f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 23400f0601f4SLars Ellenberg unsigned long rs_left; 23410f0601f4SLars Ellenberg int i; 23420f0601f4SLars Ellenberg 23430f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 23440f0601f4SLars Ellenberg 23450f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 23460f0601f4SLars Ellenberg * approx. */ 23472649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 23482649f080SLars Ellenberg 23492649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 23502649f080SLars Ellenberg rs_left = mdev->ov_left; 23512649f080SLars Ellenberg else 23520f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 23530f0601f4SLars Ellenberg 23540f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 23550f0601f4SLars Ellenberg if (!dt) 23560f0601f4SLars Ellenberg dt++; 23570f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 23580f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 23590f0601f4SLars Ellenberg 2360daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 23610f0601f4SLars Ellenberg throttle = 1; 23620f0601f4SLars Ellenberg } 23630f0601f4SLars Ellenberg return throttle; 23640f0601f4SLars Ellenberg } 23650f0601f4SLars Ellenberg 23660f0601f4SLars Ellenberg 23674a76b161SAndreas Gruenbacher static int receive_DataRequest(struct drbd_tconn *tconn, struct packet_info *pi) 2368b411b363SPhilipp Reisner { 23694a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2370b411b363SPhilipp Reisner sector_t sector; 23714a76b161SAndreas Gruenbacher sector_t capacity; 2372db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2373b411b363SPhilipp Reisner struct digest_info *di = NULL; 2374b18b37beSPhilipp Reisner int size, verb; 2375b411b363SPhilipp Reisner unsigned int fault_type; 2376e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 23774a76b161SAndreas Gruenbacher 23784a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 23794a76b161SAndreas Gruenbacher if (!mdev) 23804a76b161SAndreas Gruenbacher return -EIO; 23814a76b161SAndreas Gruenbacher capacity = drbd_get_capacity(mdev->this_bdev); 2382b411b363SPhilipp Reisner 2383b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2384b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2385b411b363SPhilipp Reisner 2386c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2387b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2388b411b363SPhilipp Reisner (unsigned long long)sector, size); 238982bc0194SAndreas Gruenbacher return -EINVAL; 2390b411b363SPhilipp Reisner } 2391b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2392b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2393b411b363SPhilipp Reisner (unsigned long long)sector, size); 239482bc0194SAndreas Gruenbacher return -EINVAL; 2395b411b363SPhilipp Reisner } 2396b411b363SPhilipp Reisner 2397b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2398b18b37beSPhilipp Reisner verb = 1; 2399e2857216SAndreas Gruenbacher switch (pi->cmd) { 2400b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2401b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2402b18b37beSPhilipp Reisner break; 2403b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2404b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2405b18b37beSPhilipp Reisner case P_OV_REQUEST: 2406b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2407b18b37beSPhilipp Reisner break; 2408b18b37beSPhilipp Reisner case P_OV_REPLY: 2409b18b37beSPhilipp Reisner verb = 0; 2410b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2411b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2412b18b37beSPhilipp Reisner break; 2413b18b37beSPhilipp Reisner default: 241449ba9b1bSAndreas Gruenbacher BUG(); 2415b18b37beSPhilipp Reisner } 2416b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2417b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2418b411b363SPhilipp Reisner "no local data.\n"); 2419b18b37beSPhilipp Reisner 2420a821cc4aSLars Ellenberg /* drain possibly payload */ 2421e2857216SAndreas Gruenbacher return drbd_drain_block(mdev, pi->size); 2422b411b363SPhilipp Reisner } 2423b411b363SPhilipp Reisner 2424b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2425b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2426b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 24270db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, p->block_id, sector, size, GFP_NOIO); 2428db830c46SAndreas Gruenbacher if (!peer_req) { 2429b411b363SPhilipp Reisner put_ldev(mdev); 243082bc0194SAndreas Gruenbacher return -ENOMEM; 2431b411b363SPhilipp Reisner } 2432b411b363SPhilipp Reisner 2433e2857216SAndreas Gruenbacher switch (pi->cmd) { 2434b411b363SPhilipp Reisner case P_DATA_REQUEST: 2435db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2436b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 243780a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 243880a40e43SLars Ellenberg goto submit; 243980a40e43SLars Ellenberg 2440b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2441db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2442b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 24435f9915bbSLars Ellenberg /* used in the sector offset progress display */ 24445f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2445b411b363SPhilipp Reisner break; 2446b411b363SPhilipp Reisner 2447b411b363SPhilipp Reisner case P_OV_REPLY: 2448b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2449b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2450e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2451b411b363SPhilipp Reisner if (!di) 2452b411b363SPhilipp Reisner goto out_free_e; 2453b411b363SPhilipp Reisner 2454e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2455b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2456b411b363SPhilipp Reisner 2457db830c46SAndreas Gruenbacher peer_req->digest = di; 2458db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2459c36c3cedSLars Ellenberg 2460e2857216SAndreas Gruenbacher if (drbd_recv_all(mdev->tconn, di->digest, pi->size)) 2461b411b363SPhilipp Reisner goto out_free_e; 2462b411b363SPhilipp Reisner 2463e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 246431890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2465db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 24665f9915bbSLars Ellenberg /* used in the sector offset progress display */ 24675f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2468e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 24692649f080SLars Ellenberg /* track progress, we may need to throttle */ 24702649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2471db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2472b411b363SPhilipp Reisner dec_rs_pending(mdev); 24730f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 24740f0601f4SLars Ellenberg * but accounting still needs to be done. */ 24750f0601f4SLars Ellenberg goto submit_for_resync; 2476b411b363SPhilipp Reisner } 2477b411b363SPhilipp Reisner break; 2478b411b363SPhilipp Reisner 2479b411b363SPhilipp Reisner case P_OV_REQUEST: 2480b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 248131890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2482de228bbaSLars Ellenberg unsigned long now = jiffies; 2483de228bbaSLars Ellenberg int i; 2484b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2485b411b363SPhilipp Reisner mdev->ov_position = sector; 248630b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 248730b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2488de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2489de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2490de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2491de228bbaSLars Ellenberg } 2492b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2493b411b363SPhilipp Reisner (unsigned long long)sector); 2494b411b363SPhilipp Reisner } 2495db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2496b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2497b411b363SPhilipp Reisner break; 2498b411b363SPhilipp Reisner 2499b411b363SPhilipp Reisner default: 250049ba9b1bSAndreas Gruenbacher BUG(); 2501b411b363SPhilipp Reisner } 2502b411b363SPhilipp Reisner 25030f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 25040f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 25050f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 25060f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 25070f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 25080f0601f4SLars Ellenberg * 25090f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 25100f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 25110f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 25120f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 25130f0601f4SLars Ellenberg * a while, anyways. 25140f0601f4SLars Ellenberg */ 2515b411b363SPhilipp Reisner 25160f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 25170f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 25180f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 25190f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 25200f0601f4SLars Ellenberg * 25210f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 25220f0601f4SLars Ellenberg * we would also throttle its application reads. 25230f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 25240f0601f4SLars Ellenberg */ 2525e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2526e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2527e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 252880a40e43SLars Ellenberg goto out_free_e; 2529b411b363SPhilipp Reisner 25300f0601f4SLars Ellenberg submit_for_resync: 25310f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 25320f0601f4SLars Ellenberg 253380a40e43SLars Ellenberg submit: 2534b411b363SPhilipp Reisner inc_unacked(mdev); 253587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2536db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 253787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2538b411b363SPhilipp Reisner 2539fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 254082bc0194SAndreas Gruenbacher return 0; 2541b411b363SPhilipp Reisner 254210f6d992SLars Ellenberg /* don't care for the reason here */ 254310f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 254487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2545db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 254687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 254722cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 254822cc37a9SLars Ellenberg 2549b411b363SPhilipp Reisner out_free_e: 2550b411b363SPhilipp Reisner put_ldev(mdev); 25513967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 255282bc0194SAndreas Gruenbacher return -EIO; 2553b411b363SPhilipp Reisner } 2554b411b363SPhilipp Reisner 2555b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2556b411b363SPhilipp Reisner { 2557b411b363SPhilipp Reisner int self, peer, rv = -100; 2558b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 255944ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2560b411b363SPhilipp Reisner 2561b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2562b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2563b411b363SPhilipp Reisner 2564b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2565b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2566b411b363SPhilipp Reisner 256744ed167dSPhilipp Reisner rcu_read_lock(); 256844ed167dSPhilipp Reisner after_sb_0p = rcu_dereference(mdev->tconn->net_conf)->after_sb_0p; 256944ed167dSPhilipp Reisner rcu_read_unlock(); 257044ed167dSPhilipp Reisner switch (after_sb_0p) { 2571b411b363SPhilipp Reisner case ASB_CONSENSUS: 2572b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2573b411b363SPhilipp Reisner case ASB_CALL_HELPER: 257444ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2575b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2576b411b363SPhilipp Reisner break; 2577b411b363SPhilipp Reisner case ASB_DISCONNECT: 2578b411b363SPhilipp Reisner break; 2579b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2580b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2581b411b363SPhilipp Reisner rv = -1; 2582b411b363SPhilipp Reisner break; 2583b411b363SPhilipp Reisner } 2584b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2585b411b363SPhilipp Reisner rv = 1; 2586b411b363SPhilipp Reisner break; 2587b411b363SPhilipp Reisner } 2588b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2589b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2590b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2591b411b363SPhilipp Reisner rv = 1; 2592b411b363SPhilipp Reisner break; 2593b411b363SPhilipp Reisner } 2594b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2595b411b363SPhilipp Reisner rv = -1; 2596b411b363SPhilipp Reisner break; 2597b411b363SPhilipp Reisner } 2598b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2599ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2600b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2601b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2602b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 260325703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2604b411b363SPhilipp Reisner ? -1 : 1; 2605b411b363SPhilipp Reisner break; 2606b411b363SPhilipp Reisner } else { 2607b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2608b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2609b411b363SPhilipp Reisner } 261044ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2611b411b363SPhilipp Reisner break; 2612b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2613b411b363SPhilipp Reisner if (ch_self < ch_peer) 2614b411b363SPhilipp Reisner rv = -1; 2615b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2616b411b363SPhilipp Reisner rv = 1; 2617b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2618b411b363SPhilipp Reisner /* Well, then use something else. */ 261925703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2620b411b363SPhilipp Reisner ? -1 : 1; 2621b411b363SPhilipp Reisner break; 2622b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2623b411b363SPhilipp Reisner rv = -1; 2624b411b363SPhilipp Reisner break; 2625b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2626b411b363SPhilipp Reisner rv = 1; 2627b411b363SPhilipp Reisner } 2628b411b363SPhilipp Reisner 2629b411b363SPhilipp Reisner return rv; 2630b411b363SPhilipp Reisner } 2631b411b363SPhilipp Reisner 2632b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2633b411b363SPhilipp Reisner { 26346184ea21SAndreas Gruenbacher int hg, rv = -100; 263544ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2636b411b363SPhilipp Reisner 263744ed167dSPhilipp Reisner rcu_read_lock(); 263844ed167dSPhilipp Reisner after_sb_1p = rcu_dereference(mdev->tconn->net_conf)->after_sb_1p; 263944ed167dSPhilipp Reisner rcu_read_unlock(); 264044ed167dSPhilipp Reisner switch (after_sb_1p) { 2641b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2642b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2643b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2644b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2645b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 264644ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2647b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2648b411b363SPhilipp Reisner break; 2649b411b363SPhilipp Reisner case ASB_DISCONNECT: 2650b411b363SPhilipp Reisner break; 2651b411b363SPhilipp Reisner case ASB_CONSENSUS: 2652b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2653b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2654b411b363SPhilipp Reisner rv = hg; 2655b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2656b411b363SPhilipp Reisner rv = hg; 2657b411b363SPhilipp Reisner break; 2658b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2659b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2660b411b363SPhilipp Reisner break; 2661b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2662b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2663b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2664b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2665b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2666bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2667bb437946SAndreas Gruenbacher 2668bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2669b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2670b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2671b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2672bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2673bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2674b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2675b411b363SPhilipp Reisner } else { 2676b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2677b411b363SPhilipp Reisner rv = hg; 2678b411b363SPhilipp Reisner } 2679b411b363SPhilipp Reisner } else 2680b411b363SPhilipp Reisner rv = hg; 2681b411b363SPhilipp Reisner } 2682b411b363SPhilipp Reisner 2683b411b363SPhilipp Reisner return rv; 2684b411b363SPhilipp Reisner } 2685b411b363SPhilipp Reisner 2686b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2687b411b363SPhilipp Reisner { 26886184ea21SAndreas Gruenbacher int hg, rv = -100; 268944ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2690b411b363SPhilipp Reisner 269144ed167dSPhilipp Reisner rcu_read_lock(); 269244ed167dSPhilipp Reisner after_sb_2p = rcu_dereference(mdev->tconn->net_conf)->after_sb_2p; 269344ed167dSPhilipp Reisner rcu_read_unlock(); 269444ed167dSPhilipp Reisner switch (after_sb_2p) { 2695b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2696b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2697b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2698b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2699b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2700b411b363SPhilipp Reisner case ASB_CONSENSUS: 2701b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 270244ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2703b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2704b411b363SPhilipp Reisner break; 2705b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2706b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2707b411b363SPhilipp Reisner break; 2708b411b363SPhilipp Reisner case ASB_DISCONNECT: 2709b411b363SPhilipp Reisner break; 2710b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2711b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2712b411b363SPhilipp Reisner if (hg == -1) { 2713bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2714bb437946SAndreas Gruenbacher 2715b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2716b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2717b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2718bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2719bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2720b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2721b411b363SPhilipp Reisner } else { 2722b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2723b411b363SPhilipp Reisner rv = hg; 2724b411b363SPhilipp Reisner } 2725b411b363SPhilipp Reisner } else 2726b411b363SPhilipp Reisner rv = hg; 2727b411b363SPhilipp Reisner } 2728b411b363SPhilipp Reisner 2729b411b363SPhilipp Reisner return rv; 2730b411b363SPhilipp Reisner } 2731b411b363SPhilipp Reisner 2732b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2733b411b363SPhilipp Reisner u64 bits, u64 flags) 2734b411b363SPhilipp Reisner { 2735b411b363SPhilipp Reisner if (!uuid) { 2736b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2737b411b363SPhilipp Reisner return; 2738b411b363SPhilipp Reisner } 2739b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2740b411b363SPhilipp Reisner text, 2741b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2742b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2743b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2744b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2745b411b363SPhilipp Reisner (unsigned long long)bits, 2746b411b363SPhilipp Reisner (unsigned long long)flags); 2747b411b363SPhilipp Reisner } 2748b411b363SPhilipp Reisner 2749b411b363SPhilipp Reisner /* 2750b411b363SPhilipp Reisner 100 after split brain try auto recover 2751b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2752b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2753b411b363SPhilipp Reisner 0 no Sync 2754b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2755b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2756b411b363SPhilipp Reisner -100 after split brain, disconnect 2757b411b363SPhilipp Reisner -1000 unrelated data 27584a23f264SPhilipp Reisner -1091 requires proto 91 27594a23f264SPhilipp Reisner -1096 requires proto 96 2760b411b363SPhilipp Reisner */ 2761b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2762b411b363SPhilipp Reisner { 2763b411b363SPhilipp Reisner u64 self, peer; 2764b411b363SPhilipp Reisner int i, j; 2765b411b363SPhilipp Reisner 2766b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2767b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2768b411b363SPhilipp Reisner 2769b411b363SPhilipp Reisner *rule_nr = 10; 2770b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2771b411b363SPhilipp Reisner return 0; 2772b411b363SPhilipp Reisner 2773b411b363SPhilipp Reisner *rule_nr = 20; 2774b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2775b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2776b411b363SPhilipp Reisner return -2; 2777b411b363SPhilipp Reisner 2778b411b363SPhilipp Reisner *rule_nr = 30; 2779b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2780b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2781b411b363SPhilipp Reisner return 2; 2782b411b363SPhilipp Reisner 2783b411b363SPhilipp Reisner if (self == peer) { 2784b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2785b411b363SPhilipp Reisner 2786b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2787b411b363SPhilipp Reisner 278831890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27894a23f264SPhilipp Reisner return -1091; 2790b411b363SPhilipp Reisner 2791b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2792b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2793b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2794b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2795b411b363SPhilipp Reisner 2796b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2797b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2798b411b363SPhilipp Reisner *rule_nr = 34; 2799b411b363SPhilipp Reisner } else { 2800b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2801b411b363SPhilipp Reisner *rule_nr = 36; 2802b411b363SPhilipp Reisner } 2803b411b363SPhilipp Reisner 2804b411b363SPhilipp Reisner return 1; 2805b411b363SPhilipp Reisner } 2806b411b363SPhilipp Reisner 2807b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2808b411b363SPhilipp Reisner 280931890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28104a23f264SPhilipp Reisner return -1091; 2811b411b363SPhilipp Reisner 2812b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2813b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2814b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2815b411b363SPhilipp Reisner 2816b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2817b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2818b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2819b411b363SPhilipp Reisner 2820b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2821b411b363SPhilipp Reisner *rule_nr = 35; 2822b411b363SPhilipp Reisner } else { 2823b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2824b411b363SPhilipp Reisner *rule_nr = 37; 2825b411b363SPhilipp Reisner } 2826b411b363SPhilipp Reisner 2827b411b363SPhilipp Reisner return -1; 2828b411b363SPhilipp Reisner } 2829b411b363SPhilipp Reisner 2830b411b363SPhilipp Reisner /* Common power [off|failure] */ 2831b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2832b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2833b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2834b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2835b411b363SPhilipp Reisner *rule_nr = 40; 2836b411b363SPhilipp Reisner 2837b411b363SPhilipp Reisner switch (rct) { 2838b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2839b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2840b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2841b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 284225703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2843b411b363SPhilipp Reisner return dc ? -1 : 1; 2844b411b363SPhilipp Reisner } 2845b411b363SPhilipp Reisner } 2846b411b363SPhilipp Reisner 2847b411b363SPhilipp Reisner *rule_nr = 50; 2848b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2849b411b363SPhilipp Reisner if (self == peer) 2850b411b363SPhilipp Reisner return -1; 2851b411b363SPhilipp Reisner 2852b411b363SPhilipp Reisner *rule_nr = 51; 2853b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2854b411b363SPhilipp Reisner if (self == peer) { 285531890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 28564a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 28574a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 28584a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2859b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2860b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2861b411b363SPhilipp Reisner 286231890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28634a23f264SPhilipp Reisner return -1091; 2864b411b363SPhilipp Reisner 2865b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2866b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 28674a23f264SPhilipp Reisner 28681882e22dSLars Ellenberg dev_info(DEV, "Lost last syncUUID packet, corrected:\n"); 28694a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 28704a23f264SPhilipp Reisner 2871b411b363SPhilipp Reisner return -1; 2872b411b363SPhilipp Reisner } 2873b411b363SPhilipp Reisner } 2874b411b363SPhilipp Reisner 2875b411b363SPhilipp Reisner *rule_nr = 60; 2876b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2877b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2878b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2879b411b363SPhilipp Reisner if (self == peer) 2880b411b363SPhilipp Reisner return -2; 2881b411b363SPhilipp Reisner } 2882b411b363SPhilipp Reisner 2883b411b363SPhilipp Reisner *rule_nr = 70; 2884b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2885b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2886b411b363SPhilipp Reisner if (self == peer) 2887b411b363SPhilipp Reisner return 1; 2888b411b363SPhilipp Reisner 2889b411b363SPhilipp Reisner *rule_nr = 71; 2890b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2891b411b363SPhilipp Reisner if (self == peer) { 289231890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 28934a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 28944a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 28954a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2896b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2897b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2898b411b363SPhilipp Reisner 289931890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 29004a23f264SPhilipp Reisner return -1091; 2901b411b363SPhilipp Reisner 2902b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2903b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2904b411b363SPhilipp Reisner 29054a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2906b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2907b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2908b411b363SPhilipp Reisner 2909b411b363SPhilipp Reisner return 1; 2910b411b363SPhilipp Reisner } 2911b411b363SPhilipp Reisner } 2912b411b363SPhilipp Reisner 2913b411b363SPhilipp Reisner 2914b411b363SPhilipp Reisner *rule_nr = 80; 2915d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2916b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2917b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2918b411b363SPhilipp Reisner if (self == peer) 2919b411b363SPhilipp Reisner return 2; 2920b411b363SPhilipp Reisner } 2921b411b363SPhilipp Reisner 2922b411b363SPhilipp Reisner *rule_nr = 90; 2923b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2924b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2925b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2926b411b363SPhilipp Reisner return 100; 2927b411b363SPhilipp Reisner 2928b411b363SPhilipp Reisner *rule_nr = 100; 2929b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2930b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2931b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2932b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2933b411b363SPhilipp Reisner if (self == peer) 2934b411b363SPhilipp Reisner return -100; 2935b411b363SPhilipp Reisner } 2936b411b363SPhilipp Reisner } 2937b411b363SPhilipp Reisner 2938b411b363SPhilipp Reisner return -1000; 2939b411b363SPhilipp Reisner } 2940b411b363SPhilipp Reisner 2941b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2942b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2943b411b363SPhilipp Reisner */ 2944b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2945b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2946b411b363SPhilipp Reisner { 2947b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2948b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 294944ed167dSPhilipp Reisner struct net_conf *nc; 29506dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 2951b411b363SPhilipp Reisner 2952b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2953b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2954b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2955b411b363SPhilipp Reisner 2956b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2957b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2958b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2959b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2960b411b363SPhilipp Reisner 2961b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2962b411b363SPhilipp Reisner 2963b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2964b411b363SPhilipp Reisner 2965b411b363SPhilipp Reisner if (hg == -1000) { 2966b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2967b411b363SPhilipp Reisner return C_MASK; 2968b411b363SPhilipp Reisner } 29694a23f264SPhilipp Reisner if (hg < -1000) { 29704a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2971b411b363SPhilipp Reisner return C_MASK; 2972b411b363SPhilipp Reisner } 2973b411b363SPhilipp Reisner 2974b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2975b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2976b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2977b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2978b411b363SPhilipp Reisner if (f) 2979b411b363SPhilipp Reisner hg = hg*2; 2980b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2981b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2982b411b363SPhilipp Reisner } 2983b411b363SPhilipp Reisner 29843a11a487SAdam Gandelman if (abs(hg) == 100) 29853a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 29863a11a487SAdam Gandelman 298744ed167dSPhilipp Reisner rcu_read_lock(); 298844ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 298944ed167dSPhilipp Reisner 299044ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 2991b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2992b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2993b411b363SPhilipp Reisner int forced = (hg == -100); 2994b411b363SPhilipp Reisner 2995b411b363SPhilipp Reisner switch (pcount) { 2996b411b363SPhilipp Reisner case 0: 2997b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2998b411b363SPhilipp Reisner break; 2999b411b363SPhilipp Reisner case 1: 3000b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 3001b411b363SPhilipp Reisner break; 3002b411b363SPhilipp Reisner case 2: 3003b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 3004b411b363SPhilipp Reisner break; 3005b411b363SPhilipp Reisner } 3006b411b363SPhilipp Reisner if (abs(hg) < 100) { 3007b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 3008b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3009b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3010b411b363SPhilipp Reisner if (forced) { 3011b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 3012b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3013b411b363SPhilipp Reisner hg = hg*2; 3014b411b363SPhilipp Reisner } 3015b411b363SPhilipp Reisner } 3016b411b363SPhilipp Reisner } 3017b411b363SPhilipp Reisner 3018b411b363SPhilipp Reisner if (hg == -100) { 301908b165baSPhilipp Reisner if (test_bit(DISCARD_MY_DATA, &mdev->flags) && !(mdev->p_uuid[UI_FLAGS]&1)) 3020b411b363SPhilipp Reisner hg = -1; 302108b165baSPhilipp Reisner if (!test_bit(DISCARD_MY_DATA, &mdev->flags) && (mdev->p_uuid[UI_FLAGS]&1)) 3022b411b363SPhilipp Reisner hg = 1; 3023b411b363SPhilipp Reisner 3024b411b363SPhilipp Reisner if (abs(hg) < 100) 3025b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 3026b411b363SPhilipp Reisner "Sync from %s node\n", 3027b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3028b411b363SPhilipp Reisner } 302944ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 30306dff2902SAndreas Gruenbacher tentative = nc->tentative; 303144ed167dSPhilipp Reisner rcu_read_unlock(); 3032b411b363SPhilipp Reisner 3033b411b363SPhilipp Reisner if (hg == -100) { 3034580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3035580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3036580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3037580b9767SLars Ellenberg * to that disk, in a way... */ 30383a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 3039b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 3040b411b363SPhilipp Reisner return C_MASK; 3041b411b363SPhilipp Reisner } 3042b411b363SPhilipp Reisner 3043b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3044b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 3045b411b363SPhilipp Reisner return C_MASK; 3046b411b363SPhilipp Reisner } 3047b411b363SPhilipp Reisner 3048b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3049b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 305044ed167dSPhilipp Reisner switch (rr_conflict) { 3051b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3052b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 3053b411b363SPhilipp Reisner /* fall through */ 3054b411b363SPhilipp Reisner case ASB_DISCONNECT: 3055b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 3056b411b363SPhilipp Reisner return C_MASK; 3057b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3058b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 3059b411b363SPhilipp Reisner "assumption\n"); 3060b411b363SPhilipp Reisner } 3061b411b363SPhilipp Reisner } 3062b411b363SPhilipp Reisner 30636dff2902SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 3064cf14c2e9SPhilipp Reisner if (hg == 0) 3065cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 3066cf14c2e9SPhilipp Reisner else 3067cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 3068cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3069cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3070cf14c2e9SPhilipp Reisner return C_MASK; 3071cf14c2e9SPhilipp Reisner } 3072cf14c2e9SPhilipp Reisner 3073b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3074b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 307520ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 307620ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3077b411b363SPhilipp Reisner return C_MASK; 3078b411b363SPhilipp Reisner } 3079b411b363SPhilipp Reisner 3080b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3081b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3082b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3083b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3084b411b363SPhilipp Reisner } else { 3085b411b363SPhilipp Reisner rv = C_CONNECTED; 3086b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 3087b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 3088b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 3089b411b363SPhilipp Reisner } 3090b411b363SPhilipp Reisner } 3091b411b363SPhilipp Reisner 3092b411b363SPhilipp Reisner return rv; 3093b411b363SPhilipp Reisner } 3094b411b363SPhilipp Reisner 3095f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3096b411b363SPhilipp Reisner { 3097b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3098f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3099f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3100b411b363SPhilipp Reisner 3101b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3102f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3103f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3104b411b363SPhilipp Reisner 3105b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3106f179d76dSPhilipp Reisner return peer; 3107b411b363SPhilipp Reisner } 3108b411b363SPhilipp Reisner 3109e2857216SAndreas Gruenbacher static int receive_protocol(struct drbd_tconn *tconn, struct packet_info *pi) 3110b411b363SPhilipp Reisner { 3111e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3112036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3113036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3114036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3115036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 3116accdbcc5SAndreas Gruenbacher struct crypto_hash *peer_integrity_tfm = NULL; 31177aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3118b411b363SPhilipp Reisner 3119b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3120b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3121b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3122b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3123b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3124cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 31256139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3126cf14c2e9SPhilipp Reisner 312786db0618SAndreas Gruenbacher if (tconn->agreed_pro_version >= 87) { 312886db0618SAndreas Gruenbacher int err; 312986db0618SAndreas Gruenbacher 313088104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 313186db0618SAndreas Gruenbacher return -EIO; 313288104ca4SAndreas Gruenbacher err = drbd_recv_all(tconn, integrity_alg, pi->size); 313386db0618SAndreas Gruenbacher if (err) 313486db0618SAndreas Gruenbacher return err; 313588104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3136036b17eaSPhilipp Reisner } 313786db0618SAndreas Gruenbacher 31387d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 31397204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 3140cf14c2e9SPhilipp Reisner 3141cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 31427204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 3143b411b363SPhilipp Reisner 314444ed167dSPhilipp Reisner rcu_read_lock(); 314544ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 314644ed167dSPhilipp Reisner 3147036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 3148d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "protocol"); 314944ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3150b411b363SPhilipp Reisner } 3151b411b363SPhilipp Reisner 3152f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 3153d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-0pri"); 315444ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3155b411b363SPhilipp Reisner } 3156b411b363SPhilipp Reisner 3157f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 3158d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-1pri"); 315944ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3160b411b363SPhilipp Reisner } 3161b411b363SPhilipp Reisner 3162f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 3163d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-2pri"); 316444ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3165b411b363SPhilipp Reisner } 3166b411b363SPhilipp Reisner 31676139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 3168d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "discard-my-data"); 316944ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3170b411b363SPhilipp Reisner } 3171b411b363SPhilipp Reisner 317244ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 3173d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "allow-two-primaries"); 317444ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3175b411b363SPhilipp Reisner } 3176b411b363SPhilipp Reisner 3177036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 3178d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "data-integrity-alg"); 3179036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3180036b17eaSPhilipp Reisner } 3181036b17eaSPhilipp Reisner 318286db0618SAndreas Gruenbacher rcu_read_unlock(); 3183fbc12f45SAndreas Gruenbacher } 31847d4c782cSAndreas Gruenbacher 31857d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 31867d4c782cSAndreas Gruenbacher int hash_size; 31877d4c782cSAndreas Gruenbacher 31887d4c782cSAndreas Gruenbacher /* 31897d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 31907d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 31917d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 31927d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 31937d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 31947d4c782cSAndreas Gruenbacher * change. 31957d4c782cSAndreas Gruenbacher */ 31967d4c782cSAndreas Gruenbacher 31977d4c782cSAndreas Gruenbacher peer_integrity_tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 31987d4c782cSAndreas Gruenbacher if (!peer_integrity_tfm) { 31997d4c782cSAndreas Gruenbacher conn_err(tconn, "peer data-integrity-alg %s not supported\n", 32007d4c782cSAndreas Gruenbacher integrity_alg); 32017d4c782cSAndreas Gruenbacher goto disconnect; 32027d4c782cSAndreas Gruenbacher } 32037d4c782cSAndreas Gruenbacher 32047d4c782cSAndreas Gruenbacher hash_size = crypto_hash_digestsize(peer_integrity_tfm); 32057d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 32067d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 32077d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 32087d4c782cSAndreas Gruenbacher conn_err(tconn, "Allocation of buffers for data integrity checking failed\n"); 32097d4c782cSAndreas Gruenbacher goto disconnect; 32107d4c782cSAndreas Gruenbacher } 32117d4c782cSAndreas Gruenbacher } 32127d4c782cSAndreas Gruenbacher 32137d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 32147d4c782cSAndreas Gruenbacher if (!new_net_conf) { 32157d4c782cSAndreas Gruenbacher conn_err(tconn, "Allocation of new net_conf failed\n"); 32167d4c782cSAndreas Gruenbacher goto disconnect; 32177d4c782cSAndreas Gruenbacher } 32187d4c782cSAndreas Gruenbacher 32197d4c782cSAndreas Gruenbacher mutex_lock(&tconn->data.mutex); 32207d4c782cSAndreas Gruenbacher mutex_lock(&tconn->conf_update); 32217d4c782cSAndreas Gruenbacher old_net_conf = tconn->net_conf; 32227d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 32237d4c782cSAndreas Gruenbacher 32247d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 32257d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 32267d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 32277d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 32287d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 32297d4c782cSAndreas Gruenbacher 32307d4c782cSAndreas Gruenbacher rcu_assign_pointer(tconn->net_conf, new_net_conf); 32317d4c782cSAndreas Gruenbacher mutex_unlock(&tconn->conf_update); 32327d4c782cSAndreas Gruenbacher mutex_unlock(&tconn->data.mutex); 32337d4c782cSAndreas Gruenbacher 32347d4c782cSAndreas Gruenbacher crypto_free_hash(tconn->peer_integrity_tfm); 32357d4c782cSAndreas Gruenbacher kfree(tconn->int_dig_in); 32367d4c782cSAndreas Gruenbacher kfree(tconn->int_dig_vv); 32377d4c782cSAndreas Gruenbacher tconn->peer_integrity_tfm = peer_integrity_tfm; 32387d4c782cSAndreas Gruenbacher tconn->int_dig_in = int_dig_in; 32397d4c782cSAndreas Gruenbacher tconn->int_dig_vv = int_dig_vv; 32407d4c782cSAndreas Gruenbacher 32417d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 32427d4c782cSAndreas Gruenbacher conn_info(tconn, "peer data-integrity-alg: %s\n", 32437d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 32447d4c782cSAndreas Gruenbacher 32457d4c782cSAndreas Gruenbacher synchronize_rcu(); 32467d4c782cSAndreas Gruenbacher kfree(old_net_conf); 324782bc0194SAndreas Gruenbacher return 0; 3248b411b363SPhilipp Reisner 324944ed167dSPhilipp Reisner disconnect_rcu_unlock: 325044ed167dSPhilipp Reisner rcu_read_unlock(); 3251b411b363SPhilipp Reisner disconnect: 3252b792c35cSAndreas Gruenbacher crypto_free_hash(peer_integrity_tfm); 3253036b17eaSPhilipp Reisner kfree(int_dig_in); 3254036b17eaSPhilipp Reisner kfree(int_dig_vv); 32557204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 325682bc0194SAndreas Gruenbacher return -EIO; 3257b411b363SPhilipp Reisner } 3258b411b363SPhilipp Reisner 3259b411b363SPhilipp Reisner /* helper function 3260b411b363SPhilipp Reisner * input: alg name, feature name 3261b411b363SPhilipp Reisner * return: NULL (alg name was "") 3262b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3263b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 3264b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 3265b411b363SPhilipp Reisner const char *alg, const char *name) 3266b411b363SPhilipp Reisner { 3267b411b363SPhilipp Reisner struct crypto_hash *tfm; 3268b411b363SPhilipp Reisner 3269b411b363SPhilipp Reisner if (!alg[0]) 3270b411b363SPhilipp Reisner return NULL; 3271b411b363SPhilipp Reisner 3272b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3273b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3274b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3275b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3276b411b363SPhilipp Reisner return tfm; 3277b411b363SPhilipp Reisner } 3278b411b363SPhilipp Reisner return tfm; 3279b411b363SPhilipp Reisner } 3280b411b363SPhilipp Reisner 32814a76b161SAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_tconn *tconn, struct packet_info *pi) 3282b411b363SPhilipp Reisner { 32834a76b161SAndreas Gruenbacher void *buffer = tconn->data.rbuf; 32844a76b161SAndreas Gruenbacher int size = pi->size; 32854a76b161SAndreas Gruenbacher 32864a76b161SAndreas Gruenbacher while (size) { 32874a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 32884a76b161SAndreas Gruenbacher s = drbd_recv(tconn, buffer, s); 32894a76b161SAndreas Gruenbacher if (s <= 0) { 32904a76b161SAndreas Gruenbacher if (s < 0) 32914a76b161SAndreas Gruenbacher return s; 32924a76b161SAndreas Gruenbacher break; 32934a76b161SAndreas Gruenbacher } 32944a76b161SAndreas Gruenbacher size -= s; 32954a76b161SAndreas Gruenbacher } 32964a76b161SAndreas Gruenbacher if (size) 32974a76b161SAndreas Gruenbacher return -EIO; 32984a76b161SAndreas Gruenbacher return 0; 32994a76b161SAndreas Gruenbacher } 33004a76b161SAndreas Gruenbacher 33014a76b161SAndreas Gruenbacher /* 33024a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 33034a76b161SAndreas Gruenbacher * 33044a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 33054a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 33064a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 33074a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 33084a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 33094a76b161SAndreas Gruenbacher * 33104a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 33114a76b161SAndreas Gruenbacher */ 33124a76b161SAndreas Gruenbacher static int config_unknown_volume(struct drbd_tconn *tconn, struct packet_info *pi) 33134a76b161SAndreas Gruenbacher { 33142fcb8f30SAndreas Gruenbacher conn_warn(tconn, "%s packet received for volume %u, which is not configured locally\n", 33152fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 33164a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 33174a76b161SAndreas Gruenbacher } 33184a76b161SAndreas Gruenbacher 33194a76b161SAndreas Gruenbacher static int receive_SyncParam(struct drbd_tconn *tconn, struct packet_info *pi) 33204a76b161SAndreas Gruenbacher { 33214a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3322e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3323b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3324b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3325b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 33262ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3327813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 33284a76b161SAndreas Gruenbacher const int apv = tconn->agreed_pro_version; 3329813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3330778f271dSPhilipp Reisner int fifo_size = 0; 333182bc0194SAndreas Gruenbacher int err; 3332b411b363SPhilipp Reisner 33334a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 33344a76b161SAndreas Gruenbacher if (!mdev) 33354a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 33364a76b161SAndreas Gruenbacher 3337b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3338b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3339b411b363SPhilipp Reisner + SHARED_SECRET_MAX 33408e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 33418e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3342b411b363SPhilipp Reisner 3343e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3344b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3345e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 334682bc0194SAndreas Gruenbacher return -EIO; 3347b411b363SPhilipp Reisner } 3348b411b363SPhilipp Reisner 3349b411b363SPhilipp Reisner if (apv <= 88) { 3350e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3351e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 33528e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3353e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3354e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3355b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 33568e26f9ccSPhilipp Reisner } else { 3357e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3358e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3359b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 3360b411b363SPhilipp Reisner } 3361b411b363SPhilipp Reisner 3362b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3363e658983aSAndreas Gruenbacher p = pi->data; 3364b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3365b411b363SPhilipp Reisner 3366e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, header_size); 336782bc0194SAndreas Gruenbacher if (err) 336882bc0194SAndreas Gruenbacher return err; 3369b411b363SPhilipp Reisner 3370813472ceSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3371813472ceSPhilipp Reisner old_net_conf = mdev->tconn->net_conf; 3372813472ceSPhilipp Reisner if (get_ldev(mdev)) { 3373daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3374daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3375813472ceSPhilipp Reisner put_ldev(mdev); 3376813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3377daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3378daeda1ccSPhilipp Reisner return -ENOMEM; 3379f399002eSLars Ellenberg } 3380b411b363SPhilipp Reisner 3381daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3382daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3383daeda1ccSPhilipp Reisner 33846394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3385813472ceSPhilipp Reisner } 3386daeda1ccSPhilipp Reisner 3387b411b363SPhilipp Reisner if (apv >= 88) { 3388b411b363SPhilipp Reisner if (apv == 88) { 3389e4bad1bcSPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 3390e4bad1bcSPhilipp Reisner dev_err(DEV, "verify-alg of wrong size, " 3391e4bad1bcSPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3392b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3393813472ceSPhilipp Reisner err = -EIO; 3394813472ceSPhilipp Reisner goto reconnect; 3395b411b363SPhilipp Reisner } 3396b411b363SPhilipp Reisner 339782bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size); 3398813472ceSPhilipp Reisner if (err) 3399813472ceSPhilipp Reisner goto reconnect; 3400b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3401b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3402b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3403b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3404b411b363SPhilipp Reisner 3405b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3406b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3407b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3408b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3409b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3410b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3411b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3412b411b363SPhilipp Reisner } 3413b411b363SPhilipp Reisner 34142ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3415b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3416b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 34172ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3418b411b363SPhilipp Reisner goto disconnect; 3419b411b363SPhilipp Reisner } 3420b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3421b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3422b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3423b411b363SPhilipp Reisner verify_tfm = NULL; 3424b411b363SPhilipp Reisner goto disconnect; 3425b411b363SPhilipp Reisner } 3426b411b363SPhilipp Reisner } 3427b411b363SPhilipp Reisner 34282ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3429b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3430b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 34312ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3432b411b363SPhilipp Reisner goto disconnect; 3433b411b363SPhilipp Reisner } 3434b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3435b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3436b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3437b411b363SPhilipp Reisner csums_tfm = NULL; 3438b411b363SPhilipp Reisner goto disconnect; 3439b411b363SPhilipp Reisner } 3440b411b363SPhilipp Reisner } 3441b411b363SPhilipp Reisner 3442813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3443daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3444daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3445daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3446daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3447778f271dSPhilipp Reisner 3448daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 34499958c857SPhilipp Reisner if (fifo_size != mdev->rs_plan_s->size) { 3450813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3451813472ceSPhilipp Reisner if (!new_plan) { 3452778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3453f399002eSLars Ellenberg put_ldev(mdev); 3454778f271dSPhilipp Reisner goto disconnect; 3455778f271dSPhilipp Reisner } 3456778f271dSPhilipp Reisner } 34578e26f9ccSPhilipp Reisner } 3458b411b363SPhilipp Reisner 345991fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 34602ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 34612ec91e0eSPhilipp Reisner if (!new_net_conf) { 346291fd4dadSPhilipp Reisner dev_err(DEV, "Allocation of new net_conf failed\n"); 346391fd4dadSPhilipp Reisner goto disconnect; 346491fd4dadSPhilipp Reisner } 346591fd4dadSPhilipp Reisner 34662ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 346791fd4dadSPhilipp Reisner 3468b411b363SPhilipp Reisner if (verify_tfm) { 34692ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 34702ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3471f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3472f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3473b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3474b411b363SPhilipp Reisner } 3475b411b363SPhilipp Reisner if (csums_tfm) { 34762ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 34772ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3478f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3479f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3480b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3481b411b363SPhilipp Reisner } 34822ec91e0eSPhilipp Reisner rcu_assign_pointer(tconn->net_conf, new_net_conf); 348391fd4dadSPhilipp Reisner } 348491fd4dadSPhilipp Reisner } 348591fd4dadSPhilipp Reisner 3486813472ceSPhilipp Reisner if (new_disk_conf) { 3487daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3488813472ceSPhilipp Reisner put_ldev(mdev); 3489778f271dSPhilipp Reisner } 3490813472ceSPhilipp Reisner 3491813472ceSPhilipp Reisner if (new_plan) { 3492813472ceSPhilipp Reisner old_plan = mdev->rs_plan_s; 3493813472ceSPhilipp Reisner rcu_assign_pointer(mdev->rs_plan_s, new_plan); 3494813472ceSPhilipp Reisner } 3495daeda1ccSPhilipp Reisner 3496daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3497daeda1ccSPhilipp Reisner synchronize_rcu(); 3498daeda1ccSPhilipp Reisner if (new_net_conf) 3499daeda1ccSPhilipp Reisner kfree(old_net_conf); 3500daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3501813472ceSPhilipp Reisner kfree(old_plan); 3502daeda1ccSPhilipp Reisner 350382bc0194SAndreas Gruenbacher return 0; 3504b411b363SPhilipp Reisner 3505813472ceSPhilipp Reisner reconnect: 3506813472ceSPhilipp Reisner if (new_disk_conf) { 3507813472ceSPhilipp Reisner put_ldev(mdev); 3508813472ceSPhilipp Reisner kfree(new_disk_conf); 3509813472ceSPhilipp Reisner } 3510813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3511813472ceSPhilipp Reisner return -EIO; 3512813472ceSPhilipp Reisner 3513b411b363SPhilipp Reisner disconnect: 3514813472ceSPhilipp Reisner kfree(new_plan); 3515813472ceSPhilipp Reisner if (new_disk_conf) { 3516813472ceSPhilipp Reisner put_ldev(mdev); 3517813472ceSPhilipp Reisner kfree(new_disk_conf); 3518813472ceSPhilipp Reisner } 3519a0095508SPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3520b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3521b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3522b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3523b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3524b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 352538fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 352682bc0194SAndreas Gruenbacher return -EIO; 3527b411b363SPhilipp Reisner } 3528b411b363SPhilipp Reisner 3529b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3530b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3531b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3532b411b363SPhilipp Reisner { 3533b411b363SPhilipp Reisner sector_t d; 3534b411b363SPhilipp Reisner if (a == 0 || b == 0) 3535b411b363SPhilipp Reisner return; 3536b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3537b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3538b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3539b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3540b411b363SPhilipp Reisner } 3541b411b363SPhilipp Reisner 35424a76b161SAndreas Gruenbacher static int receive_sizes(struct drbd_tconn *tconn, struct packet_info *pi) 3543b411b363SPhilipp Reisner { 35444a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3545e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3546b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3547b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3548b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3549e89b591cSPhilipp Reisner enum dds_flags ddsf; 3550b411b363SPhilipp Reisner 35514a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 35524a76b161SAndreas Gruenbacher if (!mdev) 35534a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 35544a76b161SAndreas Gruenbacher 3555b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3556b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3557b411b363SPhilipp Reisner 3558b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3559b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3560b411b363SPhilipp Reisner mdev->p_size = p_size; 3561b411b363SPhilipp Reisner 3562b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3563daeda1ccSPhilipp Reisner rcu_read_lock(); 3564daeda1ccSPhilipp Reisner my_usize = rcu_dereference(mdev->ldev->disk_conf)->disk_size; 3565daeda1ccSPhilipp Reisner rcu_read_unlock(); 3566daeda1ccSPhilipp Reisner 3567b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3568b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3569b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3570daeda1ccSPhilipp Reisner p_usize, my_usize); 3571b411b363SPhilipp Reisner 3572b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3573b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3574b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3575daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3576b411b363SPhilipp Reisner 3577b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3578b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3579ef5e44a6SPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, p_usize, 0) < 3580b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3581b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3582b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3583b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 358438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3585b411b363SPhilipp Reisner put_ldev(mdev); 358682bc0194SAndreas Gruenbacher return -EIO; 3587b411b363SPhilipp Reisner } 3588daeda1ccSPhilipp Reisner 3589daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3590daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3591daeda1ccSPhilipp Reisner 3592daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3593daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3594daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3595daeda1ccSPhilipp Reisner put_ldev(mdev); 3596daeda1ccSPhilipp Reisner return -ENOMEM; 3597daeda1ccSPhilipp Reisner } 3598daeda1ccSPhilipp Reisner 3599daeda1ccSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3600daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3601daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3602daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3603daeda1ccSPhilipp Reisner 3604daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3605daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3606daeda1ccSPhilipp Reisner synchronize_rcu(); 3607daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3608daeda1ccSPhilipp Reisner 3609daeda1ccSPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3610daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3611daeda1ccSPhilipp Reisner } 3612daeda1ccSPhilipp Reisner 3613b411b363SPhilipp Reisner put_ldev(mdev); 3614b411b363SPhilipp Reisner } 3615b411b363SPhilipp Reisner 3616e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3617b411b363SPhilipp Reisner if (get_ldev(mdev)) { 361824c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3619b411b363SPhilipp Reisner put_ldev(mdev); 3620b411b363SPhilipp Reisner if (dd == dev_size_error) 362182bc0194SAndreas Gruenbacher return -EIO; 3622b411b363SPhilipp Reisner drbd_md_sync(mdev); 3623b411b363SPhilipp Reisner } else { 3624b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3625b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3626b411b363SPhilipp Reisner } 3627b411b363SPhilipp Reisner 362899432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 362999432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 363099432fccSPhilipp Reisner 3631b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3632b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3633b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3634b411b363SPhilipp Reisner ldsc = 1; 3635b411b363SPhilipp Reisner } 3636b411b363SPhilipp Reisner 3637b411b363SPhilipp Reisner put_ldev(mdev); 3638b411b363SPhilipp Reisner } 3639b411b363SPhilipp Reisner 3640b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3641b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3642b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3643b411b363SPhilipp Reisner /* we have different sizes, probably peer 3644b411b363SPhilipp Reisner * needs to know my new size... */ 3645e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3646b411b363SPhilipp Reisner } 3647b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3648b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3649b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3650e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3651e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3652e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3653b411b363SPhilipp Reisner else 3654e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3655e89b591cSPhilipp Reisner } else 3656b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3657b411b363SPhilipp Reisner } 3658b411b363SPhilipp Reisner } 3659b411b363SPhilipp Reisner 366082bc0194SAndreas Gruenbacher return 0; 3661b411b363SPhilipp Reisner } 3662b411b363SPhilipp Reisner 36634a76b161SAndreas Gruenbacher static int receive_uuids(struct drbd_tconn *tconn, struct packet_info *pi) 3664b411b363SPhilipp Reisner { 36654a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3666e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3667b411b363SPhilipp Reisner u64 *p_uuid; 366862b0da3aSLars Ellenberg int i, updated_uuids = 0; 3669b411b363SPhilipp Reisner 36704a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 36714a76b161SAndreas Gruenbacher if (!mdev) 36724a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 36734a76b161SAndreas Gruenbacher 3674b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3675b411b363SPhilipp Reisner 3676b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3677b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3678b411b363SPhilipp Reisner 3679b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3680b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3681b411b363SPhilipp Reisner 3682b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3683b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3684b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3685b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3686b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3687b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 368838fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 368982bc0194SAndreas Gruenbacher return -EIO; 3690b411b363SPhilipp Reisner } 3691b411b363SPhilipp Reisner 3692b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3693b411b363SPhilipp Reisner int skip_initial_sync = 3694b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 369531890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3696b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3697b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3698b411b363SPhilipp Reisner if (skip_initial_sync) { 3699b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3700b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 370120ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 370220ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3703b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3704b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3705b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3706b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3707b411b363SPhilipp Reisner drbd_md_sync(mdev); 370862b0da3aSLars Ellenberg updated_uuids = 1; 3709b411b363SPhilipp Reisner } 3710b411b363SPhilipp Reisner put_ldev(mdev); 371118a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 371218a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 371318a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 371418a50fa2SPhilipp Reisner for me. */ 371562b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3716b411b363SPhilipp Reisner } 3717b411b363SPhilipp Reisner 3718b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3719b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3720b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3721b411b363SPhilipp Reisner new disk state... */ 37228410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 37238410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3724b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 372562b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 372662b0da3aSLars Ellenberg 372762b0da3aSLars Ellenberg if (updated_uuids) 372862b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3729b411b363SPhilipp Reisner 373082bc0194SAndreas Gruenbacher return 0; 3731b411b363SPhilipp Reisner } 3732b411b363SPhilipp Reisner 3733b411b363SPhilipp Reisner /** 3734b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3735b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3736b411b363SPhilipp Reisner */ 3737b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3738b411b363SPhilipp Reisner { 3739b411b363SPhilipp Reisner union drbd_state ms; 3740b411b363SPhilipp Reisner 3741b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3742369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 3743b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3744b411b363SPhilipp Reisner 3745b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3746b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3747b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3748b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3749b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3750b411b363SPhilipp Reisner }; 3751b411b363SPhilipp Reisner 3752b411b363SPhilipp Reisner ms.i = ps.i; 3753b411b363SPhilipp Reisner 3754b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3755b411b363SPhilipp Reisner ms.peer = ps.role; 3756b411b363SPhilipp Reisner ms.role = ps.peer; 3757b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3758b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3759b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3760b411b363SPhilipp Reisner 3761b411b363SPhilipp Reisner return ms; 3762b411b363SPhilipp Reisner } 3763b411b363SPhilipp Reisner 37644a76b161SAndreas Gruenbacher static int receive_req_state(struct drbd_tconn *tconn, struct packet_info *pi) 3765b411b363SPhilipp Reisner { 37664a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3767e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3768b411b363SPhilipp Reisner union drbd_state mask, val; 3769bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3770b411b363SPhilipp Reisner 37714a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 37724a76b161SAndreas Gruenbacher if (!mdev) 37734a76b161SAndreas Gruenbacher return -EIO; 37744a76b161SAndreas Gruenbacher 3775b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3776b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3777b411b363SPhilipp Reisner 377825703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 37798410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3780b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 378182bc0194SAndreas Gruenbacher return 0; 3782b411b363SPhilipp Reisner } 3783b411b363SPhilipp Reisner 3784b411b363SPhilipp Reisner mask = convert_state(mask); 3785b411b363SPhilipp Reisner val = convert_state(val); 3786b411b363SPhilipp Reisner 3787b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3788b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3789047cd4a6SPhilipp Reisner 3790b411b363SPhilipp Reisner drbd_md_sync(mdev); 3791b411b363SPhilipp Reisner 379282bc0194SAndreas Gruenbacher return 0; 3793b411b363SPhilipp Reisner } 3794b411b363SPhilipp Reisner 3795e2857216SAndreas Gruenbacher static int receive_req_conn_state(struct drbd_tconn *tconn, struct packet_info *pi) 3796dfafcc8aSPhilipp Reisner { 3797e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3798dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3799dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3800dfafcc8aSPhilipp Reisner 3801dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3802dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3803dfafcc8aSPhilipp Reisner 3804dfafcc8aSPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &tconn->flags) && 3805dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3806dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 380782bc0194SAndreas Gruenbacher return 0; 3808dfafcc8aSPhilipp Reisner } 3809dfafcc8aSPhilipp Reisner 3810dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3811dfafcc8aSPhilipp Reisner val = convert_state(val); 3812dfafcc8aSPhilipp Reisner 3813778bcf2eSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3814dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3815dfafcc8aSPhilipp Reisner 381682bc0194SAndreas Gruenbacher return 0; 3817dfafcc8aSPhilipp Reisner } 3818dfafcc8aSPhilipp Reisner 38194a76b161SAndreas Gruenbacher static int receive_state(struct drbd_tconn *tconn, struct packet_info *pi) 3820b411b363SPhilipp Reisner { 38214a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3822e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 38234ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3824b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 382565d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3826b411b363SPhilipp Reisner int rv; 3827b411b363SPhilipp Reisner 38284a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 38294a76b161SAndreas Gruenbacher if (!mdev) 38304a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 38314a76b161SAndreas Gruenbacher 3832b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3833b411b363SPhilipp Reisner 3834b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3835b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3836b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3837b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3838b411b363SPhilipp Reisner } 3839b411b363SPhilipp Reisner 384087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3841b411b363SPhilipp Reisner retry: 384278bae59bSPhilipp Reisner os = ns = drbd_read_state(mdev); 384387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3844b411b363SPhilipp Reisner 3845b8853dbdSPhilipp Reisner /* If some other part of the code (asender thread, timeout) 3846b8853dbdSPhilipp Reisner * already decided to close the connection again, 3847b8853dbdSPhilipp Reisner * we must not "re-establish" it here. */ 3848b8853dbdSPhilipp Reisner if (os.conn <= C_TEAR_DOWN) 384958ffa580SLars Ellenberg return -ECONNRESET; 3850b8853dbdSPhilipp Reisner 38519bcd2521SPhilipp Reisner /* If this is the "end of sync" confirmation, usually the peer disk 38529bcd2521SPhilipp Reisner * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 38539bcd2521SPhilipp Reisner * set) resync started in PausedSyncT, or if the timing of pause-/ 38549bcd2521SPhilipp Reisner * unpause-sync events has been "just right", the peer disk may 38559bcd2521SPhilipp Reisner * transition from D_CONSISTENT to D_UP_TO_DATE as well. 38569bcd2521SPhilipp Reisner */ 38579bcd2521SPhilipp Reisner if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 38589bcd2521SPhilipp Reisner real_peer_disk == D_UP_TO_DATE && 3859e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3860e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3861e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3862e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3863e9ef7bb6SLars Ellenberg * syncing states. 3864e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3865e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3866e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3867e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3868e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3869e9ef7bb6SLars Ellenberg 3870e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3871e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3872e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3873e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3874e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3875e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3876e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 387782bc0194SAndreas Gruenbacher return 0; 3878e9ef7bb6SLars Ellenberg } 3879e9ef7bb6SLars Ellenberg } 3880e9ef7bb6SLars Ellenberg 388158ffa580SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 388258ffa580SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 388358ffa580SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 388458ffa580SLars Ellenberg ov_out_of_sync_print(mdev); 388558ffa580SLars Ellenberg drbd_resync_finished(mdev); 388658ffa580SLars Ellenberg return 0; 388758ffa580SLars Ellenberg } 388858ffa580SLars Ellenberg 3889e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3890e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3891e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3892e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3893e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3894e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3895e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3896e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3897e9ef7bb6SLars Ellenberg 38984ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 38994ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3900b411b363SPhilipp Reisner 390167531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 390267531718SPhilipp Reisner ns.conn = C_BEHIND; 390367531718SPhilipp Reisner 3904b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3905b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3906b411b363SPhilipp Reisner int cr; /* consider resync */ 3907b411b363SPhilipp Reisner 3908b411b363SPhilipp Reisner /* if we established a new connection */ 39094ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3910b411b363SPhilipp Reisner /* if we had an established connection 3911b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 39124ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3913b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 39144ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3915b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3916b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3917b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3918b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3919b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 39204ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3921b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3922b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3923b411b363SPhilipp Reisner 3924b411b363SPhilipp Reisner if (cr) 39254ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3926b411b363SPhilipp Reisner 3927b411b363SPhilipp Reisner put_ldev(mdev); 39284ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 39294ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3930b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 393182f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3932b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3933b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3934b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3935580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3936b411b363SPhilipp Reisner } else { 39378169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 393882bc0194SAndreas Gruenbacher return -EIO; 39394ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 394038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 394182bc0194SAndreas Gruenbacher return -EIO; 3942b411b363SPhilipp Reisner } 3943b411b363SPhilipp Reisner } 3944b411b363SPhilipp Reisner } 3945b411b363SPhilipp Reisner 394687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 394778bae59bSPhilipp Reisner if (os.i != drbd_read_state(mdev).i) 3948b411b363SPhilipp Reisner goto retry; 3949b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3950b411b363SPhilipp Reisner ns.peer = peer_state.role; 3951b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3952b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 39534ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3954b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 39554ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 39562aebfabbSPhilipp Reisner if (ns.pdsk == D_CONSISTENT && drbd_suspended(mdev) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3957481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 39588554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3959481c6f50SPhilipp Reisner for temporal network outages! */ 396087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3961481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 39622f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3963481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3964481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 396538fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 396682bc0194SAndreas Gruenbacher return -EIO; 3967481c6f50SPhilipp Reisner } 396865d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 396978bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 397087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3971b411b363SPhilipp Reisner 3972b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 397338fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 397482bc0194SAndreas Gruenbacher return -EIO; 3975b411b363SPhilipp Reisner } 3976b411b363SPhilipp Reisner 39774ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 39784ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3979b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3980b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3981b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3982b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3983b411b363SPhilipp Reisner drbd_send_uuids(mdev); 398443de7c85SPhilipp Reisner drbd_send_current_state(mdev); 3985b411b363SPhilipp Reisner } 3986b411b363SPhilipp Reisner } 3987b411b363SPhilipp Reisner 398808b165baSPhilipp Reisner clear_bit(DISCARD_MY_DATA, &mdev->flags); 3989b411b363SPhilipp Reisner 3990b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3991b411b363SPhilipp Reisner 399282bc0194SAndreas Gruenbacher return 0; 3993b411b363SPhilipp Reisner } 3994b411b363SPhilipp Reisner 39954a76b161SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_tconn *tconn, struct packet_info *pi) 3996b411b363SPhilipp Reisner { 39974a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3998e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 39994a76b161SAndreas Gruenbacher 40004a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 40014a76b161SAndreas Gruenbacher if (!mdev) 40024a76b161SAndreas Gruenbacher return -EIO; 4003b411b363SPhilipp Reisner 4004b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 4005b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 4006c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 4007b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 4008b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 4009b411b363SPhilipp Reisner 4010b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 4011b411b363SPhilipp Reisner 4012b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4013b411b363SPhilipp Reisner _not_ be rotated into the history */ 4014b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 4015b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 4016b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 4017b411b363SPhilipp Reisner 401862b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 4019b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 4020b411b363SPhilipp Reisner 4021b411b363SPhilipp Reisner put_ldev(mdev); 4022b411b363SPhilipp Reisner } else 4023b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 4024b411b363SPhilipp Reisner 402582bc0194SAndreas Gruenbacher return 0; 4026b411b363SPhilipp Reisner } 4027b411b363SPhilipp Reisner 40282c46407dSAndreas Gruenbacher /** 40292c46407dSAndreas Gruenbacher * receive_bitmap_plain 40302c46407dSAndreas Gruenbacher * 40312c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40322c46407dSAndreas Gruenbacher * code upon failure. 40332c46407dSAndreas Gruenbacher */ 40342c46407dSAndreas Gruenbacher static int 403550d0b1adSAndreas Gruenbacher receive_bitmap_plain(struct drbd_conf *mdev, unsigned int size, 4036e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4037b411b363SPhilipp Reisner { 403850d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 403950d0b1adSAndreas Gruenbacher drbd_header_size(mdev->tconn); 4040e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 404150d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4042e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 40432c46407dSAndreas Gruenbacher int err; 4044b411b363SPhilipp Reisner 404550d0b1adSAndreas Gruenbacher if (want != size) { 404650d0b1adSAndreas Gruenbacher dev_err(DEV, "%s:want (%u) != size (%u)\n", __func__, want, size); 40472c46407dSAndreas Gruenbacher return -EIO; 4048b411b363SPhilipp Reisner } 4049b411b363SPhilipp Reisner if (want == 0) 40502c46407dSAndreas Gruenbacher return 0; 4051e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, want); 405282bc0194SAndreas Gruenbacher if (err) 40532c46407dSAndreas Gruenbacher return err; 4054b411b363SPhilipp Reisner 4055e658983aSAndreas Gruenbacher drbd_bm_merge_lel(mdev, c->word_offset, num_words, p); 4056b411b363SPhilipp Reisner 4057b411b363SPhilipp Reisner c->word_offset += num_words; 4058b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4059b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4060b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4061b411b363SPhilipp Reisner 40622c46407dSAndreas Gruenbacher return 1; 4063b411b363SPhilipp Reisner } 4064b411b363SPhilipp Reisner 4065a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4066a02d1240SAndreas Gruenbacher { 4067a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4068a02d1240SAndreas Gruenbacher } 4069a02d1240SAndreas Gruenbacher 4070a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4071a02d1240SAndreas Gruenbacher { 4072a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4073a02d1240SAndreas Gruenbacher } 4074a02d1240SAndreas Gruenbacher 4075a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4076a02d1240SAndreas Gruenbacher { 4077a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4078a02d1240SAndreas Gruenbacher } 4079a02d1240SAndreas Gruenbacher 40802c46407dSAndreas Gruenbacher /** 40812c46407dSAndreas Gruenbacher * recv_bm_rle_bits 40822c46407dSAndreas Gruenbacher * 40832c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40842c46407dSAndreas Gruenbacher * code upon failure. 40852c46407dSAndreas Gruenbacher */ 40862c46407dSAndreas Gruenbacher static int 4087b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 4088b411b363SPhilipp Reisner struct p_compressed_bm *p, 4089c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4090c6d25cfeSPhilipp Reisner unsigned int len) 4091b411b363SPhilipp Reisner { 4092b411b363SPhilipp Reisner struct bitstream bs; 4093b411b363SPhilipp Reisner u64 look_ahead; 4094b411b363SPhilipp Reisner u64 rl; 4095b411b363SPhilipp Reisner u64 tmp; 4096b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4097b411b363SPhilipp Reisner unsigned long e; 4098a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4099b411b363SPhilipp Reisner int have; 4100b411b363SPhilipp Reisner int bits; 4101b411b363SPhilipp Reisner 4102a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4103b411b363SPhilipp Reisner 4104b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4105b411b363SPhilipp Reisner if (bits < 0) 41062c46407dSAndreas Gruenbacher return -EIO; 4107b411b363SPhilipp Reisner 4108b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4109b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4110b411b363SPhilipp Reisner if (bits <= 0) 41112c46407dSAndreas Gruenbacher return -EIO; 4112b411b363SPhilipp Reisner 4113b411b363SPhilipp Reisner if (toggle) { 4114b411b363SPhilipp Reisner e = s + rl -1; 4115b411b363SPhilipp Reisner if (e >= c->bm_bits) { 4116b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 41172c46407dSAndreas Gruenbacher return -EIO; 4118b411b363SPhilipp Reisner } 4119b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 4120b411b363SPhilipp Reisner } 4121b411b363SPhilipp Reisner 4122b411b363SPhilipp Reisner if (have < bits) { 4123b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4124b411b363SPhilipp Reisner have, bits, look_ahead, 4125b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4126b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 41272c46407dSAndreas Gruenbacher return -EIO; 4128b411b363SPhilipp Reisner } 4129b411b363SPhilipp Reisner look_ahead >>= bits; 4130b411b363SPhilipp Reisner have -= bits; 4131b411b363SPhilipp Reisner 4132b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4133b411b363SPhilipp Reisner if (bits < 0) 41342c46407dSAndreas Gruenbacher return -EIO; 4135b411b363SPhilipp Reisner look_ahead |= tmp << have; 4136b411b363SPhilipp Reisner have += bits; 4137b411b363SPhilipp Reisner } 4138b411b363SPhilipp Reisner 4139b411b363SPhilipp Reisner c->bit_offset = s; 4140b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4141b411b363SPhilipp Reisner 41422c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4143b411b363SPhilipp Reisner } 4144b411b363SPhilipp Reisner 41452c46407dSAndreas Gruenbacher /** 41462c46407dSAndreas Gruenbacher * decode_bitmap_c 41472c46407dSAndreas Gruenbacher * 41482c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 41492c46407dSAndreas Gruenbacher * code upon failure. 41502c46407dSAndreas Gruenbacher */ 41512c46407dSAndreas Gruenbacher static int 4152b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 4153b411b363SPhilipp Reisner struct p_compressed_bm *p, 4154c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4155c6d25cfeSPhilipp Reisner unsigned int len) 4156b411b363SPhilipp Reisner { 4157a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 4158e658983aSAndreas Gruenbacher return recv_bm_rle_bits(mdev, p, c, len - sizeof(*p)); 4159b411b363SPhilipp Reisner 4160b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4161b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4162b411b363SPhilipp Reisner * during all our tests. */ 4163b411b363SPhilipp Reisner 4164b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 416538fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 41662c46407dSAndreas Gruenbacher return -EIO; 4167b411b363SPhilipp Reisner } 4168b411b363SPhilipp Reisner 4169b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 4170b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4171b411b363SPhilipp Reisner { 4172b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 417350d0b1adSAndreas Gruenbacher unsigned int header_size = drbd_header_size(mdev->tconn); 417450d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 417550d0b1adSAndreas Gruenbacher unsigned int plain = 417650d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 417750d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 417850d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 417950d0b1adSAndreas Gruenbacher unsigned int r; 4180b411b363SPhilipp Reisner 4181b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4182b411b363SPhilipp Reisner if (total == 0) 4183b411b363SPhilipp Reisner return; 4184b411b363SPhilipp Reisner 4185b411b363SPhilipp Reisner /* don't report if not compressed */ 4186b411b363SPhilipp Reisner if (total >= plain) 4187b411b363SPhilipp Reisner return; 4188b411b363SPhilipp Reisner 4189b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4190b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4191b411b363SPhilipp Reisner : (1000 * total / plain); 4192b411b363SPhilipp Reisner 4193b411b363SPhilipp Reisner if (r > 1000) 4194b411b363SPhilipp Reisner r = 1000; 4195b411b363SPhilipp Reisner 4196b411b363SPhilipp Reisner r = 1000 - r; 4197b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4198b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4199b411b363SPhilipp Reisner direction, 4200b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4201b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4202b411b363SPhilipp Reisner total, r/10, r % 10); 4203b411b363SPhilipp Reisner } 4204b411b363SPhilipp Reisner 4205b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4206b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4207b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4208b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4209b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4210b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4211b411b363SPhilipp Reisner 4212b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 42134a76b161SAndreas Gruenbacher static int receive_bitmap(struct drbd_tconn *tconn, struct packet_info *pi) 4214b411b363SPhilipp Reisner { 42154a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4216b411b363SPhilipp Reisner struct bm_xfer_ctx c; 42172c46407dSAndreas Gruenbacher int err; 42184a76b161SAndreas Gruenbacher 42194a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 42204a76b161SAndreas Gruenbacher if (!mdev) 42214a76b161SAndreas Gruenbacher return -EIO; 4222b411b363SPhilipp Reisner 422320ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 422420ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 422520ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4226b411b363SPhilipp Reisner 4227b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4228b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 4229b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 4230b411b363SPhilipp Reisner }; 4231b411b363SPhilipp Reisner 42322c46407dSAndreas Gruenbacher for(;;) { 4233e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 4234e658983aSAndreas Gruenbacher err = receive_bitmap_plain(mdev, pi->size, pi->data, &c); 4235e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4236b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4237b411b363SPhilipp Reisner * and the feature is enabled! */ 4238e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4239b411b363SPhilipp Reisner 424050d0b1adSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(tconn)) { 4241b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 424282bc0194SAndreas Gruenbacher err = -EIO; 4243b411b363SPhilipp Reisner goto out; 4244b411b363SPhilipp Reisner } 4245e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4246e2857216SAndreas Gruenbacher dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", pi->size); 424782bc0194SAndreas Gruenbacher err = -EIO; 424878fcbdaeSAndreas Gruenbacher goto out; 4249b411b363SPhilipp Reisner } 4250e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, pi->size); 4251e658983aSAndreas Gruenbacher if (err) 4252e658983aSAndreas Gruenbacher goto out; 4253e2857216SAndreas Gruenbacher err = decode_bitmap_c(mdev, p, &c, pi->size); 4254b411b363SPhilipp Reisner } else { 4255e2857216SAndreas Gruenbacher dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 425682bc0194SAndreas Gruenbacher err = -EIO; 4257b411b363SPhilipp Reisner goto out; 4258b411b363SPhilipp Reisner } 4259b411b363SPhilipp Reisner 4260e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 426150d0b1adSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(tconn) + pi->size; 4262b411b363SPhilipp Reisner 42632c46407dSAndreas Gruenbacher if (err <= 0) { 42642c46407dSAndreas Gruenbacher if (err < 0) 42652c46407dSAndreas Gruenbacher goto out; 4266b411b363SPhilipp Reisner break; 42672c46407dSAndreas Gruenbacher } 4268e2857216SAndreas Gruenbacher err = drbd_recv_header(mdev->tconn, pi); 426982bc0194SAndreas Gruenbacher if (err) 4270b411b363SPhilipp Reisner goto out; 42712c46407dSAndreas Gruenbacher } 4272b411b363SPhilipp Reisner 4273b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 4274b411b363SPhilipp Reisner 4275b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 4276de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4277de1f8e4aSAndreas Gruenbacher 427882bc0194SAndreas Gruenbacher err = drbd_send_bitmap(mdev); 427982bc0194SAndreas Gruenbacher if (err) 4280b411b363SPhilipp Reisner goto out; 4281b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4282de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 4283de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 4284b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 4285b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4286b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4287b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 4288b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 4289b411b363SPhilipp Reisner } 429082bc0194SAndreas Gruenbacher err = 0; 4291b411b363SPhilipp Reisner 4292b411b363SPhilipp Reisner out: 429320ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 429482bc0194SAndreas Gruenbacher if (!err && mdev->state.conn == C_WF_BITMAP_S) 4295b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 429682bc0194SAndreas Gruenbacher return err; 4297b411b363SPhilipp Reisner } 4298b411b363SPhilipp Reisner 42994a76b161SAndreas Gruenbacher static int receive_skip(struct drbd_tconn *tconn, struct packet_info *pi) 4300b411b363SPhilipp Reisner { 43014a76b161SAndreas Gruenbacher conn_warn(tconn, "skipping unknown optional packet type %d, l: %d!\n", 4302e2857216SAndreas Gruenbacher pi->cmd, pi->size); 43032de876efSPhilipp Reisner 43044a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 43052de876efSPhilipp Reisner } 43062de876efSPhilipp Reisner 43074a76b161SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_tconn *tconn, struct packet_info *pi) 4308b411b363SPhilipp Reisner { 4309b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4310b411b363SPhilipp Reisner * with the data requests being unplugged */ 43114a76b161SAndreas Gruenbacher drbd_tcp_quickack(tconn->data.socket); 4312b411b363SPhilipp Reisner 431382bc0194SAndreas Gruenbacher return 0; 4314b411b363SPhilipp Reisner } 4315b411b363SPhilipp Reisner 43164a76b161SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_tconn *tconn, struct packet_info *pi) 431773a01a18SPhilipp Reisner { 43184a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4319e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 43204a76b161SAndreas Gruenbacher 43214a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 43224a76b161SAndreas Gruenbacher if (!mdev) 43234a76b161SAndreas Gruenbacher return -EIO; 432473a01a18SPhilipp Reisner 4325f735e363SLars Ellenberg switch (mdev->state.conn) { 4326f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4327f735e363SLars Ellenberg case C_WF_BITMAP_T: 4328f735e363SLars Ellenberg case C_BEHIND: 4329f735e363SLars Ellenberg break; 4330f735e363SLars Ellenberg default: 4331f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4332f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 4333f735e363SLars Ellenberg } 4334f735e363SLars Ellenberg 433573a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 433673a01a18SPhilipp Reisner 433782bc0194SAndreas Gruenbacher return 0; 433873a01a18SPhilipp Reisner } 433973a01a18SPhilipp Reisner 434002918be2SPhilipp Reisner struct data_cmd { 434102918be2SPhilipp Reisner int expect_payload; 434202918be2SPhilipp Reisner size_t pkt_size; 43434a76b161SAndreas Gruenbacher int (*fn)(struct drbd_tconn *, struct packet_info *); 4344b411b363SPhilipp Reisner }; 4345b411b363SPhilipp Reisner 434602918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 43474a76b161SAndreas Gruenbacher [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 43484a76b161SAndreas Gruenbacher [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 43494a76b161SAndreas Gruenbacher [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 43504a76b161SAndreas Gruenbacher [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4351e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4352e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4353e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 43544a76b161SAndreas Gruenbacher [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 43554a76b161SAndreas Gruenbacher [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4356e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4357e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 43584a76b161SAndreas Gruenbacher [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 43594a76b161SAndreas Gruenbacher [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 43604a76b161SAndreas Gruenbacher [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 43614a76b161SAndreas Gruenbacher [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 43624a76b161SAndreas Gruenbacher [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 43634a76b161SAndreas Gruenbacher [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 43644a76b161SAndreas Gruenbacher [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 43654a76b161SAndreas Gruenbacher [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 43664a76b161SAndreas Gruenbacher [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 43674a76b161SAndreas Gruenbacher [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 43684a76b161SAndreas Gruenbacher [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 43694a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4370036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 437102918be2SPhilipp Reisner }; 437202918be2SPhilipp Reisner 4373eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 4374b411b363SPhilipp Reisner { 437577351055SPhilipp Reisner struct packet_info pi; 437602918be2SPhilipp Reisner size_t shs; /* sub header size */ 437782bc0194SAndreas Gruenbacher int err; 4378b411b363SPhilipp Reisner 4379eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 4380deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4381deebe195SAndreas Gruenbacher 4382eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 438369bc7bc3SAndreas Gruenbacher if (drbd_recv_header(tconn, &pi)) 438402918be2SPhilipp Reisner goto err_out; 438502918be2SPhilipp Reisner 4386deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 43874a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 43882fcb8f30SAndreas Gruenbacher conn_err(tconn, "Unexpected data packet %s (0x%04x)", 43892fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 439002918be2SPhilipp Reisner goto err_out; 43910b33a916SLars Ellenberg } 4392b411b363SPhilipp Reisner 4393e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4394e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 43952fcb8f30SAndreas Gruenbacher conn_err(tconn, "No payload expected %s l:%d\n", 43962fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4397c13f7e1aSLars Ellenberg goto err_out; 4398c13f7e1aSLars Ellenberg } 4399c13f7e1aSLars Ellenberg 4400c13f7e1aSLars Ellenberg if (shs) { 4401e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, pi.data, shs); 4402a5c31904SAndreas Gruenbacher if (err) 440302918be2SPhilipp Reisner goto err_out; 4404e2857216SAndreas Gruenbacher pi.size -= shs; 4405b411b363SPhilipp Reisner } 440602918be2SPhilipp Reisner 44074a76b161SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 44084a76b161SAndreas Gruenbacher if (err) { 44099f5bdc33SAndreas Gruenbacher conn_err(tconn, "error receiving %s, e: %d l: %d!\n", 44109f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 441102918be2SPhilipp Reisner goto err_out; 4412b411b363SPhilipp Reisner } 4413b411b363SPhilipp Reisner } 441482bc0194SAndreas Gruenbacher return; 441502918be2SPhilipp Reisner 441602918be2SPhilipp Reisner err_out: 4417bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4418b411b363SPhilipp Reisner } 4419b411b363SPhilipp Reisner 44200e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 4421b411b363SPhilipp Reisner { 4422b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4423b411b363SPhilipp Reisner 4424b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 44250e29d163SPhilipp Reisner barr.w.tconn = tconn; 4426b411b363SPhilipp Reisner init_completion(&barr.done); 4427d5b27b01SLars Ellenberg drbd_queue_work(&tconn->sender_work, &barr.w); 4428b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4429b411b363SPhilipp Reisner } 4430b411b363SPhilipp Reisner 443181fa2e67SPhilipp Reisner static void conn_disconnect(struct drbd_tconn *tconn) 4432b411b363SPhilipp Reisner { 4433c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 4434bbeb641cSPhilipp Reisner enum drbd_conns oc; 4435376694a0SPhilipp Reisner int vnr; 4436b411b363SPhilipp Reisner 4437bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4438b411b363SPhilipp Reisner return; 4439b411b363SPhilipp Reisner 4440b8853dbdSPhilipp Reisner /* We are about to start the cleanup after connection loss. 4441b8853dbdSPhilipp Reisner * Make sure drbd_make_request knows about that. 4442b8853dbdSPhilipp Reisner * Usually we should be in some network failure state already, 4443b8853dbdSPhilipp Reisner * but just in case we are not, we fix it up here. 4444b8853dbdSPhilipp Reisner */ 4445b8853dbdSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4446b8853dbdSPhilipp Reisner 4447b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4448360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4449360cc740SPhilipp Reisner drbd_free_sock(tconn); 4450360cc740SPhilipp Reisner 4451c141ebdaSPhilipp Reisner rcu_read_lock(); 4452c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 4453c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 4454c141ebdaSPhilipp Reisner rcu_read_unlock(); 4455c141ebdaSPhilipp Reisner drbd_disconnected(mdev); 4456c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 4457c141ebdaSPhilipp Reisner rcu_read_lock(); 4458c141ebdaSPhilipp Reisner } 4459c141ebdaSPhilipp Reisner rcu_read_unlock(); 4460c141ebdaSPhilipp Reisner 446112038a3aSPhilipp Reisner if (!list_empty(&tconn->current_epoch->list)) 446212038a3aSPhilipp Reisner conn_err(tconn, "ASSERTION FAILED: tconn->current_epoch->list not empty\n"); 446312038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 446412038a3aSPhilipp Reisner atomic_set(&tconn->current_epoch->epoch_size, 0); 4465b6dd1a89SLars Ellenberg tconn->send.seen_any_write_yet = false; 446612038a3aSPhilipp Reisner 4467360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4468360cc740SPhilipp Reisner 4469cb703454SPhilipp Reisner if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN) 4470cb703454SPhilipp Reisner conn_try_outdate_peer_async(tconn); 4471cb703454SPhilipp Reisner 4472360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4473bbeb641cSPhilipp Reisner oc = tconn->cstate; 4474bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4475376694a0SPhilipp Reisner _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4476bbeb641cSPhilipp Reisner 4477360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4478360cc740SPhilipp Reisner 4479f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4480d9cc6e23SLars Ellenberg conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4481360cc740SPhilipp Reisner } 4482360cc740SPhilipp Reisner 4483c141ebdaSPhilipp Reisner static int drbd_disconnected(struct drbd_conf *mdev) 4484360cc740SPhilipp Reisner { 4485360cc740SPhilipp Reisner unsigned int i; 4486b411b363SPhilipp Reisner 448785719573SPhilipp Reisner /* wait for current activity to cease. */ 448887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4489b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4490b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4491b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 449287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4493b411b363SPhilipp Reisner 4494b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4495b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4496b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4497b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4498b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4499b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4500b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4501b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4502b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4503b411b363SPhilipp Reisner * on the fly. */ 4504b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4505b411b363SPhilipp Reisner mdev->rs_total = 0; 4506b411b363SPhilipp Reisner mdev->rs_failed = 0; 4507b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4508b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4509b411b363SPhilipp Reisner 4510b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4511b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4512b411b363SPhilipp Reisner 4513b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4514b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4515b411b363SPhilipp Reisner * to be "canceled" */ 4516a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 4517b411b363SPhilipp Reisner 4518a990be46SAndreas Gruenbacher drbd_finish_peer_reqs(mdev); 4519b411b363SPhilipp Reisner 4520d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 4521d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 4522d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 4523d10b4ea3SPhilipp Reisner drbd_flush_workqueue(mdev); 4524d10b4ea3SPhilipp Reisner 4525b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4526b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4527b411b363SPhilipp Reisner 45282aebfabbSPhilipp Reisner if (!drbd_suspended(mdev)) 45292f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4530b411b363SPhilipp Reisner 4531b411b363SPhilipp Reisner drbd_md_sync(mdev); 4532b411b363SPhilipp Reisner 453320ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 453420ceb2b2SLars Ellenberg * if any. */ 453520ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 453620ceb2b2SLars Ellenberg 4537b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4538b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4539b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4540b411b363SPhilipp Reisner * 4541b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4542b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4543b411b363SPhilipp Reisner */ 45447721f567SAndreas Gruenbacher i = drbd_free_peer_reqs(mdev, &mdev->net_ee); 4545b411b363SPhilipp Reisner if (i) 4546b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4547435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4548435f0740SLars Ellenberg if (i) 4549435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4550b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4551b411b363SPhilipp Reisner if (i) 455245bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4553b411b363SPhilipp Reisner 4554b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4555b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4556b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4557b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4558b411b363SPhilipp Reisner 4559360cc740SPhilipp Reisner return 0; 4560b411b363SPhilipp Reisner } 4561b411b363SPhilipp Reisner 4562b411b363SPhilipp Reisner /* 4563b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4564b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4565b411b363SPhilipp Reisner * 4566b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4567b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4568b411b363SPhilipp Reisner * 4569b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4570b411b363SPhilipp Reisner */ 45716038178eSAndreas Gruenbacher static int drbd_send_features(struct drbd_tconn *tconn) 4572b411b363SPhilipp Reisner { 45739f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 45749f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4575b411b363SPhilipp Reisner 45769f5bdc33SAndreas Gruenbacher sock = &tconn->data; 45779f5bdc33SAndreas Gruenbacher p = conn_prepare_command(tconn, sock); 45789f5bdc33SAndreas Gruenbacher if (!p) 4579e8d17b01SAndreas Gruenbacher return -EIO; 4580b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4581b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4582b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 45839f5bdc33SAndreas Gruenbacher return conn_send_command(tconn, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4584b411b363SPhilipp Reisner } 4585b411b363SPhilipp Reisner 4586b411b363SPhilipp Reisner /* 4587b411b363SPhilipp Reisner * return values: 4588b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4589b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4590b411b363SPhilipp Reisner * -1 peer talks different language, 4591b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4592b411b363SPhilipp Reisner */ 45936038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn) 4594b411b363SPhilipp Reisner { 459565d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 4596e658983aSAndreas Gruenbacher struct p_connection_features *p; 4597e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 459877351055SPhilipp Reisner struct packet_info pi; 4599a5c31904SAndreas Gruenbacher int err; 4600b411b363SPhilipp Reisner 46016038178eSAndreas Gruenbacher err = drbd_send_features(tconn); 4602e8d17b01SAndreas Gruenbacher if (err) 4603b411b363SPhilipp Reisner return 0; 4604b411b363SPhilipp Reisner 460569bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 460669bc7bc3SAndreas Gruenbacher if (err) 4607b411b363SPhilipp Reisner return 0; 4608b411b363SPhilipp Reisner 46096038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 46106038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 461177351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4612b411b363SPhilipp Reisner return -1; 4613b411b363SPhilipp Reisner } 4614b411b363SPhilipp Reisner 461577351055SPhilipp Reisner if (pi.size != expect) { 46166038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures length: %u, received: %u\n", 461777351055SPhilipp Reisner expect, pi.size); 4618b411b363SPhilipp Reisner return -1; 4619b411b363SPhilipp Reisner } 4620b411b363SPhilipp Reisner 4621e658983aSAndreas Gruenbacher p = pi.data; 4622e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, p, expect); 4623a5c31904SAndreas Gruenbacher if (err) 4624b411b363SPhilipp Reisner return 0; 4625b411b363SPhilipp Reisner 4626b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4627b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4628b411b363SPhilipp Reisner if (p->protocol_max == 0) 4629b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4630b411b363SPhilipp Reisner 4631b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4632b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4633b411b363SPhilipp Reisner goto incompat; 4634b411b363SPhilipp Reisner 463565d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4636b411b363SPhilipp Reisner 463765d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 463865d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4639b411b363SPhilipp Reisner 4640b411b363SPhilipp Reisner return 1; 4641b411b363SPhilipp Reisner 4642b411b363SPhilipp Reisner incompat: 464365d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4644b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4645b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4646b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4647b411b363SPhilipp Reisner return -1; 4648b411b363SPhilipp Reisner } 4649b411b363SPhilipp Reisner 4650b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 465113e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4652b411b363SPhilipp Reisner { 4653b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4654b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4655b10d96cbSJohannes Thoma return -1; 4656b411b363SPhilipp Reisner } 4657b411b363SPhilipp Reisner #else 4658b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4659b10d96cbSJohannes Thoma 4660b10d96cbSJohannes Thoma /* Return value: 4661b10d96cbSJohannes Thoma 1 - auth succeeded, 4662b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4663b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4664b10d96cbSJohannes Thoma */ 4665b10d96cbSJohannes Thoma 466613e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4667b411b363SPhilipp Reisner { 46689f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4669b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4670b411b363SPhilipp Reisner struct scatterlist sg; 4671b411b363SPhilipp Reisner char *response = NULL; 4672b411b363SPhilipp Reisner char *right_response = NULL; 4673b411b363SPhilipp Reisner char *peers_ch = NULL; 467444ed167dSPhilipp Reisner unsigned int key_len; 467544ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4676b411b363SPhilipp Reisner unsigned int resp_size; 4677b411b363SPhilipp Reisner struct hash_desc desc; 467877351055SPhilipp Reisner struct packet_info pi; 467944ed167dSPhilipp Reisner struct net_conf *nc; 468069bc7bc3SAndreas Gruenbacher int err, rv; 4681b411b363SPhilipp Reisner 46829f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 46839f5bdc33SAndreas Gruenbacher 468444ed167dSPhilipp Reisner rcu_read_lock(); 468544ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 468644ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 468744ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 468844ed167dSPhilipp Reisner rcu_read_unlock(); 468944ed167dSPhilipp Reisner 469013e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4691b411b363SPhilipp Reisner desc.flags = 0; 4692b411b363SPhilipp Reisner 469344ed167dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, (u8 *)secret, key_len); 4694b411b363SPhilipp Reisner if (rv) { 469513e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4696b10d96cbSJohannes Thoma rv = -1; 4697b411b363SPhilipp Reisner goto fail; 4698b411b363SPhilipp Reisner } 4699b411b363SPhilipp Reisner 4700b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4701b411b363SPhilipp Reisner 47029f5bdc33SAndreas Gruenbacher sock = &tconn->data; 47039f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 47049f5bdc33SAndreas Gruenbacher rv = 0; 47059f5bdc33SAndreas Gruenbacher goto fail; 47069f5bdc33SAndreas Gruenbacher } 4707e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_CHALLENGE, 0, 47089f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4709b411b363SPhilipp Reisner if (!rv) 4710b411b363SPhilipp Reisner goto fail; 4711b411b363SPhilipp Reisner 471269bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 471369bc7bc3SAndreas Gruenbacher if (err) { 471469bc7bc3SAndreas Gruenbacher rv = 0; 4715b411b363SPhilipp Reisner goto fail; 471669bc7bc3SAndreas Gruenbacher } 4717b411b363SPhilipp Reisner 471877351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 471913e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 472077351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4721b411b363SPhilipp Reisner rv = 0; 4722b411b363SPhilipp Reisner goto fail; 4723b411b363SPhilipp Reisner } 4724b411b363SPhilipp Reisner 472577351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 472613e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4727b10d96cbSJohannes Thoma rv = -1; 4728b411b363SPhilipp Reisner goto fail; 4729b411b363SPhilipp Reisner } 4730b411b363SPhilipp Reisner 473177351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4732b411b363SPhilipp Reisner if (peers_ch == NULL) { 473313e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4734b10d96cbSJohannes Thoma rv = -1; 4735b411b363SPhilipp Reisner goto fail; 4736b411b363SPhilipp Reisner } 4737b411b363SPhilipp Reisner 4738a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, peers_ch, pi.size); 4739a5c31904SAndreas Gruenbacher if (err) { 4740b411b363SPhilipp Reisner rv = 0; 4741b411b363SPhilipp Reisner goto fail; 4742b411b363SPhilipp Reisner } 4743b411b363SPhilipp Reisner 474413e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4745b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4746b411b363SPhilipp Reisner if (response == NULL) { 474713e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4748b10d96cbSJohannes Thoma rv = -1; 4749b411b363SPhilipp Reisner goto fail; 4750b411b363SPhilipp Reisner } 4751b411b363SPhilipp Reisner 4752b411b363SPhilipp Reisner sg_init_table(&sg, 1); 475377351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4754b411b363SPhilipp Reisner 4755b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4756b411b363SPhilipp Reisner if (rv) { 475713e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4758b10d96cbSJohannes Thoma rv = -1; 4759b411b363SPhilipp Reisner goto fail; 4760b411b363SPhilipp Reisner } 4761b411b363SPhilipp Reisner 47629f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 47639f5bdc33SAndreas Gruenbacher rv = 0; 47649f5bdc33SAndreas Gruenbacher goto fail; 47659f5bdc33SAndreas Gruenbacher } 4766e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_RESPONSE, 0, 47679f5bdc33SAndreas Gruenbacher response, resp_size); 4768b411b363SPhilipp Reisner if (!rv) 4769b411b363SPhilipp Reisner goto fail; 4770b411b363SPhilipp Reisner 477169bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 477269bc7bc3SAndreas Gruenbacher if (err) { 477369bc7bc3SAndreas Gruenbacher rv = 0; 4774b411b363SPhilipp Reisner goto fail; 477569bc7bc3SAndreas Gruenbacher } 4776b411b363SPhilipp Reisner 477777351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 477813e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 477977351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4780b411b363SPhilipp Reisner rv = 0; 4781b411b363SPhilipp Reisner goto fail; 4782b411b363SPhilipp Reisner } 4783b411b363SPhilipp Reisner 478477351055SPhilipp Reisner if (pi.size != resp_size) { 478513e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4786b411b363SPhilipp Reisner rv = 0; 4787b411b363SPhilipp Reisner goto fail; 4788b411b363SPhilipp Reisner } 4789b411b363SPhilipp Reisner 4790a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, response , resp_size); 4791a5c31904SAndreas Gruenbacher if (err) { 4792b411b363SPhilipp Reisner rv = 0; 4793b411b363SPhilipp Reisner goto fail; 4794b411b363SPhilipp Reisner } 4795b411b363SPhilipp Reisner 4796b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 47972d1ee87dSJulia Lawall if (right_response == NULL) { 479813e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4799b10d96cbSJohannes Thoma rv = -1; 4800b411b363SPhilipp Reisner goto fail; 4801b411b363SPhilipp Reisner } 4802b411b363SPhilipp Reisner 4803b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4804b411b363SPhilipp Reisner 4805b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4806b411b363SPhilipp Reisner if (rv) { 480713e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4808b10d96cbSJohannes Thoma rv = -1; 4809b411b363SPhilipp Reisner goto fail; 4810b411b363SPhilipp Reisner } 4811b411b363SPhilipp Reisner 4812b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4813b411b363SPhilipp Reisner 4814b411b363SPhilipp Reisner if (rv) 481544ed167dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes HMAC\n", 481644ed167dSPhilipp Reisner resp_size); 4817b10d96cbSJohannes Thoma else 4818b10d96cbSJohannes Thoma rv = -1; 4819b411b363SPhilipp Reisner 4820b411b363SPhilipp Reisner fail: 4821b411b363SPhilipp Reisner kfree(peers_ch); 4822b411b363SPhilipp Reisner kfree(response); 4823b411b363SPhilipp Reisner kfree(right_response); 4824b411b363SPhilipp Reisner 4825b411b363SPhilipp Reisner return rv; 4826b411b363SPhilipp Reisner } 4827b411b363SPhilipp Reisner #endif 4828b411b363SPhilipp Reisner 4829b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4830b411b363SPhilipp Reisner { 4831392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4832b411b363SPhilipp Reisner int h; 4833b411b363SPhilipp Reisner 48344d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4835b411b363SPhilipp Reisner 4836b411b363SPhilipp Reisner do { 483781fa2e67SPhilipp Reisner h = conn_connect(tconn); 4838b411b363SPhilipp Reisner if (h == 0) { 483981fa2e67SPhilipp Reisner conn_disconnect(tconn); 484020ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4841b411b363SPhilipp Reisner } 4842b411b363SPhilipp Reisner if (h == -1) { 48434d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4844bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4845b411b363SPhilipp Reisner } 4846b411b363SPhilipp Reisner } while (h == 0); 4847b411b363SPhilipp Reisner 484891fd4dadSPhilipp Reisner if (h > 0) 48494d641dd7SPhilipp Reisner drbdd(tconn); 4850b411b363SPhilipp Reisner 485181fa2e67SPhilipp Reisner conn_disconnect(tconn); 4852b411b363SPhilipp Reisner 48534d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4854b411b363SPhilipp Reisner return 0; 4855b411b363SPhilipp Reisner } 4856b411b363SPhilipp Reisner 4857b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4858b411b363SPhilipp Reisner 4859e05e1e59SAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4860b411b363SPhilipp Reisner { 4861e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4862b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4863b411b363SPhilipp Reisner 4864fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4865fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4866fc3b10a4SPhilipp Reisner } else { 4867fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4868fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4869fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4870fc3b10a4SPhilipp Reisner } 4871fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4872e4f78edeSPhilipp Reisner 48732735a594SAndreas Gruenbacher return 0; 4874fc3b10a4SPhilipp Reisner } 4875e4f78edeSPhilipp Reisner 48761952e916SAndreas Gruenbacher static int got_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4877e4f78edeSPhilipp Reisner { 48781952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4879e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4880e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4881e4f78edeSPhilipp Reisner 48821952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48831952e916SAndreas Gruenbacher if (!mdev) 48842735a594SAndreas Gruenbacher return -EIO; 48851952e916SAndreas Gruenbacher 48864d0fc3fdSPhilipp Reisner if (test_bit(CONN_WD_ST_CHG_REQ, &tconn->flags)) { 48874d0fc3fdSPhilipp Reisner D_ASSERT(tconn->agreed_pro_version < 100); 48884d0fc3fdSPhilipp Reisner return got_conn_RqSReply(tconn, pi); 48894d0fc3fdSPhilipp Reisner } 48904d0fc3fdSPhilipp Reisner 4891e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4892e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4893e4f78edeSPhilipp Reisner } else { 4894e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4895e4f78edeSPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4896e4f78edeSPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4897e4f78edeSPhilipp Reisner } 4898e4f78edeSPhilipp Reisner wake_up(&mdev->state_wait); 4899e4f78edeSPhilipp Reisner 49002735a594SAndreas Gruenbacher return 0; 4901b411b363SPhilipp Reisner } 4902b411b363SPhilipp Reisner 4903e05e1e59SAndreas Gruenbacher static int got_Ping(struct drbd_tconn *tconn, struct packet_info *pi) 4904b411b363SPhilipp Reisner { 49052735a594SAndreas Gruenbacher return drbd_send_ping_ack(tconn); 4906b411b363SPhilipp Reisner 4907b411b363SPhilipp Reisner } 4908b411b363SPhilipp Reisner 4909e05e1e59SAndreas Gruenbacher static int got_PingAck(struct drbd_tconn *tconn, struct packet_info *pi) 4910b411b363SPhilipp Reisner { 4911b411b363SPhilipp Reisner /* restore idle timeout */ 49122a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 49132a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 49142a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4915b411b363SPhilipp Reisner 49162735a594SAndreas Gruenbacher return 0; 4917b411b363SPhilipp Reisner } 4918b411b363SPhilipp Reisner 49191952e916SAndreas Gruenbacher static int got_IsInSync(struct drbd_tconn *tconn, struct packet_info *pi) 4920b411b363SPhilipp Reisner { 49211952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4922e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4923b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4924b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4925b411b363SPhilipp Reisner 49261952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49271952e916SAndreas Gruenbacher if (!mdev) 49282735a594SAndreas Gruenbacher return -EIO; 49291952e916SAndreas Gruenbacher 493031890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4931b411b363SPhilipp Reisner 4932b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4933b411b363SPhilipp Reisner 49341d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4935b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4936b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4937b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4938b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 49391d53f09eSLars Ellenberg put_ldev(mdev); 49401d53f09eSLars Ellenberg } 4941b411b363SPhilipp Reisner dec_rs_pending(mdev); 4942778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4943b411b363SPhilipp Reisner 49442735a594SAndreas Gruenbacher return 0; 4945b411b363SPhilipp Reisner } 4946b411b363SPhilipp Reisner 4947bc9c5c41SAndreas Gruenbacher static int 4948bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4949bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4950bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4951b411b363SPhilipp Reisner { 4952b411b363SPhilipp Reisner struct drbd_request *req; 4953b411b363SPhilipp Reisner struct bio_and_error m; 4954b411b363SPhilipp Reisner 495587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4956bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4957b411b363SPhilipp Reisner if (unlikely(!req)) { 495887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 495985997675SAndreas Gruenbacher return -EIO; 4960b411b363SPhilipp Reisner } 4961b411b363SPhilipp Reisner __req_mod(req, what, &m); 496287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4963b411b363SPhilipp Reisner 4964b411b363SPhilipp Reisner if (m.bio) 4965b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 496685997675SAndreas Gruenbacher return 0; 4967b411b363SPhilipp Reisner } 4968b411b363SPhilipp Reisner 49691952e916SAndreas Gruenbacher static int got_BlockAck(struct drbd_tconn *tconn, struct packet_info *pi) 4970b411b363SPhilipp Reisner { 49711952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4972e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4973b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4974b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4975b411b363SPhilipp Reisner enum drbd_req_event what; 4976b411b363SPhilipp Reisner 49771952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49781952e916SAndreas Gruenbacher if (!mdev) 49792735a594SAndreas Gruenbacher return -EIO; 49801952e916SAndreas Gruenbacher 4981b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4982b411b363SPhilipp Reisner 4983579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4984b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4985b411b363SPhilipp Reisner dec_rs_pending(mdev); 49862735a594SAndreas Gruenbacher return 0; 4987b411b363SPhilipp Reisner } 4988e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4989b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 49908554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4991b411b363SPhilipp Reisner break; 4992b411b363SPhilipp Reisner case P_WRITE_ACK: 49938554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4994b411b363SPhilipp Reisner break; 4995b411b363SPhilipp Reisner case P_RECV_ACK: 49968554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4997b411b363SPhilipp Reisner break; 49987be8da07SAndreas Gruenbacher case P_DISCARD_WRITE: 49997be8da07SAndreas Gruenbacher what = DISCARD_WRITE; 50007be8da07SAndreas Gruenbacher break; 50017be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 50027be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5003b411b363SPhilipp Reisner break; 5004b411b363SPhilipp Reisner default: 50052735a594SAndreas Gruenbacher BUG(); 5006b411b363SPhilipp Reisner } 5007b411b363SPhilipp Reisner 50082735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 5009bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 5010bc9c5c41SAndreas Gruenbacher what, false); 5011b411b363SPhilipp Reisner } 5012b411b363SPhilipp Reisner 50131952e916SAndreas Gruenbacher static int got_NegAck(struct drbd_tconn *tconn, struct packet_info *pi) 5014b411b363SPhilipp Reisner { 50151952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5016e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5017b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 50182deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 501985997675SAndreas Gruenbacher int err; 5020b411b363SPhilipp Reisner 50211952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50221952e916SAndreas Gruenbacher if (!mdev) 50232735a594SAndreas Gruenbacher return -EIO; 50241952e916SAndreas Gruenbacher 5025b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5026b411b363SPhilipp Reisner 5027579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5028b411b363SPhilipp Reisner dec_rs_pending(mdev); 5029b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 50302735a594SAndreas Gruenbacher return 0; 5031b411b363SPhilipp Reisner } 50322deb8336SPhilipp Reisner 503385997675SAndreas Gruenbacher err = validate_req_change_req_state(mdev, p->block_id, sector, 5034bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 5035303d1448SPhilipp Reisner NEG_ACKED, true); 503685997675SAndreas Gruenbacher if (err) { 50372deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 50382deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5039c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 50402deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 50412deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 5042c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 50432deb8336SPhilipp Reisner } 50442735a594SAndreas Gruenbacher return 0; 5045b411b363SPhilipp Reisner } 5046b411b363SPhilipp Reisner 50471952e916SAndreas Gruenbacher static int got_NegDReply(struct drbd_tconn *tconn, struct packet_info *pi) 5048b411b363SPhilipp Reisner { 50491952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5050e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5051b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5052b411b363SPhilipp Reisner 50531952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50541952e916SAndreas Gruenbacher if (!mdev) 50552735a594SAndreas Gruenbacher return -EIO; 50561952e916SAndreas Gruenbacher 5057b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 50587be8da07SAndreas Gruenbacher 5059380207d0SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u.\n", 5060b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5061b411b363SPhilipp Reisner 50622735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 5063bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 50648554df1cSAndreas Gruenbacher NEG_ACKED, false); 5065b411b363SPhilipp Reisner } 5066b411b363SPhilipp Reisner 50671952e916SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_tconn *tconn, struct packet_info *pi) 5068b411b363SPhilipp Reisner { 50691952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5070b411b363SPhilipp Reisner sector_t sector; 5071b411b363SPhilipp Reisner int size; 5072e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 50731952e916SAndreas Gruenbacher 50741952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50751952e916SAndreas Gruenbacher if (!mdev) 50762735a594SAndreas Gruenbacher return -EIO; 5077b411b363SPhilipp Reisner 5078b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5079b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5080b411b363SPhilipp Reisner 5081b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5082b411b363SPhilipp Reisner 5083b411b363SPhilipp Reisner dec_rs_pending(mdev); 5084b411b363SPhilipp Reisner 5085b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 5086b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 5087e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5088d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5089b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 5090d612d309SPhilipp Reisner case P_RS_CANCEL: 5091d612d309SPhilipp Reisner break; 5092d612d309SPhilipp Reisner default: 50932735a594SAndreas Gruenbacher BUG(); 5094d612d309SPhilipp Reisner } 5095b411b363SPhilipp Reisner put_ldev(mdev); 5096b411b363SPhilipp Reisner } 5097b411b363SPhilipp Reisner 50982735a594SAndreas Gruenbacher return 0; 5099b411b363SPhilipp Reisner } 5100b411b363SPhilipp Reisner 51011952e916SAndreas Gruenbacher static int got_BarrierAck(struct drbd_tconn *tconn, struct packet_info *pi) 5102b411b363SPhilipp Reisner { 5103e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 51049ed57dcbSLars Ellenberg struct drbd_conf *mdev; 51059ed57dcbSLars Ellenberg int vnr; 51061952e916SAndreas Gruenbacher 51079ed57dcbSLars Ellenberg tl_release(tconn, p->barrier, be32_to_cpu(p->set_size)); 5108b411b363SPhilipp Reisner 51099ed57dcbSLars Ellenberg rcu_read_lock(); 51109ed57dcbSLars Ellenberg idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5111c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 5112c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 511336baf611SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->flags)) { 5114370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 5115370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 5116c4752ef1SPhilipp Reisner } 51179ed57dcbSLars Ellenberg } 51189ed57dcbSLars Ellenberg rcu_read_unlock(); 5119c4752ef1SPhilipp Reisner 51202735a594SAndreas Gruenbacher return 0; 5121b411b363SPhilipp Reisner } 5122b411b363SPhilipp Reisner 51231952e916SAndreas Gruenbacher static int got_OVResult(struct drbd_tconn *tconn, struct packet_info *pi) 5124b411b363SPhilipp Reisner { 51251952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5126e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5127b411b363SPhilipp Reisner struct drbd_work *w; 5128b411b363SPhilipp Reisner sector_t sector; 5129b411b363SPhilipp Reisner int size; 5130b411b363SPhilipp Reisner 51311952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 51321952e916SAndreas Gruenbacher if (!mdev) 51332735a594SAndreas Gruenbacher return -EIO; 51341952e916SAndreas Gruenbacher 5135b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5136b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5137b411b363SPhilipp Reisner 5138b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5139b411b363SPhilipp Reisner 5140b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 51418f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 5142b411b363SPhilipp Reisner else 51438f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5144b411b363SPhilipp Reisner 51451d53f09eSLars Ellenberg if (!get_ldev(mdev)) 51462735a594SAndreas Gruenbacher return 0; 51471d53f09eSLars Ellenberg 5148b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 5149b411b363SPhilipp Reisner dec_rs_pending(mdev); 5150b411b363SPhilipp Reisner 5151ea5442afSLars Ellenberg --mdev->ov_left; 5152ea5442afSLars Ellenberg 5153ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5154ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 5155ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 5156ea5442afSLars Ellenberg 5157ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 5158b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 5159b411b363SPhilipp Reisner if (w) { 5160b411b363SPhilipp Reisner w->cb = w_ov_finished; 5161a21e9298SPhilipp Reisner w->mdev = mdev; 5162d5b27b01SLars Ellenberg drbd_queue_work(&mdev->tconn->sender_work, w); 5163b411b363SPhilipp Reisner } else { 5164b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 51658f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5166b411b363SPhilipp Reisner drbd_resync_finished(mdev); 5167b411b363SPhilipp Reisner } 5168b411b363SPhilipp Reisner } 51691d53f09eSLars Ellenberg put_ldev(mdev); 51702735a594SAndreas Gruenbacher return 0; 5171b411b363SPhilipp Reisner } 5172b411b363SPhilipp Reisner 51731952e916SAndreas Gruenbacher static int got_skip(struct drbd_tconn *tconn, struct packet_info *pi) 51740ced55a3SPhilipp Reisner { 51752735a594SAndreas Gruenbacher return 0; 51760ced55a3SPhilipp Reisner } 51770ced55a3SPhilipp Reisner 5178a990be46SAndreas Gruenbacher static int tconn_finish_peer_reqs(struct drbd_tconn *tconn) 517932862ec7SPhilipp Reisner { 5180082a3439SPhilipp Reisner struct drbd_conf *mdev; 5181c141ebdaSPhilipp Reisner int vnr, not_empty = 0; 518232862ec7SPhilipp Reisner 518332862ec7SPhilipp Reisner do { 518432862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 518532862ec7SPhilipp Reisner flush_signals(current); 5186c141ebdaSPhilipp Reisner 5187c141ebdaSPhilipp Reisner rcu_read_lock(); 5188c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5189c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 5190c141ebdaSPhilipp Reisner rcu_read_unlock(); 5191d3fcb490SPhilipp Reisner if (drbd_finish_peer_reqs(mdev)) { 5192c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5193c141ebdaSPhilipp Reisner return 1; 5194082a3439SPhilipp Reisner } 5195c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5196c141ebdaSPhilipp Reisner rcu_read_lock(); 5197d3fcb490SPhilipp Reisner } 519832862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 5199082a3439SPhilipp Reisner 5200082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 5201c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5202082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 5203082a3439SPhilipp Reisner if (not_empty) 5204082a3439SPhilipp Reisner break; 5205082a3439SPhilipp Reisner } 5206082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 5207c141ebdaSPhilipp Reisner rcu_read_unlock(); 520832862ec7SPhilipp Reisner } while (not_empty); 520932862ec7SPhilipp Reisner 521032862ec7SPhilipp Reisner return 0; 521132862ec7SPhilipp Reisner } 521232862ec7SPhilipp Reisner 52137201b972SAndreas Gruenbacher struct asender_cmd { 52147201b972SAndreas Gruenbacher size_t pkt_size; 52151952e916SAndreas Gruenbacher int (*fn)(struct drbd_tconn *tconn, struct packet_info *); 52167201b972SAndreas Gruenbacher }; 52177201b972SAndreas Gruenbacher 52187201b972SAndreas Gruenbacher static struct asender_cmd asender_tbl[] = { 5219e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5220e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 52211952e916SAndreas Gruenbacher [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 52221952e916SAndreas Gruenbacher [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 52231952e916SAndreas Gruenbacher [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 52241952e916SAndreas Gruenbacher [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 52251952e916SAndreas Gruenbacher [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 52261952e916SAndreas Gruenbacher [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 52271952e916SAndreas Gruenbacher [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 52281952e916SAndreas Gruenbacher [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 52291952e916SAndreas Gruenbacher [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 52301952e916SAndreas Gruenbacher [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 52311952e916SAndreas Gruenbacher [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 52321952e916SAndreas Gruenbacher [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 52331952e916SAndreas Gruenbacher [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 52341952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 52351952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 52367201b972SAndreas Gruenbacher }; 52377201b972SAndreas Gruenbacher 5238b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5239b411b363SPhilipp Reisner { 5240392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 5241b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 524277351055SPhilipp Reisner struct packet_info pi; 5243257d0af6SPhilipp Reisner int rv; 5244e658983aSAndreas Gruenbacher void *buf = tconn->meta.rbuf; 5245b411b363SPhilipp Reisner int received = 0; 524652b061a4SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 524752b061a4SAndreas Gruenbacher int expect = header_size; 524844ed167dSPhilipp Reisner bool ping_timeout_active = false; 524944ed167dSPhilipp Reisner struct net_conf *nc; 5250bb77d34eSAndreas Gruenbacher int ping_timeo, tcp_cork, ping_int; 5251b411b363SPhilipp Reisner 5252b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 5253b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 5254b411b363SPhilipp Reisner 5255e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 525680822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 525744ed167dSPhilipp Reisner 525844ed167dSPhilipp Reisner rcu_read_lock(); 525944ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 526044ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 5261bb77d34eSAndreas Gruenbacher tcp_cork = nc->tcp_cork; 526244ed167dSPhilipp Reisner ping_int = nc->ping_int; 526344ed167dSPhilipp Reisner rcu_read_unlock(); 526444ed167dSPhilipp Reisner 526532862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 5266a17647aaSAndreas Gruenbacher if (drbd_send_ping(tconn)) { 526732862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 5268841ce241SAndreas Gruenbacher goto reconnect; 5269841ce241SAndreas Gruenbacher } 527044ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 527144ed167dSPhilipp Reisner ping_timeout_active = true; 5272b411b363SPhilipp Reisner } 5273b411b363SPhilipp Reisner 527432862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 527532862ec7SPhilipp Reisner much to send */ 5276bb77d34eSAndreas Gruenbacher if (tcp_cork) 527732862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 5278a990be46SAndreas Gruenbacher if (tconn_finish_peer_reqs(tconn)) { 5279a990be46SAndreas Gruenbacher conn_err(tconn, "tconn_finish_peer_reqs() failed\n"); 5280b411b363SPhilipp Reisner goto reconnect; 5281082a3439SPhilipp Reisner } 5282b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 5283bb77d34eSAndreas Gruenbacher if (tcp_cork) 528432862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 5285b411b363SPhilipp Reisner 5286b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5287b411b363SPhilipp Reisner if (signal_pending(current)) 5288b411b363SPhilipp Reisner continue; 5289b411b363SPhilipp Reisner 529032862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 529132862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5292b411b363SPhilipp Reisner 5293b411b363SPhilipp Reisner flush_signals(current); 5294b411b363SPhilipp Reisner 5295b411b363SPhilipp Reisner /* Note: 5296b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5297b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5298b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5299b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5300b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5301b411b363SPhilipp Reisner * rv == expected: full header or command 5302b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5303b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5304b411b363SPhilipp Reisner */ 5305b411b363SPhilipp Reisner if (likely(rv > 0)) { 5306b411b363SPhilipp Reisner received += rv; 5307b411b363SPhilipp Reisner buf += rv; 5308b411b363SPhilipp Reisner } else if (rv == 0) { 530932862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 5310b411b363SPhilipp Reisner goto reconnect; 5311b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5312cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5313cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 531432862ec7SPhilipp Reisner if (time_after(tconn->last_received, 531532862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 5316cb6518cbSLars Ellenberg continue; 5317f36af18cSLars Ellenberg if (ping_timeout_active) { 531832862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 5319b411b363SPhilipp Reisner goto reconnect; 5320b411b363SPhilipp Reisner } 532132862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 5322b411b363SPhilipp Reisner continue; 5323b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5324b411b363SPhilipp Reisner continue; 5325b411b363SPhilipp Reisner } else { 532632862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 5327b411b363SPhilipp Reisner goto reconnect; 5328b411b363SPhilipp Reisner } 5329b411b363SPhilipp Reisner 5330b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5331e658983aSAndreas Gruenbacher if (decode_header(tconn, tconn->meta.rbuf, &pi)) 5332b411b363SPhilipp Reisner goto reconnect; 53337201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 53341952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 53352fcb8f30SAndreas Gruenbacher conn_err(tconn, "Unexpected meta packet %s (0x%04x)\n", 53362fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5337b411b363SPhilipp Reisner goto disconnect; 5338b411b363SPhilipp Reisner } 5339e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 534052b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 534132862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 534277351055SPhilipp Reisner pi.cmd, pi.size); 5343b411b363SPhilipp Reisner goto reconnect; 5344b411b363SPhilipp Reisner } 5345257d0af6SPhilipp Reisner } 5346b411b363SPhilipp Reisner if (received == expect) { 53472735a594SAndreas Gruenbacher bool err; 5348a4fbda8eSPhilipp Reisner 53492735a594SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 53502735a594SAndreas Gruenbacher if (err) { 53511952e916SAndreas Gruenbacher conn_err(tconn, "%pf failed\n", cmd->fn); 5352b411b363SPhilipp Reisner goto reconnect; 53531952e916SAndreas Gruenbacher } 5354b411b363SPhilipp Reisner 5355a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 5356a4fbda8eSPhilipp Reisner 535744ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 535844ed167dSPhilipp Reisner /* restore idle timeout */ 535944ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 536044ed167dSPhilipp Reisner ping_timeout_active = false; 536144ed167dSPhilipp Reisner } 5362f36af18cSLars Ellenberg 5363e658983aSAndreas Gruenbacher buf = tconn->meta.rbuf; 5364b411b363SPhilipp Reisner received = 0; 536552b061a4SAndreas Gruenbacher expect = header_size; 5366b411b363SPhilipp Reisner cmd = NULL; 5367b411b363SPhilipp Reisner } 5368b411b363SPhilipp Reisner } 5369b411b363SPhilipp Reisner 5370b411b363SPhilipp Reisner if (0) { 5371b411b363SPhilipp Reisner reconnect: 5372bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5373b411b363SPhilipp Reisner } 5374b411b363SPhilipp Reisner if (0) { 5375b411b363SPhilipp Reisner disconnect: 5376bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 5377b411b363SPhilipp Reisner } 537832862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5379b411b363SPhilipp Reisner 538032862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 5381b411b363SPhilipp Reisner 5382b411b363SPhilipp Reisner return 0; 5383b411b363SPhilipp Reisner } 5384