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" 47a3603a6eSAndreas Gruenbacher #include "drbd_protocol.h" 48b411b363SPhilipp Reisner #include "drbd_req.h" 49b411b363SPhilipp Reisner 50b411b363SPhilipp Reisner #include "drbd_vli.h" 51b411b363SPhilipp Reisner 5277351055SPhilipp Reisner struct packet_info { 5377351055SPhilipp Reisner enum drbd_packet cmd; 54e2857216SAndreas Gruenbacher unsigned int size; 55e2857216SAndreas Gruenbacher unsigned int vnr; 56e658983aSAndreas Gruenbacher void *data; 5777351055SPhilipp Reisner }; 5877351055SPhilipp Reisner 59b411b363SPhilipp Reisner enum finish_epoch { 60b411b363SPhilipp Reisner FE_STILL_LIVE, 61b411b363SPhilipp Reisner FE_DESTROYED, 62b411b363SPhilipp Reisner FE_RECYCLED, 63b411b363SPhilipp Reisner }; 64b411b363SPhilipp Reisner 656038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn); 6613e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn); 67c141ebdaSPhilipp Reisner static int drbd_disconnected(struct drbd_conf *mdev); 68b411b363SPhilipp Reisner 691e9dd291SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_tconn *, struct drbd_epoch *, enum epoch_event); 7099920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *, int); 71b411b363SPhilipp Reisner 72b411b363SPhilipp Reisner 73b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 74b411b363SPhilipp Reisner 7545bb912bSLars Ellenberg /* 7645bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 7745bb912bSLars Ellenberg * page->private being our "next" pointer. 7845bb912bSLars Ellenberg */ 7945bb912bSLars Ellenberg 8045bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 8145bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8245bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8345bb912bSLars Ellenberg */ 8445bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8545bb912bSLars Ellenberg { 8645bb912bSLars Ellenberg struct page *page; 8745bb912bSLars Ellenberg struct page *tmp; 8845bb912bSLars Ellenberg 8945bb912bSLars Ellenberg BUG_ON(!n); 9045bb912bSLars Ellenberg BUG_ON(!head); 9145bb912bSLars Ellenberg 9245bb912bSLars Ellenberg page = *head; 9323ce4227SPhilipp Reisner 9423ce4227SPhilipp Reisner if (!page) 9523ce4227SPhilipp Reisner return NULL; 9623ce4227SPhilipp Reisner 9745bb912bSLars Ellenberg while (page) { 9845bb912bSLars Ellenberg tmp = page_chain_next(page); 9945bb912bSLars Ellenberg if (--n == 0) 10045bb912bSLars Ellenberg break; /* found sufficient pages */ 10145bb912bSLars Ellenberg if (tmp == NULL) 10245bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10345bb912bSLars Ellenberg return NULL; 10445bb912bSLars Ellenberg page = tmp; 10545bb912bSLars Ellenberg } 10645bb912bSLars Ellenberg 10745bb912bSLars Ellenberg /* add end of list marker for the returned list */ 10845bb912bSLars Ellenberg set_page_private(page, 0); 10945bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 11045bb912bSLars Ellenberg page = *head; 11145bb912bSLars Ellenberg *head = tmp; 11245bb912bSLars Ellenberg return page; 11345bb912bSLars Ellenberg } 11445bb912bSLars Ellenberg 11545bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11645bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 11745bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 11845bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 11945bb912bSLars Ellenberg { 12045bb912bSLars Ellenberg struct page *tmp; 12145bb912bSLars Ellenberg int i = 1; 12245bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12345bb912bSLars Ellenberg ++i, page = tmp; 12445bb912bSLars Ellenberg if (len) 12545bb912bSLars Ellenberg *len = i; 12645bb912bSLars Ellenberg return page; 12745bb912bSLars Ellenberg } 12845bb912bSLars Ellenberg 12945bb912bSLars Ellenberg static int page_chain_free(struct page *page) 13045bb912bSLars Ellenberg { 13145bb912bSLars Ellenberg struct page *tmp; 13245bb912bSLars Ellenberg int i = 0; 13345bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13445bb912bSLars Ellenberg put_page(page); 13545bb912bSLars Ellenberg ++i; 13645bb912bSLars Ellenberg } 13745bb912bSLars Ellenberg return i; 13845bb912bSLars Ellenberg } 13945bb912bSLars Ellenberg 14045bb912bSLars Ellenberg static void page_chain_add(struct page **head, 14145bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14245bb912bSLars Ellenberg { 14345bb912bSLars Ellenberg #if 1 14445bb912bSLars Ellenberg struct page *tmp; 14545bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14645bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 14745bb912bSLars Ellenberg #endif 14845bb912bSLars Ellenberg 14945bb912bSLars Ellenberg /* add chain to head */ 15045bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 15145bb912bSLars Ellenberg *head = chain_first; 15245bb912bSLars Ellenberg } 15345bb912bSLars Ellenberg 15418c2d522SAndreas Gruenbacher static struct page *__drbd_alloc_pages(struct drbd_conf *mdev, 15518c2d522SAndreas Gruenbacher unsigned int number) 156b411b363SPhilipp Reisner { 157b411b363SPhilipp Reisner struct page *page = NULL; 15845bb912bSLars Ellenberg struct page *tmp = NULL; 15918c2d522SAndreas Gruenbacher unsigned int i = 0; 160b411b363SPhilipp Reisner 161b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 162b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16345bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 164b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16545bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16645bb912bSLars Ellenberg if (page) 16745bb912bSLars Ellenberg drbd_pp_vacant -= number; 168b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 16945bb912bSLars Ellenberg if (page) 17045bb912bSLars Ellenberg return page; 171b411b363SPhilipp Reisner } 17245bb912bSLars Ellenberg 173b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 174b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 175b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17645bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17745bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 17845bb912bSLars Ellenberg if (!tmp) 17945bb912bSLars Ellenberg break; 18045bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 18145bb912bSLars Ellenberg page = tmp; 18245bb912bSLars Ellenberg } 18345bb912bSLars Ellenberg 18445bb912bSLars Ellenberg if (i == number) 185b411b363SPhilipp Reisner return page; 18645bb912bSLars Ellenberg 18745bb912bSLars Ellenberg /* Not enough pages immediately available this time. 188c37c8ecfSAndreas Gruenbacher * No need to jump around here, drbd_alloc_pages will retry this 18945bb912bSLars Ellenberg * function "soon". */ 19045bb912bSLars Ellenberg if (page) { 19145bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 19245bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19345bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19445bb912bSLars Ellenberg drbd_pp_vacant += i; 19545bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19645bb912bSLars Ellenberg } 19745bb912bSLars Ellenberg return NULL; 198b411b363SPhilipp Reisner } 199b411b363SPhilipp Reisner 200a990be46SAndreas Gruenbacher static void reclaim_finished_net_peer_reqs(struct drbd_conf *mdev, 201a990be46SAndreas Gruenbacher struct list_head *to_be_freed) 202b411b363SPhilipp Reisner { 203db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 204b411b363SPhilipp Reisner struct list_head *le, *tle; 205b411b363SPhilipp Reisner 206b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 207b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 208b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 209b411b363SPhilipp Reisner stop to examine the list... */ 210b411b363SPhilipp Reisner 211b411b363SPhilipp Reisner list_for_each_safe(le, tle, &mdev->net_ee) { 212db830c46SAndreas Gruenbacher peer_req = list_entry(le, struct drbd_peer_request, w.list); 213045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) 214b411b363SPhilipp Reisner break; 215b411b363SPhilipp Reisner list_move(le, to_be_freed); 216b411b363SPhilipp Reisner } 217b411b363SPhilipp Reisner } 218b411b363SPhilipp Reisner 219b411b363SPhilipp Reisner static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev) 220b411b363SPhilipp Reisner { 221b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 222db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 223b411b363SPhilipp Reisner 22487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 225a990be46SAndreas Gruenbacher reclaim_finished_net_peer_reqs(mdev, &reclaimed); 22687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 227b411b363SPhilipp Reisner 228db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 2293967deb1SAndreas Gruenbacher drbd_free_net_peer_req(mdev, peer_req); 230b411b363SPhilipp Reisner } 231b411b363SPhilipp Reisner 232b411b363SPhilipp Reisner /** 233c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages() - Returns @number pages, retries forever (or until signalled) 234b411b363SPhilipp Reisner * @mdev: DRBD device. 23545bb912bSLars Ellenberg * @number: number of pages requested 23645bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 237b411b363SPhilipp Reisner * 23845bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 23945bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 24045bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 24145bb912bSLars Ellenberg * 24245bb912bSLars Ellenberg * Returns a page chain linked via page->private. 243b411b363SPhilipp Reisner */ 244c37c8ecfSAndreas Gruenbacher struct page *drbd_alloc_pages(struct drbd_conf *mdev, unsigned int number, 245c37c8ecfSAndreas Gruenbacher bool retry) 246b411b363SPhilipp Reisner { 247b411b363SPhilipp Reisner struct page *page = NULL; 24844ed167dSPhilipp Reisner struct net_conf *nc; 249b411b363SPhilipp Reisner DEFINE_WAIT(wait); 25044ed167dSPhilipp Reisner int mxb; 251b411b363SPhilipp Reisner 25245bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 25345bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 25444ed167dSPhilipp Reisner rcu_read_lock(); 25544ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 25644ed167dSPhilipp Reisner mxb = nc ? nc->max_buffers : 1000000; 25744ed167dSPhilipp Reisner rcu_read_unlock(); 25844ed167dSPhilipp Reisner 25944ed167dSPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mxb) 26018c2d522SAndreas Gruenbacher page = __drbd_alloc_pages(mdev, number); 261b411b363SPhilipp Reisner 26245bb912bSLars Ellenberg while (page == NULL) { 263b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 264b411b363SPhilipp Reisner 265b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 266b411b363SPhilipp Reisner 26744ed167dSPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mxb) { 26818c2d522SAndreas Gruenbacher page = __drbd_alloc_pages(mdev, number); 269b411b363SPhilipp Reisner if (page) 270b411b363SPhilipp Reisner break; 271b411b363SPhilipp Reisner } 272b411b363SPhilipp Reisner 273b411b363SPhilipp Reisner if (!retry) 274b411b363SPhilipp Reisner break; 275b411b363SPhilipp Reisner 276b411b363SPhilipp Reisner if (signal_pending(current)) { 277c37c8ecfSAndreas Gruenbacher dev_warn(DEV, "drbd_alloc_pages interrupted!\n"); 278b411b363SPhilipp Reisner break; 279b411b363SPhilipp Reisner } 280b411b363SPhilipp Reisner 281b411b363SPhilipp Reisner schedule(); 282b411b363SPhilipp Reisner } 283b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 284b411b363SPhilipp Reisner 28545bb912bSLars Ellenberg if (page) 28645bb912bSLars Ellenberg atomic_add(number, &mdev->pp_in_use); 287b411b363SPhilipp Reisner return page; 288b411b363SPhilipp Reisner } 289b411b363SPhilipp Reisner 290c37c8ecfSAndreas Gruenbacher /* Must not be used from irq, as that may deadlock: see drbd_alloc_pages. 29187eeee41SPhilipp Reisner * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock); 29245bb912bSLars Ellenberg * Either links the page chain back to the global pool, 29345bb912bSLars Ellenberg * or returns all pages to the system. */ 2945cc287e0SAndreas Gruenbacher static void drbd_free_pages(struct drbd_conf *mdev, struct page *page, int is_net) 295b411b363SPhilipp Reisner { 296435f0740SLars Ellenberg atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use; 297b411b363SPhilipp Reisner int i; 298435f0740SLars Ellenberg 299a73ff323SLars Ellenberg if (page == NULL) 300a73ff323SLars Ellenberg return; 301a73ff323SLars Ellenberg 3021816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 30345bb912bSLars Ellenberg i = page_chain_free(page); 30445bb912bSLars Ellenberg else { 30545bb912bSLars Ellenberg struct page *tmp; 30645bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 307b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 30845bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 30945bb912bSLars Ellenberg drbd_pp_vacant += i; 310b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 311b411b363SPhilipp Reisner } 312435f0740SLars Ellenberg i = atomic_sub_return(i, a); 31345bb912bSLars Ellenberg if (i < 0) 314435f0740SLars Ellenberg dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n", 315435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 316b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 317b411b363SPhilipp Reisner } 318b411b363SPhilipp Reisner 319b411b363SPhilipp Reisner /* 320b411b363SPhilipp Reisner You need to hold the req_lock: 321b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 322b411b363SPhilipp Reisner 323b411b363SPhilipp Reisner You must not have the req_lock: 3243967deb1SAndreas Gruenbacher drbd_free_peer_req() 3250db55363SAndreas Gruenbacher drbd_alloc_peer_req() 3267721f567SAndreas Gruenbacher drbd_free_peer_reqs() 327b411b363SPhilipp Reisner drbd_ee_fix_bhs() 328a990be46SAndreas Gruenbacher drbd_finish_peer_reqs() 329b411b363SPhilipp Reisner drbd_clear_done_ee() 330b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 331b411b363SPhilipp Reisner */ 332b411b363SPhilipp Reisner 333f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 3340db55363SAndreas Gruenbacher drbd_alloc_peer_req(struct drbd_conf *mdev, u64 id, sector_t sector, 335f6ffca9fSAndreas Gruenbacher unsigned int data_size, gfp_t gfp_mask) __must_hold(local) 336b411b363SPhilipp Reisner { 337db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 338a73ff323SLars Ellenberg struct page *page = NULL; 33945bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 340b411b363SPhilipp Reisner 3410cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE)) 342b411b363SPhilipp Reisner return NULL; 343b411b363SPhilipp Reisner 344db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 345db830c46SAndreas Gruenbacher if (!peer_req) { 346b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 3470db55363SAndreas Gruenbacher dev_err(DEV, "%s: allocation failed\n", __func__); 348b411b363SPhilipp Reisner return NULL; 349b411b363SPhilipp Reisner } 350b411b363SPhilipp Reisner 351a73ff323SLars Ellenberg if (data_size) { 352c37c8ecfSAndreas Gruenbacher page = drbd_alloc_pages(mdev, nr_pages, (gfp_mask & __GFP_WAIT)); 35345bb912bSLars Ellenberg if (!page) 35445bb912bSLars Ellenberg goto fail; 355a73ff323SLars Ellenberg } 356b411b363SPhilipp Reisner 357db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 358db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 359db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 360db830c46SAndreas Gruenbacher peer_req->i.local = false; 361db830c46SAndreas Gruenbacher peer_req->i.waiting = false; 362b411b363SPhilipp Reisner 363db830c46SAndreas Gruenbacher peer_req->epoch = NULL; 364a21e9298SPhilipp Reisner peer_req->w.mdev = mdev; 365db830c46SAndreas Gruenbacher peer_req->pages = page; 366db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, 0); 367db830c46SAndreas Gruenbacher peer_req->flags = 0; 3689a8e7753SAndreas Gruenbacher /* 3699a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3709a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3719a8e7753SAndreas Gruenbacher */ 372db830c46SAndreas Gruenbacher peer_req->block_id = id; 373b411b363SPhilipp Reisner 374db830c46SAndreas Gruenbacher return peer_req; 375b411b363SPhilipp Reisner 37645bb912bSLars Ellenberg fail: 377db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 378b411b363SPhilipp Reisner return NULL; 379b411b363SPhilipp Reisner } 380b411b363SPhilipp Reisner 3813967deb1SAndreas Gruenbacher void __drbd_free_peer_req(struct drbd_conf *mdev, struct drbd_peer_request *peer_req, 382f6ffca9fSAndreas Gruenbacher int is_net) 383b411b363SPhilipp Reisner { 384db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 385db830c46SAndreas Gruenbacher kfree(peer_req->digest); 3865cc287e0SAndreas Gruenbacher drbd_free_pages(mdev, peer_req->pages, is_net); 387db830c46SAndreas Gruenbacher D_ASSERT(atomic_read(&peer_req->pending_bios) == 0); 388db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 389db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 390b411b363SPhilipp Reisner } 391b411b363SPhilipp Reisner 3927721f567SAndreas Gruenbacher int drbd_free_peer_reqs(struct drbd_conf *mdev, struct list_head *list) 393b411b363SPhilipp Reisner { 394b411b363SPhilipp Reisner LIST_HEAD(work_list); 395db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 396b411b363SPhilipp Reisner int count = 0; 397435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 398b411b363SPhilipp Reisner 39987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 400b411b363SPhilipp Reisner list_splice_init(list, &work_list); 40187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 402b411b363SPhilipp Reisner 403db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 4043967deb1SAndreas Gruenbacher __drbd_free_peer_req(mdev, peer_req, is_net); 405b411b363SPhilipp Reisner count++; 406b411b363SPhilipp Reisner } 407b411b363SPhilipp Reisner return count; 408b411b363SPhilipp Reisner } 409b411b363SPhilipp Reisner 410b411b363SPhilipp Reisner /* 411a990be46SAndreas Gruenbacher * See also comments in _req_mod(,BARRIER_ACKED) and receive_Barrier. 412b411b363SPhilipp Reisner */ 413a990be46SAndreas Gruenbacher static int drbd_finish_peer_reqs(struct drbd_conf *mdev) 414b411b363SPhilipp Reisner { 415b411b363SPhilipp Reisner LIST_HEAD(work_list); 416b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 417db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 418e2b3032bSAndreas Gruenbacher int err = 0; 419b411b363SPhilipp Reisner 42087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 421a990be46SAndreas Gruenbacher reclaim_finished_net_peer_reqs(mdev, &reclaimed); 422b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 42387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 424b411b363SPhilipp Reisner 425db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 4263967deb1SAndreas Gruenbacher drbd_free_net_peer_req(mdev, peer_req); 427b411b363SPhilipp Reisner 428b411b363SPhilipp Reisner /* possible callbacks here: 429d4dabbe2SLars Ellenberg * e_end_block, and e_end_resync_block, e_send_superseded. 430b411b363SPhilipp Reisner * all ignore the last argument. 431b411b363SPhilipp Reisner */ 432db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 433e2b3032bSAndreas Gruenbacher int err2; 434e2b3032bSAndreas Gruenbacher 435b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 436e2b3032bSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 437e2b3032bSAndreas Gruenbacher if (!err) 438e2b3032bSAndreas Gruenbacher err = err2; 4393967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 440b411b363SPhilipp Reisner } 441b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 442b411b363SPhilipp Reisner 443e2b3032bSAndreas Gruenbacher return err; 444b411b363SPhilipp Reisner } 445b411b363SPhilipp Reisner 446d4da1537SAndreas Gruenbacher static void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, 447d4da1537SAndreas Gruenbacher struct list_head *head) 448b411b363SPhilipp Reisner { 449b411b363SPhilipp Reisner DEFINE_WAIT(wait); 450b411b363SPhilipp Reisner 451b411b363SPhilipp Reisner /* avoids spin_lock/unlock 452b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 453b411b363SPhilipp Reisner while (!list_empty(head)) { 454b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 45587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4567eaceaccSJens Axboe io_schedule(); 457b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 45887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 459b411b363SPhilipp Reisner } 460b411b363SPhilipp Reisner } 461b411b363SPhilipp Reisner 462d4da1537SAndreas Gruenbacher static void drbd_wait_ee_list_empty(struct drbd_conf *mdev, 463d4da1537SAndreas Gruenbacher struct list_head *head) 464b411b363SPhilipp Reisner { 46587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 466b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 46787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 468b411b363SPhilipp Reisner } 469b411b363SPhilipp Reisner 470dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 471b411b363SPhilipp Reisner { 472b411b363SPhilipp Reisner mm_segment_t oldfs; 473b411b363SPhilipp Reisner struct kvec iov = { 474b411b363SPhilipp Reisner .iov_base = buf, 475b411b363SPhilipp Reisner .iov_len = size, 476b411b363SPhilipp Reisner }; 477b411b363SPhilipp Reisner struct msghdr msg = { 478b411b363SPhilipp Reisner .msg_iovlen = 1, 479b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 480b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 481b411b363SPhilipp Reisner }; 482b411b363SPhilipp Reisner int rv; 483b411b363SPhilipp Reisner 484b411b363SPhilipp Reisner oldfs = get_fs(); 485b411b363SPhilipp Reisner set_fs(KERNEL_DS); 486b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 487b411b363SPhilipp Reisner set_fs(oldfs); 488b411b363SPhilipp Reisner 489b411b363SPhilipp Reisner return rv; 490b411b363SPhilipp Reisner } 491b411b363SPhilipp Reisner 492de0ff338SPhilipp Reisner static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size) 493b411b363SPhilipp Reisner { 494b411b363SPhilipp Reisner int rv; 495b411b363SPhilipp Reisner 4961393b59fSPhilipp Reisner rv = drbd_recv_short(tconn->data.socket, buf, size, 0); 497b411b363SPhilipp Reisner 498b411b363SPhilipp Reisner if (rv < 0) { 499b411b363SPhilipp Reisner if (rv == -ECONNRESET) 500de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 501b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 502de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 503b411b363SPhilipp Reisner } else if (rv == 0) { 504b66623e3SPhilipp Reisner if (test_bit(DISCONNECT_SENT, &tconn->flags)) { 505b66623e3SPhilipp Reisner long t; 506b66623e3SPhilipp Reisner rcu_read_lock(); 507b66623e3SPhilipp Reisner t = rcu_dereference(tconn->net_conf)->ping_timeo * HZ/10; 508b66623e3SPhilipp Reisner rcu_read_unlock(); 509b66623e3SPhilipp Reisner 510b66623e3SPhilipp Reisner t = wait_event_timeout(tconn->ping_wait, tconn->cstate < C_WF_REPORT_PARAMS, t); 511b66623e3SPhilipp Reisner 512599377acSPhilipp Reisner if (t) 513599377acSPhilipp Reisner goto out; 514599377acSPhilipp Reisner } 515b66623e3SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 516599377acSPhilipp Reisner } 517599377acSPhilipp Reisner 518b411b363SPhilipp Reisner if (rv != size) 519bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 520b411b363SPhilipp Reisner 521599377acSPhilipp Reisner out: 522b411b363SPhilipp Reisner return rv; 523b411b363SPhilipp Reisner } 524b411b363SPhilipp Reisner 525c6967746SAndreas Gruenbacher static int drbd_recv_all(struct drbd_tconn *tconn, void *buf, size_t size) 526c6967746SAndreas Gruenbacher { 527c6967746SAndreas Gruenbacher int err; 528c6967746SAndreas Gruenbacher 529c6967746SAndreas Gruenbacher err = drbd_recv(tconn, buf, size); 530c6967746SAndreas Gruenbacher if (err != size) { 531c6967746SAndreas Gruenbacher if (err >= 0) 532c6967746SAndreas Gruenbacher err = -EIO; 533c6967746SAndreas Gruenbacher } else 534c6967746SAndreas Gruenbacher err = 0; 535c6967746SAndreas Gruenbacher return err; 536c6967746SAndreas Gruenbacher } 537c6967746SAndreas Gruenbacher 538a5c31904SAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_tconn *tconn, void *buf, size_t size) 539a5c31904SAndreas Gruenbacher { 540a5c31904SAndreas Gruenbacher int err; 541a5c31904SAndreas Gruenbacher 542a5c31904SAndreas Gruenbacher err = drbd_recv_all(tconn, buf, size); 543a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 544a5c31904SAndreas Gruenbacher conn_warn(tconn, "short read (expected size %d)\n", (int)size); 545a5c31904SAndreas Gruenbacher return err; 546a5c31904SAndreas Gruenbacher } 547a5c31904SAndreas Gruenbacher 5485dbf1673SLars Ellenberg /* quoting tcp(7): 5495dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5505dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5515dbf1673SLars Ellenberg * This is our wrapper to do so. 5525dbf1673SLars Ellenberg */ 5535dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5545dbf1673SLars Ellenberg unsigned int rcv) 5555dbf1673SLars Ellenberg { 5565dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5575dbf1673SLars Ellenberg if (snd) { 5585dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5595dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5605dbf1673SLars Ellenberg } 5615dbf1673SLars Ellenberg if (rcv) { 5625dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5635dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5645dbf1673SLars Ellenberg } 5655dbf1673SLars Ellenberg } 5665dbf1673SLars Ellenberg 567eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 568b411b363SPhilipp Reisner { 569b411b363SPhilipp Reisner const char *what; 570b411b363SPhilipp Reisner struct socket *sock; 571b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 57244ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 57344ed167dSPhilipp Reisner struct net_conf *nc; 57444ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 57569ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 576b411b363SPhilipp Reisner int disconnect_on_error = 1; 577b411b363SPhilipp Reisner 57844ed167dSPhilipp Reisner rcu_read_lock(); 57944ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 58044ed167dSPhilipp Reisner if (!nc) { 58144ed167dSPhilipp Reisner rcu_read_unlock(); 582b411b363SPhilipp Reisner return NULL; 58344ed167dSPhilipp Reisner } 58444ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 58544ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 58669ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 587089c075dSAndreas Gruenbacher rcu_read_unlock(); 58844ed167dSPhilipp Reisner 589089c075dSAndreas Gruenbacher my_addr_len = min_t(int, tconn->my_addr_len, sizeof(src_in6)); 590089c075dSAndreas Gruenbacher memcpy(&src_in6, &tconn->my_addr, my_addr_len); 59144ed167dSPhilipp Reisner 592089c075dSAndreas Gruenbacher if (((struct sockaddr *)&tconn->my_addr)->sa_family == AF_INET6) 59344ed167dSPhilipp Reisner src_in6.sin6_port = 0; 59444ed167dSPhilipp Reisner else 59544ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 59644ed167dSPhilipp Reisner 597089c075dSAndreas Gruenbacher peer_addr_len = min_t(int, tconn->peer_addr_len, sizeof(src_in6)); 598089c075dSAndreas Gruenbacher memcpy(&peer_in6, &tconn->peer_addr, peer_addr_len); 599b411b363SPhilipp Reisner 600b411b363SPhilipp Reisner what = "sock_create_kern"; 60144ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family, 602b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 603b411b363SPhilipp Reisner if (err < 0) { 604b411b363SPhilipp Reisner sock = NULL; 605b411b363SPhilipp Reisner goto out; 606b411b363SPhilipp Reisner } 607b411b363SPhilipp Reisner 608b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 60969ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 61044ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 611b411b363SPhilipp Reisner 612b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 613b411b363SPhilipp Reisner * for the outgoing connections. 614b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 615b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 616b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 617b411b363SPhilipp Reisner * a free one dynamically. 618b411b363SPhilipp Reisner */ 619b411b363SPhilipp Reisner what = "bind before connect"; 62044ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 621b411b363SPhilipp Reisner if (err < 0) 622b411b363SPhilipp Reisner goto out; 623b411b363SPhilipp Reisner 624b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 625b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 626b411b363SPhilipp Reisner disconnect_on_error = 0; 627b411b363SPhilipp Reisner what = "connect"; 62844ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 629b411b363SPhilipp Reisner 630b411b363SPhilipp Reisner out: 631b411b363SPhilipp Reisner if (err < 0) { 632b411b363SPhilipp Reisner if (sock) { 633b411b363SPhilipp Reisner sock_release(sock); 634b411b363SPhilipp Reisner sock = NULL; 635b411b363SPhilipp Reisner } 636b411b363SPhilipp Reisner switch (-err) { 637b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 638b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 639b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 640b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 641b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 642b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 643b411b363SPhilipp Reisner disconnect_on_error = 0; 644b411b363SPhilipp Reisner break; 645b411b363SPhilipp Reisner default: 646eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 647b411b363SPhilipp Reisner } 648b411b363SPhilipp Reisner if (disconnect_on_error) 649bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 650b411b363SPhilipp Reisner } 65144ed167dSPhilipp Reisner 652b411b363SPhilipp Reisner return sock; 653b411b363SPhilipp Reisner } 654b411b363SPhilipp Reisner 6557a426fd8SPhilipp Reisner struct accept_wait_data { 6567a426fd8SPhilipp Reisner struct drbd_tconn *tconn; 6577a426fd8SPhilipp Reisner struct socket *s_listen; 6587a426fd8SPhilipp Reisner struct completion door_bell; 6597a426fd8SPhilipp Reisner void (*original_sk_state_change)(struct sock *sk); 6607a426fd8SPhilipp Reisner 6617a426fd8SPhilipp Reisner }; 6627a426fd8SPhilipp Reisner 663715306f6SAndreas Gruenbacher static void drbd_incoming_connection(struct sock *sk) 664b411b363SPhilipp Reisner { 6657a426fd8SPhilipp Reisner struct accept_wait_data *ad = sk->sk_user_data; 666715306f6SAndreas Gruenbacher void (*state_change)(struct sock *sk); 6677a426fd8SPhilipp Reisner 668715306f6SAndreas Gruenbacher state_change = ad->original_sk_state_change; 669715306f6SAndreas Gruenbacher if (sk->sk_state == TCP_ESTABLISHED) 6707a426fd8SPhilipp Reisner complete(&ad->door_bell); 671715306f6SAndreas Gruenbacher state_change(sk); 6727a426fd8SPhilipp Reisner } 6737a426fd8SPhilipp Reisner 6747a426fd8SPhilipp Reisner static int prepare_listen_socket(struct drbd_tconn *tconn, struct accept_wait_data *ad) 675b411b363SPhilipp Reisner { 6761f3e509bSPhilipp Reisner int err, sndbuf_size, rcvbuf_size, my_addr_len; 67744ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 6781f3e509bSPhilipp Reisner struct socket *s_listen; 67944ed167dSPhilipp Reisner struct net_conf *nc; 680b411b363SPhilipp Reisner const char *what; 681b411b363SPhilipp Reisner 68244ed167dSPhilipp Reisner rcu_read_lock(); 68344ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 68444ed167dSPhilipp Reisner if (!nc) { 68544ed167dSPhilipp Reisner rcu_read_unlock(); 6867a426fd8SPhilipp Reisner return -EIO; 68744ed167dSPhilipp Reisner } 68844ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 68944ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 69044ed167dSPhilipp Reisner rcu_read_unlock(); 691b411b363SPhilipp Reisner 692089c075dSAndreas Gruenbacher my_addr_len = min_t(int, tconn->my_addr_len, sizeof(struct sockaddr_in6)); 693089c075dSAndreas Gruenbacher memcpy(&my_addr, &tconn->my_addr, my_addr_len); 694b411b363SPhilipp Reisner 695b411b363SPhilipp Reisner what = "sock_create_kern"; 69644ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family, 697b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 698b411b363SPhilipp Reisner if (err) { 699b411b363SPhilipp Reisner s_listen = NULL; 700b411b363SPhilipp Reisner goto out; 701b411b363SPhilipp Reisner } 702b411b363SPhilipp Reisner 7034a17fd52SPavel Emelyanov s_listen->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 70444ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 705b411b363SPhilipp Reisner 706b411b363SPhilipp Reisner what = "bind before listen"; 70744ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 708b411b363SPhilipp Reisner if (err < 0) 709b411b363SPhilipp Reisner goto out; 710b411b363SPhilipp Reisner 7117a426fd8SPhilipp Reisner ad->s_listen = s_listen; 7127a426fd8SPhilipp Reisner write_lock_bh(&s_listen->sk->sk_callback_lock); 7137a426fd8SPhilipp Reisner ad->original_sk_state_change = s_listen->sk->sk_state_change; 714715306f6SAndreas Gruenbacher s_listen->sk->sk_state_change = drbd_incoming_connection; 7157a426fd8SPhilipp Reisner s_listen->sk->sk_user_data = ad; 7167a426fd8SPhilipp Reisner write_unlock_bh(&s_listen->sk->sk_callback_lock); 717b411b363SPhilipp Reisner 7182820fd39SPhilipp Reisner what = "listen"; 7192820fd39SPhilipp Reisner err = s_listen->ops->listen(s_listen, 5); 7202820fd39SPhilipp Reisner if (err < 0) 7212820fd39SPhilipp Reisner goto out; 7222820fd39SPhilipp Reisner 7237a426fd8SPhilipp Reisner return 0; 724b411b363SPhilipp Reisner out: 725b411b363SPhilipp Reisner if (s_listen) 726b411b363SPhilipp Reisner sock_release(s_listen); 727b411b363SPhilipp Reisner if (err < 0) { 728b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7291f3e509bSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 7301f3e509bSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 731b411b363SPhilipp Reisner } 732b411b363SPhilipp Reisner } 7331f3e509bSPhilipp Reisner 7347a426fd8SPhilipp Reisner return -EIO; 7351f3e509bSPhilipp Reisner } 7361f3e509bSPhilipp Reisner 737715306f6SAndreas Gruenbacher static void unregister_state_change(struct sock *sk, struct accept_wait_data *ad) 738715306f6SAndreas Gruenbacher { 739715306f6SAndreas Gruenbacher write_lock_bh(&sk->sk_callback_lock); 740715306f6SAndreas Gruenbacher sk->sk_state_change = ad->original_sk_state_change; 741715306f6SAndreas Gruenbacher sk->sk_user_data = NULL; 742715306f6SAndreas Gruenbacher write_unlock_bh(&sk->sk_callback_lock); 743715306f6SAndreas Gruenbacher } 744715306f6SAndreas Gruenbacher 7457a426fd8SPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn, struct accept_wait_data *ad) 7461f3e509bSPhilipp Reisner { 7471f3e509bSPhilipp Reisner int timeo, connect_int, err = 0; 7481f3e509bSPhilipp Reisner struct socket *s_estab = NULL; 7491f3e509bSPhilipp Reisner struct net_conf *nc; 7501f3e509bSPhilipp Reisner 7511f3e509bSPhilipp Reisner rcu_read_lock(); 7521f3e509bSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 7531f3e509bSPhilipp Reisner if (!nc) { 7541f3e509bSPhilipp Reisner rcu_read_unlock(); 7551f3e509bSPhilipp Reisner return NULL; 7561f3e509bSPhilipp Reisner } 7571f3e509bSPhilipp Reisner connect_int = nc->connect_int; 7581f3e509bSPhilipp Reisner rcu_read_unlock(); 7591f3e509bSPhilipp Reisner 7601f3e509bSPhilipp Reisner timeo = connect_int * HZ; 76138b682b2SAkinobu Mita /* 28.5% random jitter */ 76238b682b2SAkinobu Mita timeo += (prandom_u32() & 1) ? timeo / 7 : -timeo / 7; 7631f3e509bSPhilipp Reisner 7647a426fd8SPhilipp Reisner err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); 7657a426fd8SPhilipp Reisner if (err <= 0) 7667a426fd8SPhilipp Reisner return NULL; 7671f3e509bSPhilipp Reisner 7687a426fd8SPhilipp Reisner err = kernel_accept(ad->s_listen, &s_estab, 0); 769b411b363SPhilipp Reisner if (err < 0) { 770b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7711f3e509bSPhilipp Reisner conn_err(tconn, "accept failed, err = %d\n", err); 772bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 773b411b363SPhilipp Reisner } 774b411b363SPhilipp Reisner } 775b411b363SPhilipp Reisner 776715306f6SAndreas Gruenbacher if (s_estab) 777715306f6SAndreas Gruenbacher unregister_state_change(s_estab->sk, ad); 778b411b363SPhilipp Reisner 779b411b363SPhilipp Reisner return s_estab; 780b411b363SPhilipp Reisner } 781b411b363SPhilipp Reisner 782e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *, void *, struct packet_info *); 783b411b363SPhilipp Reisner 7849f5bdc33SAndreas Gruenbacher static int send_first_packet(struct drbd_tconn *tconn, struct drbd_socket *sock, 7859f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7869f5bdc33SAndreas Gruenbacher { 7879f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) 7889f5bdc33SAndreas Gruenbacher return -EIO; 789e658983aSAndreas Gruenbacher return conn_send_command(tconn, sock, cmd, 0, NULL, 0); 790b411b363SPhilipp Reisner } 791b411b363SPhilipp Reisner 7929f5bdc33SAndreas Gruenbacher static int receive_first_packet(struct drbd_tconn *tconn, struct socket *sock) 793b411b363SPhilipp Reisner { 7949f5bdc33SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 7959f5bdc33SAndreas Gruenbacher struct packet_info pi; 7969f5bdc33SAndreas Gruenbacher int err; 797b411b363SPhilipp Reisner 7989f5bdc33SAndreas Gruenbacher err = drbd_recv_short(sock, tconn->data.rbuf, header_size, 0); 7999f5bdc33SAndreas Gruenbacher if (err != header_size) { 8009f5bdc33SAndreas Gruenbacher if (err >= 0) 8019f5bdc33SAndreas Gruenbacher err = -EIO; 8029f5bdc33SAndreas Gruenbacher return err; 8039f5bdc33SAndreas Gruenbacher } 8049f5bdc33SAndreas Gruenbacher err = decode_header(tconn, tconn->data.rbuf, &pi); 8059f5bdc33SAndreas Gruenbacher if (err) 8069f5bdc33SAndreas Gruenbacher return err; 8079f5bdc33SAndreas Gruenbacher return pi.cmd; 808b411b363SPhilipp Reisner } 809b411b363SPhilipp Reisner 810b411b363SPhilipp Reisner /** 811b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 812b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 813b411b363SPhilipp Reisner */ 814dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 815b411b363SPhilipp Reisner { 816b411b363SPhilipp Reisner int rr; 817b411b363SPhilipp Reisner char tb[4]; 818b411b363SPhilipp Reisner 819b411b363SPhilipp Reisner if (!*sock) 82081e84650SAndreas Gruenbacher return false; 821b411b363SPhilipp Reisner 822dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 823b411b363SPhilipp Reisner 824b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 82581e84650SAndreas Gruenbacher return true; 826b411b363SPhilipp Reisner } else { 827b411b363SPhilipp Reisner sock_release(*sock); 828b411b363SPhilipp Reisner *sock = NULL; 82981e84650SAndreas Gruenbacher return false; 830b411b363SPhilipp Reisner } 831b411b363SPhilipp Reisner } 8322325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8332325eb66SPhilipp Reisner in a connection */ 834c141ebdaSPhilipp Reisner int drbd_connected(struct drbd_conf *mdev) 835907599e0SPhilipp Reisner { 8360829f5edSAndreas Gruenbacher int err; 837907599e0SPhilipp Reisner 838907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 839907599e0SPhilipp Reisner mdev->peer_seq = 0; 840907599e0SPhilipp Reisner 8418410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 8428410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 8438410da8fSPhilipp Reisner &mdev->own_state_mutex; 8448410da8fSPhilipp Reisner 8450829f5edSAndreas Gruenbacher err = drbd_send_sync_param(mdev); 8460829f5edSAndreas Gruenbacher if (!err) 8470829f5edSAndreas Gruenbacher err = drbd_send_sizes(mdev, 0, 0); 8480829f5edSAndreas Gruenbacher if (!err) 8490829f5edSAndreas Gruenbacher err = drbd_send_uuids(mdev); 8500829f5edSAndreas Gruenbacher if (!err) 85143de7c85SPhilipp Reisner err = drbd_send_current_state(mdev); 852907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 853907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 8542d56a974SPhilipp Reisner atomic_set(&mdev->ap_in_flight, 0); 8558b924f1dSPhilipp Reisner mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */ 8560829f5edSAndreas Gruenbacher return err; 857907599e0SPhilipp Reisner } 858b411b363SPhilipp Reisner 859b411b363SPhilipp Reisner /* 860b411b363SPhilipp Reisner * return values: 861b411b363SPhilipp Reisner * 1 yes, we have a valid connection 862b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 863b411b363SPhilipp Reisner * -1 peer talks different language, 864b411b363SPhilipp Reisner * no point in trying again, please go standalone. 865b411b363SPhilipp Reisner * -2 We do not have a network config... 866b411b363SPhilipp Reisner */ 86781fa2e67SPhilipp Reisner static int conn_connect(struct drbd_tconn *tconn) 868b411b363SPhilipp Reisner { 8697da35862SPhilipp Reisner struct drbd_socket sock, msock; 870c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 87144ed167dSPhilipp Reisner struct net_conf *nc; 87292f14951SPhilipp Reisner int vnr, timeout, h, ok; 87308b165baSPhilipp Reisner bool discard_my_data; 874197296ffSPhilipp Reisner enum drbd_state_rv rv; 8757a426fd8SPhilipp Reisner struct accept_wait_data ad = { 8767a426fd8SPhilipp Reisner .tconn = tconn, 8777a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 8787a426fd8SPhilipp Reisner }; 879b411b363SPhilipp Reisner 880b66623e3SPhilipp Reisner clear_bit(DISCONNECT_SENT, &tconn->flags); 881bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 882b411b363SPhilipp Reisner return -2; 883b411b363SPhilipp Reisner 8847da35862SPhilipp Reisner mutex_init(&sock.mutex); 8857da35862SPhilipp Reisner sock.sbuf = tconn->data.sbuf; 8867da35862SPhilipp Reisner sock.rbuf = tconn->data.rbuf; 8877da35862SPhilipp Reisner sock.socket = NULL; 8887da35862SPhilipp Reisner mutex_init(&msock.mutex); 8897da35862SPhilipp Reisner msock.sbuf = tconn->meta.sbuf; 8907da35862SPhilipp Reisner msock.rbuf = tconn->meta.rbuf; 8917da35862SPhilipp Reisner msock.socket = NULL; 8927da35862SPhilipp Reisner 8930916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 8940916e0e3SAndreas Gruenbacher tconn->agreed_pro_version = 80; 895b411b363SPhilipp Reisner 8967a426fd8SPhilipp Reisner if (prepare_listen_socket(tconn, &ad)) 8977a426fd8SPhilipp Reisner return 0; 898b411b363SPhilipp Reisner 899b411b363SPhilipp Reisner do { 9002bf89621SAndreas Gruenbacher struct socket *s; 901b411b363SPhilipp Reisner 902907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 903b411b363SPhilipp Reisner if (s) { 9047da35862SPhilipp Reisner if (!sock.socket) { 9057da35862SPhilipp Reisner sock.socket = s; 9067da35862SPhilipp Reisner send_first_packet(tconn, &sock, P_INITIAL_DATA); 9077da35862SPhilipp Reisner } else if (!msock.socket) { 908427c0434SLars Ellenberg clear_bit(RESOLVE_CONFLICTS, &tconn->flags); 9097da35862SPhilipp Reisner msock.socket = s; 9107da35862SPhilipp Reisner send_first_packet(tconn, &msock, P_INITIAL_META); 911b411b363SPhilipp Reisner } else { 91281fa2e67SPhilipp Reisner conn_err(tconn, "Logic error in conn_connect()\n"); 913b411b363SPhilipp Reisner goto out_release_sockets; 914b411b363SPhilipp Reisner } 915b411b363SPhilipp Reisner } 916b411b363SPhilipp Reisner 9177da35862SPhilipp Reisner if (sock.socket && msock.socket) { 9187da35862SPhilipp Reisner rcu_read_lock(); 9197da35862SPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 9207da35862SPhilipp Reisner timeout = nc->ping_timeo * HZ / 10; 9217da35862SPhilipp Reisner rcu_read_unlock(); 9227da35862SPhilipp Reisner schedule_timeout_interruptible(timeout); 9237da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9247da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 925b411b363SPhilipp Reisner if (ok) 926b411b363SPhilipp Reisner break; 927b411b363SPhilipp Reisner } 928b411b363SPhilipp Reisner 929b411b363SPhilipp Reisner retry: 9307a426fd8SPhilipp Reisner s = drbd_wait_for_connect(tconn, &ad); 931b411b363SPhilipp Reisner if (s) { 93292f14951SPhilipp Reisner int fp = receive_first_packet(tconn, s); 9337da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9347da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 93592f14951SPhilipp Reisner switch (fp) { 936e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9377da35862SPhilipp Reisner if (sock.socket) { 938907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 9397da35862SPhilipp Reisner sock_release(sock.socket); 94080c6eed4SPhilipp Reisner sock.socket = s; 94180c6eed4SPhilipp Reisner goto randomize; 942b411b363SPhilipp Reisner } 9437da35862SPhilipp Reisner sock.socket = s; 944b411b363SPhilipp Reisner break; 945e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 946427c0434SLars Ellenberg set_bit(RESOLVE_CONFLICTS, &tconn->flags); 9477da35862SPhilipp Reisner if (msock.socket) { 948907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 9497da35862SPhilipp Reisner sock_release(msock.socket); 95080c6eed4SPhilipp Reisner msock.socket = s; 95180c6eed4SPhilipp Reisner goto randomize; 952b411b363SPhilipp Reisner } 9537da35862SPhilipp Reisner msock.socket = s; 954b411b363SPhilipp Reisner break; 955b411b363SPhilipp Reisner default: 956907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 957b411b363SPhilipp Reisner sock_release(s); 95880c6eed4SPhilipp Reisner randomize: 95938b682b2SAkinobu Mita if (prandom_u32() & 1) 960b411b363SPhilipp Reisner goto retry; 961b411b363SPhilipp Reisner } 962b411b363SPhilipp Reisner } 963b411b363SPhilipp Reisner 964bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 965b411b363SPhilipp Reisner goto out_release_sockets; 966b411b363SPhilipp Reisner if (signal_pending(current)) { 967b411b363SPhilipp Reisner flush_signals(current); 968b411b363SPhilipp Reisner smp_rmb(); 969907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 970b411b363SPhilipp Reisner goto out_release_sockets; 971b411b363SPhilipp Reisner } 972b411b363SPhilipp Reisner 9737da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9747da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 975b666dbf8SPhilipp Reisner } while (!ok); 976b411b363SPhilipp Reisner 9777a426fd8SPhilipp Reisner if (ad.s_listen) 9787a426fd8SPhilipp Reisner sock_release(ad.s_listen); 979b411b363SPhilipp Reisner 98098683650SPhilipp Reisner sock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 98198683650SPhilipp Reisner msock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 982b411b363SPhilipp Reisner 9837da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 9847da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 985b411b363SPhilipp Reisner 9867da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 9877da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 988b411b363SPhilipp Reisner 989b411b363SPhilipp Reisner /* NOT YET ... 9907da35862SPhilipp Reisner * sock.socket->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 9917da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 9926038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 993b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 99444ed167dSPhilipp Reisner rcu_read_lock(); 99544ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 996b411b363SPhilipp Reisner 9977da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 9987da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 99944ed167dSPhilipp Reisner 10007da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 100144ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 100208b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 100344ed167dSPhilipp Reisner rcu_read_unlock(); 100444ed167dSPhilipp Reisner 10057da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 1006b411b363SPhilipp Reisner 1007b411b363SPhilipp Reisner /* we don't want delays. 100825985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10097da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10107da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1011b411b363SPhilipp Reisner 10127da35862SPhilipp Reisner tconn->data.socket = sock.socket; 10137da35862SPhilipp Reisner tconn->meta.socket = msock.socket; 1014907599e0SPhilipp Reisner tconn->last_received = jiffies; 1015b411b363SPhilipp Reisner 10166038178eSAndreas Gruenbacher h = drbd_do_features(tconn); 1017b411b363SPhilipp Reisner if (h <= 0) 1018b411b363SPhilipp Reisner return h; 1019b411b363SPhilipp Reisner 1020907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 1021b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 1022907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 1023b10d96cbSJohannes Thoma case -1: 1024907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 1025b411b363SPhilipp Reisner return -1; 1026b10d96cbSJohannes Thoma case 0: 1027907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 1028b10d96cbSJohannes Thoma return 0; 1029b411b363SPhilipp Reisner } 1030b411b363SPhilipp Reisner } 1031b411b363SPhilipp Reisner 10327da35862SPhilipp Reisner tconn->data.socket->sk->sk_sndtimeo = timeout; 10337da35862SPhilipp Reisner tconn->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1034b411b363SPhilipp Reisner 1035387eb308SAndreas Gruenbacher if (drbd_send_protocol(tconn) == -EOPNOTSUPP) 10367e2455c1SPhilipp Reisner return -1; 10371e86ac48SPhilipp Reisner 1038a1096a6eSPhilipp Reisner set_bit(STATE_SENT, &tconn->flags); 1039197296ffSPhilipp Reisner 1040c141ebdaSPhilipp Reisner rcu_read_lock(); 1041c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 1042c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 104326ea8f92SAndreas Gruenbacher rcu_read_unlock(); 104426ea8f92SAndreas Gruenbacher 104513c76abaSPhilipp Reisner /* Prevent a race between resync-handshake and 104613c76abaSPhilipp Reisner * being promoted to Primary. 104713c76abaSPhilipp Reisner * 104813c76abaSPhilipp Reisner * Grab and release the state mutex, so we know that any current 104913c76abaSPhilipp Reisner * drbd_set_role() is finished, and any incoming drbd_set_role 105013c76abaSPhilipp Reisner * will see the STATE_SENT flag, and wait for it to be cleared. 105113c76abaSPhilipp Reisner */ 105213c76abaSPhilipp Reisner mutex_lock(mdev->state_mutex); 105313c76abaSPhilipp Reisner mutex_unlock(mdev->state_mutex); 105413c76abaSPhilipp Reisner 105508b165baSPhilipp Reisner if (discard_my_data) 105608b165baSPhilipp Reisner set_bit(DISCARD_MY_DATA, &mdev->flags); 105708b165baSPhilipp Reisner else 105808b165baSPhilipp Reisner clear_bit(DISCARD_MY_DATA, &mdev->flags); 105908b165baSPhilipp Reisner 1060c141ebdaSPhilipp Reisner drbd_connected(mdev); 1061c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 1062c141ebdaSPhilipp Reisner rcu_read_lock(); 1063c141ebdaSPhilipp Reisner } 1064c141ebdaSPhilipp Reisner rcu_read_unlock(); 1065c141ebdaSPhilipp Reisner 1066a1096a6eSPhilipp Reisner rv = conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1067ed635cb0SLars Ellenberg if (rv < SS_SUCCESS || tconn->cstate != C_WF_REPORT_PARAMS) { 1068a1096a6eSPhilipp Reisner clear_bit(STATE_SENT, &tconn->flags); 10691e86ac48SPhilipp Reisner return 0; 1070a1096a6eSPhilipp Reisner } 10711e86ac48SPhilipp Reisner 1072823bd832SPhilipp Reisner drbd_thread_start(&tconn->asender); 1073b411b363SPhilipp Reisner 107408b165baSPhilipp Reisner mutex_lock(&tconn->conf_update); 107508b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 107608b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 107708b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 107808b165baSPhilipp Reisner * just to clear a single value. */ 107908b165baSPhilipp Reisner tconn->net_conf->discard_my_data = 0; 108008b165baSPhilipp Reisner mutex_unlock(&tconn->conf_update); 108108b165baSPhilipp Reisner 1082d3fcb490SPhilipp Reisner return h; 1083b411b363SPhilipp Reisner 1084b411b363SPhilipp Reisner out_release_sockets: 10857a426fd8SPhilipp Reisner if (ad.s_listen) 10867a426fd8SPhilipp Reisner sock_release(ad.s_listen); 10877da35862SPhilipp Reisner if (sock.socket) 10887da35862SPhilipp Reisner sock_release(sock.socket); 10897da35862SPhilipp Reisner if (msock.socket) 10907da35862SPhilipp Reisner sock_release(msock.socket); 1091b411b363SPhilipp Reisner return -1; 1092b411b363SPhilipp Reisner } 1093b411b363SPhilipp Reisner 1094e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *tconn, void *header, struct packet_info *pi) 1095b411b363SPhilipp Reisner { 1096e658983aSAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 1097b411b363SPhilipp Reisner 10980c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 10990c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 11000c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 11010c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 11020c8e36d9SAndreas Gruenbacher conn_err(tconn, "Header padding is not zero\n"); 11030c8e36d9SAndreas Gruenbacher return -EINVAL; 110402918be2SPhilipp Reisner } 11050c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11060c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11070c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11080c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1109e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1110e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1111e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1112b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1113eefc2f7dSPhilipp Reisner pi->vnr = 0; 1114e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1115e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1116e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1117e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1118e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 111977351055SPhilipp Reisner pi->vnr = 0; 112002918be2SPhilipp Reisner } else { 1121e658983aSAndreas Gruenbacher conn_err(tconn, "Wrong magic value 0x%08x in protocol version %d\n", 1122e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1123e658983aSAndreas Gruenbacher tconn->agreed_pro_version); 11248172f3e9SAndreas Gruenbacher return -EINVAL; 1125b411b363SPhilipp Reisner } 1126e658983aSAndreas Gruenbacher pi->data = header + header_size; 11278172f3e9SAndreas Gruenbacher return 0; 1128b411b363SPhilipp Reisner } 1129b411b363SPhilipp Reisner 11309ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 1131257d0af6SPhilipp Reisner { 1132e658983aSAndreas Gruenbacher void *buffer = tconn->data.rbuf; 113369bc7bc3SAndreas Gruenbacher int err; 1134257d0af6SPhilipp Reisner 1135e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, buffer, drbd_header_size(tconn)); 1136a5c31904SAndreas Gruenbacher if (err) 113769bc7bc3SAndreas Gruenbacher return err; 1138257d0af6SPhilipp Reisner 1139e658983aSAndreas Gruenbacher err = decode_header(tconn, buffer, pi); 11409ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 1141b411b363SPhilipp Reisner 114269bc7bc3SAndreas Gruenbacher return err; 1143b411b363SPhilipp Reisner } 1144b411b363SPhilipp Reisner 11454b0007c0SPhilipp Reisner static void drbd_flush(struct drbd_tconn *tconn) 1146b411b363SPhilipp Reisner { 1147b411b363SPhilipp Reisner int rv; 11484b0007c0SPhilipp Reisner struct drbd_conf *mdev; 11494b0007c0SPhilipp Reisner int vnr; 1150b411b363SPhilipp Reisner 11514b0007c0SPhilipp Reisner if (tconn->write_ordering >= WO_bdev_flush) { 1152615e087fSLars Ellenberg rcu_read_lock(); 11534b0007c0SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 1154615e087fSLars Ellenberg if (!get_ldev(mdev)) 1155615e087fSLars Ellenberg continue; 1156615e087fSLars Ellenberg kref_get(&mdev->kref); 1157615e087fSLars Ellenberg rcu_read_unlock(); 11584b0007c0SPhilipp Reisner 1159615e087fSLars Ellenberg rv = blkdev_issue_flush(mdev->ldev->backing_bdev, 1160615e087fSLars Ellenberg GFP_NOIO, NULL); 1161b411b363SPhilipp Reisner if (rv) { 1162ebd2b0cdSPhilipp Reisner dev_info(DEV, "local disk flush failed with status %d\n", rv); 1163b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1164b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1165b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 11664b0007c0SPhilipp Reisner drbd_bump_write_ordering(tconn, WO_drain_io); 1167b411b363SPhilipp Reisner } 1168b411b363SPhilipp Reisner put_ldev(mdev); 1169615e087fSLars Ellenberg kref_put(&mdev->kref, &drbd_minor_destroy); 1170615e087fSLars Ellenberg 1171615e087fSLars Ellenberg rcu_read_lock(); 1172615e087fSLars Ellenberg if (rv) 11734b0007c0SPhilipp Reisner break; 1174b411b363SPhilipp Reisner } 1175615e087fSLars Ellenberg rcu_read_unlock(); 1176b411b363SPhilipp Reisner } 1177b411b363SPhilipp Reisner } 1178b411b363SPhilipp Reisner 1179b411b363SPhilipp Reisner /** 1180b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1181b411b363SPhilipp Reisner * @mdev: DRBD device. 1182b411b363SPhilipp Reisner * @epoch: Epoch object. 1183b411b363SPhilipp Reisner * @ev: Epoch event. 1184b411b363SPhilipp Reisner */ 11851e9dd291SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_tconn *tconn, 1186b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1187b411b363SPhilipp Reisner enum epoch_event ev) 1188b411b363SPhilipp Reisner { 11892451fc3bSPhilipp Reisner int epoch_size; 1190b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1191b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1192b411b363SPhilipp Reisner 119312038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 1194b411b363SPhilipp Reisner do { 1195b411b363SPhilipp Reisner next_epoch = NULL; 1196b411b363SPhilipp Reisner 1197b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1198b411b363SPhilipp Reisner 1199b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1200b411b363SPhilipp Reisner case EV_PUT: 1201b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1202b411b363SPhilipp Reisner break; 1203b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1204b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1205b411b363SPhilipp Reisner break; 1206b411b363SPhilipp Reisner case EV_BECAME_LAST: 1207b411b363SPhilipp Reisner /* nothing to do*/ 1208b411b363SPhilipp Reisner break; 1209b411b363SPhilipp Reisner } 1210b411b363SPhilipp Reisner 1211b411b363SPhilipp Reisner if (epoch_size != 0 && 1212b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 121380f9fd55SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1214b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 121512038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 12169ed57dcbSLars Ellenberg drbd_send_b_ack(epoch->tconn, epoch->barrier_nr, epoch_size); 121712038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 1218b411b363SPhilipp Reisner } 12199ed57dcbSLars Ellenberg #if 0 12209ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 12219ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 122280f9fd55SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 12239ed57dcbSLars Ellenberg dec_unacked(epoch->tconn); 12249ed57dcbSLars Ellenberg #endif 1225b411b363SPhilipp Reisner 122612038a3aSPhilipp Reisner if (tconn->current_epoch != epoch) { 1227b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1228b411b363SPhilipp Reisner list_del(&epoch->list); 1229b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 123012038a3aSPhilipp Reisner tconn->epochs--; 1231b411b363SPhilipp Reisner kfree(epoch); 1232b411b363SPhilipp Reisner 1233b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1234b411b363SPhilipp Reisner rv = FE_DESTROYED; 1235b411b363SPhilipp Reisner } else { 1236b411b363SPhilipp Reisner epoch->flags = 0; 1237b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1238698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1239b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1240b411b363SPhilipp Reisner rv = FE_RECYCLED; 1241b411b363SPhilipp Reisner } 1242b411b363SPhilipp Reisner } 1243b411b363SPhilipp Reisner 1244b411b363SPhilipp Reisner if (!next_epoch) 1245b411b363SPhilipp Reisner break; 1246b411b363SPhilipp Reisner 1247b411b363SPhilipp Reisner epoch = next_epoch; 1248b411b363SPhilipp Reisner } while (1); 1249b411b363SPhilipp Reisner 125012038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 1251b411b363SPhilipp Reisner 1252b411b363SPhilipp Reisner return rv; 1253b411b363SPhilipp Reisner } 1254b411b363SPhilipp Reisner 1255b411b363SPhilipp Reisner /** 1256b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 12574b0007c0SPhilipp Reisner * @tconn: DRBD connection. 1258b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1259b411b363SPhilipp Reisner */ 12604b0007c0SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_tconn *tconn, enum write_ordering_e wo) 1261b411b363SPhilipp Reisner { 1262daeda1ccSPhilipp Reisner struct disk_conf *dc; 12634b0007c0SPhilipp Reisner struct drbd_conf *mdev; 1264b411b363SPhilipp Reisner enum write_ordering_e pwo; 12654b0007c0SPhilipp Reisner int vnr; 1266b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1267b411b363SPhilipp Reisner [WO_none] = "none", 1268b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1269b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1270b411b363SPhilipp Reisner }; 1271b411b363SPhilipp Reisner 12724b0007c0SPhilipp Reisner pwo = tconn->write_ordering; 1273b411b363SPhilipp Reisner wo = min(pwo, wo); 1274daeda1ccSPhilipp Reisner rcu_read_lock(); 12754b0007c0SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 127627eb13e9SPhilipp Reisner if (!get_ldev_if_state(mdev, D_ATTACHING)) 12774b0007c0SPhilipp Reisner continue; 1278daeda1ccSPhilipp Reisner dc = rcu_dereference(mdev->ldev->disk_conf); 1279daeda1ccSPhilipp Reisner 128066b2f6b9SAndreas Gruenbacher if (wo == WO_bdev_flush && !dc->disk_flushes) 1281b411b363SPhilipp Reisner wo = WO_drain_io; 1282d0c980e2SAndreas Gruenbacher if (wo == WO_drain_io && !dc->disk_drain) 1283b411b363SPhilipp Reisner wo = WO_none; 12844b0007c0SPhilipp Reisner put_ldev(mdev); 12854b0007c0SPhilipp Reisner } 1286daeda1ccSPhilipp Reisner rcu_read_unlock(); 12874b0007c0SPhilipp Reisner tconn->write_ordering = wo; 12884b0007c0SPhilipp Reisner if (pwo != tconn->write_ordering || wo == WO_bdev_flush) 12894b0007c0SPhilipp Reisner conn_info(tconn, "Method to ensure write ordering: %s\n", write_ordering_str[tconn->write_ordering]); 1290b411b363SPhilipp Reisner } 1291b411b363SPhilipp Reisner 1292b411b363SPhilipp Reisner /** 1293fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 129445bb912bSLars Ellenberg * @mdev: DRBD device. 1295db830c46SAndreas Gruenbacher * @peer_req: peer request 129645bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 129710f6d992SLars Ellenberg * 129810f6d992SLars Ellenberg * May spread the pages to multiple bios, 129910f6d992SLars Ellenberg * depending on bio_add_page restrictions. 130010f6d992SLars Ellenberg * 130110f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 130210f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 130310f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 130410f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 130510f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 130610f6d992SLars Ellenberg * on certain Xen deployments. 130745bb912bSLars Ellenberg */ 130845bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1309fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1310fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 131145bb912bSLars Ellenberg const unsigned rw, const int fault_type) 131245bb912bSLars Ellenberg { 131345bb912bSLars Ellenberg struct bio *bios = NULL; 131445bb912bSLars Ellenberg struct bio *bio; 1315db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1316db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1317db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 131845bb912bSLars Ellenberg unsigned n_bios = 0; 131945bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 132010f6d992SLars Ellenberg int err = -ENOMEM; 132145bb912bSLars Ellenberg 132245bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 132345bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 132445bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 13259476f39dSLars Ellenberg * request in more than one bio. 13269476f39dSLars Ellenberg * 13279476f39dSLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 13289476f39dSLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 13299476f39dSLars Ellenberg */ 133045bb912bSLars Ellenberg next_bio: 133145bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 133245bb912bSLars Ellenberg if (!bio) { 133345bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 133445bb912bSLars Ellenberg goto fail; 133545bb912bSLars Ellenberg } 1336db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 13374f024f37SKent Overstreet bio->bi_iter.bi_sector = sector; 133845bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 133945bb912bSLars Ellenberg bio->bi_rw = rw; 1340db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1341fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 134245bb912bSLars Ellenberg 134345bb912bSLars Ellenberg bio->bi_next = bios; 134445bb912bSLars Ellenberg bios = bio; 134545bb912bSLars Ellenberg ++n_bios; 134645bb912bSLars Ellenberg 134745bb912bSLars Ellenberg page_chain_for_each(page) { 134845bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 134945bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 135010f6d992SLars Ellenberg /* A single page must always be possible! 135110f6d992SLars Ellenberg * But in case it fails anyways, 135210f6d992SLars Ellenberg * we deal with it, and complain (below). */ 135310f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 135410f6d992SLars Ellenberg dev_err(DEV, 135510f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 135610f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 13574f024f37SKent Overstreet len, (uint64_t)bio->bi_iter.bi_sector); 135810f6d992SLars Ellenberg err = -ENOSPC; 135910f6d992SLars Ellenberg goto fail; 136010f6d992SLars Ellenberg } 136145bb912bSLars Ellenberg goto next_bio; 136245bb912bSLars Ellenberg } 136345bb912bSLars Ellenberg ds -= len; 136445bb912bSLars Ellenberg sector += len >> 9; 136545bb912bSLars Ellenberg --nr_pages; 136645bb912bSLars Ellenberg } 136745bb912bSLars Ellenberg D_ASSERT(page == NULL); 136845bb912bSLars Ellenberg D_ASSERT(ds == 0); 136945bb912bSLars Ellenberg 1370db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 137145bb912bSLars Ellenberg do { 137245bb912bSLars Ellenberg bio = bios; 137345bb912bSLars Ellenberg bios = bios->bi_next; 137445bb912bSLars Ellenberg bio->bi_next = NULL; 137545bb912bSLars Ellenberg 137645bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 137745bb912bSLars Ellenberg } while (bios); 137845bb912bSLars Ellenberg return 0; 137945bb912bSLars Ellenberg 138045bb912bSLars Ellenberg fail: 138145bb912bSLars Ellenberg while (bios) { 138245bb912bSLars Ellenberg bio = bios; 138345bb912bSLars Ellenberg bios = bios->bi_next; 138445bb912bSLars Ellenberg bio_put(bio); 138545bb912bSLars Ellenberg } 138610f6d992SLars Ellenberg return err; 138745bb912bSLars Ellenberg } 138845bb912bSLars Ellenberg 138953840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1390db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 139153840641SAndreas Gruenbacher { 1392db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 139353840641SAndreas Gruenbacher 139453840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 139553840641SAndreas Gruenbacher drbd_clear_interval(i); 139653840641SAndreas Gruenbacher 13976c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 139853840641SAndreas Gruenbacher if (i->waiting) 139953840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 140053840641SAndreas Gruenbacher } 140153840641SAndreas Gruenbacher 1402f63e631aSRashika Kheria static void conn_wait_active_ee_empty(struct drbd_tconn *tconn) 140377fede51SPhilipp Reisner { 140477fede51SPhilipp Reisner struct drbd_conf *mdev; 140577fede51SPhilipp Reisner int vnr; 140677fede51SPhilipp Reisner 140777fede51SPhilipp Reisner rcu_read_lock(); 140877fede51SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 140977fede51SPhilipp Reisner kref_get(&mdev->kref); 141077fede51SPhilipp Reisner rcu_read_unlock(); 141177fede51SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 141277fede51SPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 141377fede51SPhilipp Reisner rcu_read_lock(); 141477fede51SPhilipp Reisner } 141577fede51SPhilipp Reisner rcu_read_unlock(); 141677fede51SPhilipp Reisner } 141777fede51SPhilipp Reisner 14184a76b161SAndreas Gruenbacher static int receive_Barrier(struct drbd_tconn *tconn, struct packet_info *pi) 1419b411b363SPhilipp Reisner { 14202451fc3bSPhilipp Reisner int rv; 1421e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1422b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1423b411b363SPhilipp Reisner 14249ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 14259ed57dcbSLars Ellenberg * not a specific (peer)device. 14269ed57dcbSLars Ellenberg */ 142712038a3aSPhilipp Reisner tconn->current_epoch->barrier_nr = p->barrier; 14289ed57dcbSLars Ellenberg tconn->current_epoch->tconn = tconn; 14291e9dd291SPhilipp Reisner rv = drbd_may_finish_epoch(tconn, tconn->current_epoch, EV_GOT_BARRIER_NR); 1430b411b363SPhilipp Reisner 1431b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1432b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1433b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1434b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1435b411b363SPhilipp Reisner * completed. */ 14364b0007c0SPhilipp Reisner switch (tconn->write_ordering) { 1437b411b363SPhilipp Reisner case WO_none: 1438b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 143982bc0194SAndreas Gruenbacher return 0; 1440b411b363SPhilipp Reisner 1441b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1442b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1443b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14442451fc3bSPhilipp Reisner if (epoch) 14452451fc3bSPhilipp Reisner break; 14462451fc3bSPhilipp Reisner else 14479ed57dcbSLars Ellenberg conn_warn(tconn, "Allocation of an epoch failed, slowing down\n"); 14482451fc3bSPhilipp Reisner /* Fall through */ 14492451fc3bSPhilipp Reisner 14502451fc3bSPhilipp Reisner case WO_bdev_flush: 14512451fc3bSPhilipp Reisner case WO_drain_io: 145277fede51SPhilipp Reisner conn_wait_active_ee_empty(tconn); 14534b0007c0SPhilipp Reisner drbd_flush(tconn); 14542451fc3bSPhilipp Reisner 145512038a3aSPhilipp Reisner if (atomic_read(&tconn->current_epoch->epoch_size)) { 14562451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14572451fc3bSPhilipp Reisner if (epoch) 14582451fc3bSPhilipp Reisner break; 1459b411b363SPhilipp Reisner } 1460b411b363SPhilipp Reisner 146182bc0194SAndreas Gruenbacher return 0; 14622451fc3bSPhilipp Reisner default: 14639ed57dcbSLars Ellenberg conn_err(tconn, "Strangeness in tconn->write_ordering %d\n", tconn->write_ordering); 146482bc0194SAndreas Gruenbacher return -EIO; 1465b411b363SPhilipp Reisner } 1466b411b363SPhilipp Reisner 1467b411b363SPhilipp Reisner epoch->flags = 0; 1468b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1469b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1470b411b363SPhilipp Reisner 147112038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 147212038a3aSPhilipp Reisner if (atomic_read(&tconn->current_epoch->epoch_size)) { 147312038a3aSPhilipp Reisner list_add(&epoch->list, &tconn->current_epoch->list); 147412038a3aSPhilipp Reisner tconn->current_epoch = epoch; 147512038a3aSPhilipp Reisner tconn->epochs++; 1476b411b363SPhilipp Reisner } else { 1477b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1478b411b363SPhilipp Reisner kfree(epoch); 1479b411b363SPhilipp Reisner } 148012038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 1481b411b363SPhilipp Reisner 148282bc0194SAndreas Gruenbacher return 0; 1483b411b363SPhilipp Reisner } 1484b411b363SPhilipp Reisner 1485b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1486b411b363SPhilipp Reisner * and from receive_Data */ 1487f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1488f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1489f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1490b411b363SPhilipp Reisner { 14916666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1492db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1493b411b363SPhilipp Reisner struct page *page; 1494a5c31904SAndreas Gruenbacher int dgs, ds, err; 1495a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1496a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 14976b4388acSPhilipp Reisner unsigned long *data; 1498b411b363SPhilipp Reisner 149988104ca4SAndreas Gruenbacher dgs = 0; 150088104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 150188104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 15029f5bdc33SAndreas Gruenbacher /* 15039f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 15049f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 15059f5bdc33SAndreas Gruenbacher */ 1506a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1507a5c31904SAndreas Gruenbacher if (err) 1508b411b363SPhilipp Reisner return NULL; 1509b411b363SPhilipp Reisner data_size -= dgs; 151088104ca4SAndreas Gruenbacher } 1511b411b363SPhilipp Reisner 1512841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1513841ce241SAndreas Gruenbacher return NULL; 1514841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1515841ce241SAndreas Gruenbacher return NULL; 1516b411b363SPhilipp Reisner 15176666032aSLars Ellenberg /* even though we trust out peer, 15186666032aSLars Ellenberg * we sometimes have to double check. */ 15196666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1520fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1521fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 15226666032aSLars Ellenberg (unsigned long long)capacity, 15236666032aSLars Ellenberg (unsigned long long)sector, data_size); 15246666032aSLars Ellenberg return NULL; 15256666032aSLars Ellenberg } 15266666032aSLars Ellenberg 1527b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1528b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1529b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 15300db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, id, sector, data_size, GFP_NOIO); 1531db830c46SAndreas Gruenbacher if (!peer_req) 1532b411b363SPhilipp Reisner return NULL; 153345bb912bSLars Ellenberg 1534a73ff323SLars Ellenberg if (!data_size) 153581a3537aSLars Ellenberg return peer_req; 1536a73ff323SLars Ellenberg 1537b411b363SPhilipp Reisner ds = data_size; 1538db830c46SAndreas Gruenbacher page = peer_req->pages; 153945bb912bSLars Ellenberg page_chain_for_each(page) { 154045bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 15416b4388acSPhilipp Reisner data = kmap(page); 1542a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 15430cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 15446b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 15456b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 15466b4388acSPhilipp Reisner } 1547b411b363SPhilipp Reisner kunmap(page); 1548a5c31904SAndreas Gruenbacher if (err) { 15493967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1550b411b363SPhilipp Reisner return NULL; 1551b411b363SPhilipp Reisner } 1552a5c31904SAndreas Gruenbacher ds -= len; 1553b411b363SPhilipp Reisner } 1554b411b363SPhilipp Reisner 1555b411b363SPhilipp Reisner if (dgs) { 15565b614abeSAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->peer_integrity_tfm, peer_req, dig_vv); 1557b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1558470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1559470be44aSLars Ellenberg (unsigned long long)sector, data_size); 15603967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1561b411b363SPhilipp Reisner return NULL; 1562b411b363SPhilipp Reisner } 1563b411b363SPhilipp Reisner } 1564b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1565db830c46SAndreas Gruenbacher return peer_req; 1566b411b363SPhilipp Reisner } 1567b411b363SPhilipp Reisner 1568b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1569b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1570b411b363SPhilipp Reisner */ 1571b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1572b411b363SPhilipp Reisner { 1573b411b363SPhilipp Reisner struct page *page; 1574a5c31904SAndreas Gruenbacher int err = 0; 1575b411b363SPhilipp Reisner void *data; 1576b411b363SPhilipp Reisner 1577c3470cdeSLars Ellenberg if (!data_size) 1578fc5be839SAndreas Gruenbacher return 0; 1579c3470cdeSLars Ellenberg 1580c37c8ecfSAndreas Gruenbacher page = drbd_alloc_pages(mdev, 1, 1); 1581b411b363SPhilipp Reisner 1582b411b363SPhilipp Reisner data = kmap(page); 1583b411b363SPhilipp Reisner while (data_size) { 1584fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1585fc5be839SAndreas Gruenbacher 1586a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 1587a5c31904SAndreas Gruenbacher if (err) 1588b411b363SPhilipp Reisner break; 1589a5c31904SAndreas Gruenbacher data_size -= len; 1590b411b363SPhilipp Reisner } 1591b411b363SPhilipp Reisner kunmap(page); 15925cc287e0SAndreas Gruenbacher drbd_free_pages(mdev, page, 0); 1593fc5be839SAndreas Gruenbacher return err; 1594b411b363SPhilipp Reisner } 1595b411b363SPhilipp Reisner 1596b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1597b411b363SPhilipp Reisner sector_t sector, int data_size) 1598b411b363SPhilipp Reisner { 15997988613bSKent Overstreet struct bio_vec bvec; 16007988613bSKent Overstreet struct bvec_iter iter; 1601b411b363SPhilipp Reisner struct bio *bio; 16027988613bSKent Overstreet int dgs, err, expect; 1603a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1604a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1605b411b363SPhilipp Reisner 160688104ca4SAndreas Gruenbacher dgs = 0; 160788104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 160888104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 1609a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1610a5c31904SAndreas Gruenbacher if (err) 1611a5c31904SAndreas Gruenbacher return err; 1612b411b363SPhilipp Reisner data_size -= dgs; 161388104ca4SAndreas Gruenbacher } 1614b411b363SPhilipp Reisner 1615b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1616b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1617b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1618b411b363SPhilipp Reisner 1619b411b363SPhilipp Reisner bio = req->master_bio; 16204f024f37SKent Overstreet D_ASSERT(sector == bio->bi_iter.bi_sector); 1621b411b363SPhilipp Reisner 16227988613bSKent Overstreet bio_for_each_segment(bvec, bio, iter) { 16237988613bSKent Overstreet void *mapped = kmap(bvec.bv_page) + bvec.bv_offset; 16247988613bSKent Overstreet expect = min_t(int, data_size, bvec.bv_len); 1625a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, mapped, expect); 16267988613bSKent Overstreet kunmap(bvec.bv_page); 1627a5c31904SAndreas Gruenbacher if (err) 1628a5c31904SAndreas Gruenbacher return err; 1629a5c31904SAndreas Gruenbacher data_size -= expect; 1630b411b363SPhilipp Reisner } 1631b411b363SPhilipp Reisner 1632b411b363SPhilipp Reisner if (dgs) { 16335b614abeSAndreas Gruenbacher drbd_csum_bio(mdev, mdev->tconn->peer_integrity_tfm, bio, dig_vv); 1634b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1635b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 163628284cefSAndreas Gruenbacher return -EINVAL; 1637b411b363SPhilipp Reisner } 1638b411b363SPhilipp Reisner } 1639b411b363SPhilipp Reisner 1640b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 164128284cefSAndreas Gruenbacher return 0; 1642b411b363SPhilipp Reisner } 1643b411b363SPhilipp Reisner 1644a990be46SAndreas Gruenbacher /* 1645a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1646a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1647a990be46SAndreas Gruenbacher */ 164899920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1649b411b363SPhilipp Reisner { 16508050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16518050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 165200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1653db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 165499920dc5SAndreas Gruenbacher int err; 1655b411b363SPhilipp Reisner 1656db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1657b411b363SPhilipp Reisner 1658db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1659db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 166099920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1661b411b363SPhilipp Reisner } else { 1662b411b363SPhilipp Reisner /* Record failure to sync */ 1663db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1664b411b363SPhilipp Reisner 166599920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1666b411b363SPhilipp Reisner } 1667b411b363SPhilipp Reisner dec_unacked(mdev); 1668b411b363SPhilipp Reisner 166999920dc5SAndreas Gruenbacher return err; 1670b411b363SPhilipp Reisner } 1671b411b363SPhilipp Reisner 1672b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1673b411b363SPhilipp Reisner { 1674db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1675b411b363SPhilipp Reisner 1676db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1677db830c46SAndreas Gruenbacher if (!peer_req) 167845bb912bSLars Ellenberg goto fail; 1679b411b363SPhilipp Reisner 1680b411b363SPhilipp Reisner dec_rs_pending(mdev); 1681b411b363SPhilipp Reisner 1682b411b363SPhilipp Reisner inc_unacked(mdev); 1683b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1684b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1685b411b363SPhilipp Reisner 1686db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 168745bb912bSLars Ellenberg 168887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1689db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 169087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1691b411b363SPhilipp Reisner 16920f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1693fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1694e1c1b0fcSAndreas Gruenbacher return 0; 169545bb912bSLars Ellenberg 169610f6d992SLars Ellenberg /* don't care for the reason here */ 169710f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 169887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1699db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 170087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 170122cc37a9SLars Ellenberg 17023967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 170345bb912bSLars Ellenberg fail: 170445bb912bSLars Ellenberg put_ldev(mdev); 1705e1c1b0fcSAndreas Gruenbacher return -EIO; 1706b411b363SPhilipp Reisner } 1707b411b363SPhilipp Reisner 1708668eebc6SAndreas Gruenbacher static struct drbd_request * 1709bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1710bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1711b411b363SPhilipp Reisner { 1712b411b363SPhilipp Reisner struct drbd_request *req; 1713668eebc6SAndreas Gruenbacher 1714bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1715bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 17165e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1717668eebc6SAndreas Gruenbacher return req; 1718c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 17195af172edSAndreas Gruenbacher dev_err(DEV, "%s: failed to find request 0x%lx, sector %llus\n", func, 1720c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1721c3afd8f5SAndreas Gruenbacher } 1722668eebc6SAndreas Gruenbacher return NULL; 1723668eebc6SAndreas Gruenbacher } 1724668eebc6SAndreas Gruenbacher 17254a76b161SAndreas Gruenbacher static int receive_DataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1726b411b363SPhilipp Reisner { 17274a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1728b411b363SPhilipp Reisner struct drbd_request *req; 1729b411b363SPhilipp Reisner sector_t sector; 173082bc0194SAndreas Gruenbacher int err; 1731e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17324a76b161SAndreas Gruenbacher 17334a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 17344a76b161SAndreas Gruenbacher if (!mdev) 17354a76b161SAndreas Gruenbacher return -EIO; 1736b411b363SPhilipp Reisner 1737b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1738b411b363SPhilipp Reisner 173987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1740bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 174187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1742c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 174382bc0194SAndreas Gruenbacher return -EIO; 1744b411b363SPhilipp Reisner 174524c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1746b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1747b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1748e2857216SAndreas Gruenbacher err = recv_dless_read(mdev, req, sector, pi->size); 174982bc0194SAndreas Gruenbacher if (!err) 17508554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1751b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1752b411b363SPhilipp Reisner * I don't think we may complete this just yet 1753b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1754b411b363SPhilipp Reisner 175582bc0194SAndreas Gruenbacher return err; 1756b411b363SPhilipp Reisner } 1757b411b363SPhilipp Reisner 17584a76b161SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1759b411b363SPhilipp Reisner { 17604a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1761b411b363SPhilipp Reisner sector_t sector; 176282bc0194SAndreas Gruenbacher int err; 1763e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17644a76b161SAndreas Gruenbacher 17654a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 17664a76b161SAndreas Gruenbacher if (!mdev) 17674a76b161SAndreas Gruenbacher return -EIO; 1768b411b363SPhilipp Reisner 1769b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1770b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1771b411b363SPhilipp Reisner 1772b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1773b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1774b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1775fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1776e2857216SAndreas Gruenbacher err = recv_resync_read(mdev, sector, pi->size); 1777b411b363SPhilipp Reisner } else { 1778b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1779b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1780b411b363SPhilipp Reisner 1781e2857216SAndreas Gruenbacher err = drbd_drain_block(mdev, pi->size); 1782b411b363SPhilipp Reisner 1783e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 1784b411b363SPhilipp Reisner } 1785b411b363SPhilipp Reisner 1786e2857216SAndreas Gruenbacher atomic_add(pi->size >> 9, &mdev->rs_sect_in); 1787778f271dSPhilipp Reisner 178882bc0194SAndreas Gruenbacher return err; 1789b411b363SPhilipp Reisner } 1790b411b363SPhilipp Reisner 17917be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 17927be8da07SAndreas Gruenbacher sector_t sector, int size) 1793b411b363SPhilipp Reisner { 17947be8da07SAndreas Gruenbacher struct drbd_interval *i; 17957be8da07SAndreas Gruenbacher struct drbd_request *req; 1796b411b363SPhilipp Reisner 17977be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 17987be8da07SAndreas Gruenbacher if (!i->local) 17997be8da07SAndreas Gruenbacher continue; 18007be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18017be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 18027be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 18037be8da07SAndreas Gruenbacher continue; 18042312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 18052312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 1806d4dabbe2SLars Ellenberg __req_mod(req, CONFLICT_RESOLVED, NULL); 18077be8da07SAndreas Gruenbacher } 18087be8da07SAndreas Gruenbacher } 18097be8da07SAndreas Gruenbacher 1810a990be46SAndreas Gruenbacher /* 1811a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1812b411b363SPhilipp Reisner */ 181399920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1814b411b363SPhilipp Reisner { 18158050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 18168050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 181700d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1818db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 181999920dc5SAndreas Gruenbacher int err = 0, pcmd; 1820b411b363SPhilipp Reisner 1821303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1822db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1823b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1824b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1825db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1826b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 182799920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, pcmd, peer_req); 1828b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1829db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1830b411b363SPhilipp Reisner } else { 183199920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1832b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1833b411b363SPhilipp Reisner * maybe assert this? */ 1834b411b363SPhilipp Reisner } 1835b411b363SPhilipp Reisner dec_unacked(mdev); 1836b411b363SPhilipp Reisner } 1837b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1838b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1839302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 184087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1841db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1842db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 18437be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 18447be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 184587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1846bb3bfe96SAndreas Gruenbacher } else 1847db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1848b411b363SPhilipp Reisner 18491e9dd291SPhilipp Reisner drbd_may_finish_epoch(mdev->tconn, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1850b411b363SPhilipp Reisner 185199920dc5SAndreas Gruenbacher return err; 1852b411b363SPhilipp Reisner } 1853b411b363SPhilipp Reisner 18547be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1855b411b363SPhilipp Reisner { 18567be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 18578050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 18588050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 185999920dc5SAndreas Gruenbacher int err; 1860b411b363SPhilipp Reisner 186199920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, ack, peer_req); 1862b411b363SPhilipp Reisner dec_unacked(mdev); 1863b411b363SPhilipp Reisner 186499920dc5SAndreas Gruenbacher return err; 1865b411b363SPhilipp Reisner } 1866b411b363SPhilipp Reisner 1867d4dabbe2SLars Ellenberg static int e_send_superseded(struct drbd_work *w, int unused) 1868b6a370baSPhilipp Reisner { 1869d4dabbe2SLars Ellenberg return e_send_ack(w, P_SUPERSEDED); 18707be8da07SAndreas Gruenbacher } 1871b6a370baSPhilipp Reisner 187299920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 18737be8da07SAndreas Gruenbacher { 18747be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 18757be8da07SAndreas Gruenbacher 18767be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 1877d4dabbe2SLars Ellenberg P_RETRY_WRITE : P_SUPERSEDED); 18787be8da07SAndreas Gruenbacher } 18797be8da07SAndreas Gruenbacher 18803e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 18813e394da1SAndreas Gruenbacher { 18823e394da1SAndreas Gruenbacher /* 18833e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 18843e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 18853e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 18863e394da1SAndreas Gruenbacher */ 18873e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 18883e394da1SAndreas Gruenbacher } 18893e394da1SAndreas Gruenbacher 18903e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 18913e394da1SAndreas Gruenbacher { 18923e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 18933e394da1SAndreas Gruenbacher } 18943e394da1SAndreas Gruenbacher 189543ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 18963e394da1SAndreas Gruenbacher { 18973c13b680SLars Ellenberg unsigned int newest_peer_seq; 18983e394da1SAndreas Gruenbacher 1899b874d231SPhilipp Reisner if (test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags)) { 19003e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 19013c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 19023c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 19033e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 19043c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 19053c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 19063e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 19073e394da1SAndreas Gruenbacher } 19087be8da07SAndreas Gruenbacher } 19093e394da1SAndreas Gruenbacher 1910d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 1911d93f6302SLars Ellenberg { 1912d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 1913d93f6302SLars Ellenberg } 1914d93f6302SLars Ellenberg 1915d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 19163ea35df8SPhilipp Reisner static bool overlapping_resync_write(struct drbd_conf *mdev, struct drbd_peer_request *peer_req) 1917d93f6302SLars Ellenberg { 1918d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 1919b6a370baSPhilipp Reisner bool rv = 0; 1920b6a370baSPhilipp Reisner 1921d93f6302SLars Ellenberg spin_lock_irq(&mdev->tconn->req_lock); 1922d93f6302SLars Ellenberg list_for_each_entry(rs_req, &mdev->sync_ee, w.list) { 1923d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 1924d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 1925b6a370baSPhilipp Reisner rv = 1; 1926b6a370baSPhilipp Reisner break; 1927b6a370baSPhilipp Reisner } 1928b6a370baSPhilipp Reisner } 1929d93f6302SLars Ellenberg spin_unlock_irq(&mdev->tconn->req_lock); 1930b6a370baSPhilipp Reisner 1931b6a370baSPhilipp Reisner return rv; 1932b6a370baSPhilipp Reisner } 1933b6a370baSPhilipp Reisner 1934b411b363SPhilipp Reisner /* Called from receive_Data. 1935b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1936b411b363SPhilipp Reisner * 1937b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1938b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1939b411b363SPhilipp Reisner * been sent. 1940b411b363SPhilipp Reisner * 1941b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1942b411b363SPhilipp Reisner * 1943b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1944b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1945b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1946b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1947b411b363SPhilipp Reisner * 1948b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1949b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1950b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1951b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1952b411b363SPhilipp Reisner * 1953b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1954b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 19557be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1956b411b363SPhilipp Reisner { 1957b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1958b411b363SPhilipp Reisner long timeout; 1959b874d231SPhilipp Reisner int ret = 0, tp; 19607be8da07SAndreas Gruenbacher 1961b874d231SPhilipp Reisner if (!test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags)) 19627be8da07SAndreas Gruenbacher return 0; 19637be8da07SAndreas Gruenbacher 1964b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1965b411b363SPhilipp Reisner for (;;) { 19667be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 19677be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 1968b411b363SPhilipp Reisner break; 19697be8da07SAndreas Gruenbacher } 1970b874d231SPhilipp Reisner 1971b411b363SPhilipp Reisner if (signal_pending(current)) { 1972b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1973b411b363SPhilipp Reisner break; 1974b411b363SPhilipp Reisner } 1975b874d231SPhilipp Reisner 1976b874d231SPhilipp Reisner rcu_read_lock(); 1977b874d231SPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 1978b874d231SPhilipp Reisner rcu_read_unlock(); 1979b874d231SPhilipp Reisner 1980b874d231SPhilipp Reisner if (!tp) 1981b874d231SPhilipp Reisner break; 1982b874d231SPhilipp Reisner 1983b874d231SPhilipp Reisner /* Only need to wait if two_primaries is enabled */ 19847be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1985b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 198644ed167dSPhilipp Reisner rcu_read_lock(); 198744ed167dSPhilipp Reisner timeout = rcu_dereference(mdev->tconn->net_conf)->ping_timeo*HZ/10; 198844ed167dSPhilipp Reisner rcu_read_unlock(); 198971b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1990b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 19917be8da07SAndreas Gruenbacher if (!timeout) { 1992b411b363SPhilipp Reisner ret = -ETIMEDOUT; 199371b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1994b411b363SPhilipp Reisner break; 1995b411b363SPhilipp Reisner } 1996b411b363SPhilipp Reisner } 1997b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 19987be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 1999b411b363SPhilipp Reisner return ret; 2000b411b363SPhilipp Reisner } 2001b411b363SPhilipp Reisner 2002688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2003688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2004688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 2005688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 200676d2e7ecSPhilipp Reisner { 200776d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 200876d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 2009688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 201076d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 201176d2e7ecSPhilipp Reisner } 201276d2e7ecSPhilipp Reisner 20137be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 20147be8da07SAndreas Gruenbacher unsigned int size) 2015b411b363SPhilipp Reisner { 20167be8da07SAndreas Gruenbacher struct drbd_interval *i; 20177be8da07SAndreas Gruenbacher 20187be8da07SAndreas Gruenbacher repeat: 20197be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 20207be8da07SAndreas Gruenbacher struct drbd_request *req; 20217be8da07SAndreas Gruenbacher struct bio_and_error m; 20227be8da07SAndreas Gruenbacher 20237be8da07SAndreas Gruenbacher if (!i->local) 20247be8da07SAndreas Gruenbacher continue; 20257be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 20267be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 20277be8da07SAndreas Gruenbacher continue; 20287be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 20297be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 20307be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 20317be8da07SAndreas Gruenbacher if (m.bio) 20327be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 20337be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 20347be8da07SAndreas Gruenbacher goto repeat; 20357be8da07SAndreas Gruenbacher } 20367be8da07SAndreas Gruenbacher } 20377be8da07SAndreas Gruenbacher 20387be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 20397be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 20407be8da07SAndreas Gruenbacher { 20417be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 2042427c0434SLars Ellenberg bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &tconn->flags); 20437be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 20447be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 20457be8da07SAndreas Gruenbacher struct drbd_interval *i; 20467be8da07SAndreas Gruenbacher bool equal; 20477be8da07SAndreas Gruenbacher int err; 20487be8da07SAndreas Gruenbacher 20497be8da07SAndreas Gruenbacher /* 20507be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 20517be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 20527be8da07SAndreas Gruenbacher */ 20537be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 20547be8da07SAndreas Gruenbacher 20557be8da07SAndreas Gruenbacher repeat: 20567be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 20577be8da07SAndreas Gruenbacher if (i == &peer_req->i) 20587be8da07SAndreas Gruenbacher continue; 20597be8da07SAndreas Gruenbacher 20607be8da07SAndreas Gruenbacher if (!i->local) { 20617be8da07SAndreas Gruenbacher /* 20627be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 20637be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 20647be8da07SAndreas Gruenbacher * earlier peer request to complete. 20657be8da07SAndreas Gruenbacher */ 20667be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 20677be8da07SAndreas Gruenbacher if (err) 20687be8da07SAndreas Gruenbacher goto out; 20697be8da07SAndreas Gruenbacher goto repeat; 20707be8da07SAndreas Gruenbacher } 20717be8da07SAndreas Gruenbacher 20727be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 20737be8da07SAndreas Gruenbacher if (resolve_conflicts) { 20747be8da07SAndreas Gruenbacher /* 20757be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 2076d4dabbe2SLars Ellenberg * overlapping request, it can be considered overwritten 2077d4dabbe2SLars Ellenberg * and thus superseded; otherwise, it will be retried 2078d4dabbe2SLars Ellenberg * once all overlapping requests have completed. 20797be8da07SAndreas Gruenbacher */ 2080d4dabbe2SLars Ellenberg bool superseded = i->sector <= sector && i->sector + 20817be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 20827be8da07SAndreas Gruenbacher 20837be8da07SAndreas Gruenbacher if (!equal) 20847be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 20857be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 20867be8da07SAndreas Gruenbacher "assuming %s came first\n", 20877be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 20887be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 2089d4dabbe2SLars Ellenberg superseded ? "local" : "remote"); 20907be8da07SAndreas Gruenbacher 20917be8da07SAndreas Gruenbacher inc_unacked(mdev); 2092d4dabbe2SLars Ellenberg peer_req->w.cb = superseded ? e_send_superseded : 20937be8da07SAndreas Gruenbacher e_send_retry_write; 20947be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 20957be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 20967be8da07SAndreas Gruenbacher 20977be8da07SAndreas Gruenbacher err = -ENOENT; 20987be8da07SAndreas Gruenbacher goto out; 20997be8da07SAndreas Gruenbacher } else { 21007be8da07SAndreas Gruenbacher struct drbd_request *req = 21017be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 21027be8da07SAndreas Gruenbacher 21037be8da07SAndreas Gruenbacher if (!equal) 21047be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 21057be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 21067be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 21077be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 21087be8da07SAndreas Gruenbacher 21097be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 21107be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 21117be8da07SAndreas Gruenbacher /* 21127be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 2113d4dabbe2SLars Ellenberg * decide if this request has been superseded 2114d4dabbe2SLars Ellenberg * or needs to be retried. 2115d4dabbe2SLars Ellenberg * Requests that have been superseded will 21167be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 21177be8da07SAndreas Gruenbacher * 21187be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 21197be8da07SAndreas Gruenbacher * request to finish locally before submitting 21207be8da07SAndreas Gruenbacher * the conflicting peer request. 21217be8da07SAndreas Gruenbacher */ 21227be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 21237be8da07SAndreas Gruenbacher if (err) { 21247be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 21257be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 21267be8da07SAndreas Gruenbacher CS_HARD); 21277be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 21287be8da07SAndreas Gruenbacher goto out; 21297be8da07SAndreas Gruenbacher } 21307be8da07SAndreas Gruenbacher goto repeat; 21317be8da07SAndreas Gruenbacher } 21327be8da07SAndreas Gruenbacher /* 21337be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 21347be8da07SAndreas Gruenbacher * the new peer request has completed. 21357be8da07SAndreas Gruenbacher */ 21367be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 21377be8da07SAndreas Gruenbacher } 21387be8da07SAndreas Gruenbacher } 21397be8da07SAndreas Gruenbacher err = 0; 21407be8da07SAndreas Gruenbacher 21417be8da07SAndreas Gruenbacher out: 21427be8da07SAndreas Gruenbacher if (err) 21437be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 21447be8da07SAndreas Gruenbacher return err; 21457be8da07SAndreas Gruenbacher } 21467be8da07SAndreas Gruenbacher 2147b411b363SPhilipp Reisner /* mirrored write */ 21484a76b161SAndreas Gruenbacher static int receive_Data(struct drbd_tconn *tconn, struct packet_info *pi) 2149b411b363SPhilipp Reisner { 21504a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2151b411b363SPhilipp Reisner sector_t sector; 2152db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2153e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 21547be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2155b411b363SPhilipp Reisner int rw = WRITE; 2156b411b363SPhilipp Reisner u32 dp_flags; 2157302bdeaeSPhilipp Reisner int err, tp; 21587be8da07SAndreas Gruenbacher 21594a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 21604a76b161SAndreas Gruenbacher if (!mdev) 21614a76b161SAndreas Gruenbacher return -EIO; 2162b411b363SPhilipp Reisner 2163b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 216482bc0194SAndreas Gruenbacher int err2; 2165b411b363SPhilipp Reisner 21667be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 2167e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 216812038a3aSPhilipp Reisner atomic_inc(&tconn->current_epoch->epoch_size); 2169e2857216SAndreas Gruenbacher err2 = drbd_drain_block(mdev, pi->size); 217082bc0194SAndreas Gruenbacher if (!err) 217182bc0194SAndreas Gruenbacher err = err2; 217282bc0194SAndreas Gruenbacher return err; 2173b411b363SPhilipp Reisner } 2174b411b363SPhilipp Reisner 2175fcefa62eSAndreas Gruenbacher /* 2176fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2177fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2178fcefa62eSAndreas Gruenbacher * end of this function. 2179fcefa62eSAndreas Gruenbacher */ 2180b411b363SPhilipp Reisner 2181b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2182e2857216SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, pi->size); 2183db830c46SAndreas Gruenbacher if (!peer_req) { 2184b411b363SPhilipp Reisner put_ldev(mdev); 218582bc0194SAndreas Gruenbacher return -EIO; 2186b411b363SPhilipp Reisner } 2187b411b363SPhilipp Reisner 2188db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 2189b411b363SPhilipp Reisner 2190688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2191688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 219281a3537aSLars Ellenberg if (peer_req->pages == NULL) { 219381a3537aSLars Ellenberg D_ASSERT(peer_req->i.size == 0); 2194a73ff323SLars Ellenberg D_ASSERT(dp_flags & DP_FLUSH); 2195a73ff323SLars Ellenberg } 2196688593c5SLars Ellenberg 2197688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2198db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2199688593c5SLars Ellenberg 220012038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 220112038a3aSPhilipp Reisner peer_req->epoch = tconn->current_epoch; 2202db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2203db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 220412038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 2205b411b363SPhilipp Reisner 2206302bdeaeSPhilipp Reisner rcu_read_lock(); 2207302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 2208302bdeaeSPhilipp Reisner rcu_read_unlock(); 2209302bdeaeSPhilipp Reisner if (tp) { 2210302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 22117be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 22127be8da07SAndreas Gruenbacher if (err) 2213b411b363SPhilipp Reisner goto out_interrupted; 221487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 22157be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 22167be8da07SAndreas Gruenbacher if (err) { 221787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 22187be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2219b411b363SPhilipp Reisner put_ldev(mdev); 222082bc0194SAndreas Gruenbacher return 0; 2221b411b363SPhilipp Reisner } 2222b411b363SPhilipp Reisner goto out_interrupted; 2223b411b363SPhilipp Reisner } 2224b874d231SPhilipp Reisner } else { 2225b874d231SPhilipp Reisner update_peer_seq(mdev, peer_seq); 222687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2227b874d231SPhilipp Reisner } 2228db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 222987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2230b411b363SPhilipp Reisner 2231b6a370baSPhilipp Reisner if (mdev->state.conn == C_SYNC_TARGET) 22323ea35df8SPhilipp Reisner wait_event(mdev->ee_wait, !overlapping_resync_write(mdev, peer_req)); 2233b6a370baSPhilipp Reisner 2234303d1448SPhilipp Reisner if (mdev->tconn->agreed_pro_version < 100) { 223544ed167dSPhilipp Reisner rcu_read_lock(); 223644ed167dSPhilipp Reisner switch (rcu_dereference(mdev->tconn->net_conf)->wire_protocol) { 2237b411b363SPhilipp Reisner case DRBD_PROT_C: 2238303d1448SPhilipp Reisner dp_flags |= DP_SEND_WRITE_ACK; 2239303d1448SPhilipp Reisner break; 2240303d1448SPhilipp Reisner case DRBD_PROT_B: 2241303d1448SPhilipp Reisner dp_flags |= DP_SEND_RECEIVE_ACK; 2242303d1448SPhilipp Reisner break; 2243303d1448SPhilipp Reisner } 224444ed167dSPhilipp Reisner rcu_read_unlock(); 2245303d1448SPhilipp Reisner } 2246303d1448SPhilipp Reisner 2247303d1448SPhilipp Reisner if (dp_flags & DP_SEND_WRITE_ACK) { 2248303d1448SPhilipp Reisner peer_req->flags |= EE_SEND_WRITE_ACK; 2249b411b363SPhilipp Reisner inc_unacked(mdev); 2250b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2251b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2252303d1448SPhilipp Reisner } 2253303d1448SPhilipp Reisner 2254303d1448SPhilipp Reisner if (dp_flags & DP_SEND_RECEIVE_ACK) { 2255b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2256b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2257db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2258b411b363SPhilipp Reisner } 2259b411b363SPhilipp Reisner 22606719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2261b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2262db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2263db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2264db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 226556392d2fSLars Ellenberg drbd_al_begin_io(mdev, &peer_req->i, true); 2266b411b363SPhilipp Reisner } 2267b411b363SPhilipp Reisner 226882bc0194SAndreas Gruenbacher err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR); 226982bc0194SAndreas Gruenbacher if (!err) 227082bc0194SAndreas Gruenbacher return 0; 2271b411b363SPhilipp Reisner 227210f6d992SLars Ellenberg /* don't care for the reason here */ 227310f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 227487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2275db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2276db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 227787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2278db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2279181286adSLars Ellenberg drbd_al_complete_io(mdev, &peer_req->i); 228022cc37a9SLars Ellenberg 2281b411b363SPhilipp Reisner out_interrupted: 22821e9dd291SPhilipp Reisner drbd_may_finish_epoch(tconn, peer_req->epoch, EV_PUT + EV_CLEANUP); 2283b411b363SPhilipp Reisner put_ldev(mdev); 22843967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 228582bc0194SAndreas Gruenbacher return err; 2286b411b363SPhilipp Reisner } 2287b411b363SPhilipp Reisner 22880f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 22890f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 22900f0601f4SLars Ellenberg * 22910f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 22920f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 22930f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 22940f0601f4SLars Ellenberg * activity, it obviously is "busy". 22950f0601f4SLars Ellenberg * 22960f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 22970f0601f4SLars Ellenberg * to have a short time average so we can react faster. 22980f0601f4SLars Ellenberg */ 2299e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 23000f0601f4SLars Ellenberg { 23010f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 23020f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2303e3555d85SPhilipp Reisner struct lc_element *tmp; 23040f0601f4SLars Ellenberg int curr_events; 23050f0601f4SLars Ellenberg int throttle = 0; 2306daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2307daeda1ccSPhilipp Reisner 2308daeda1ccSPhilipp Reisner rcu_read_lock(); 2309daeda1ccSPhilipp Reisner c_min_rate = rcu_dereference(mdev->ldev->disk_conf)->c_min_rate; 2310daeda1ccSPhilipp Reisner rcu_read_unlock(); 23110f0601f4SLars Ellenberg 23120f0601f4SLars Ellenberg /* feature disabled? */ 2313daeda1ccSPhilipp Reisner if (c_min_rate == 0) 23140f0601f4SLars Ellenberg return 0; 23150f0601f4SLars Ellenberg 2316e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2317e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2318e3555d85SPhilipp Reisner if (tmp) { 2319e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2320e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2321e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2322e3555d85SPhilipp Reisner return 0; 2323e3555d85SPhilipp Reisner } 2324e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2325e3555d85SPhilipp Reisner } 2326e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2327e3555d85SPhilipp Reisner 23280f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 23290f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 23300f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2331e3555d85SPhilipp Reisner 23320f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 23330f0601f4SLars Ellenberg unsigned long rs_left; 23340f0601f4SLars Ellenberg int i; 23350f0601f4SLars Ellenberg 23360f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 23370f0601f4SLars Ellenberg 23380f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 23390f0601f4SLars Ellenberg * approx. */ 23402649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 23412649f080SLars Ellenberg 23422649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 23432649f080SLars Ellenberg rs_left = mdev->ov_left; 23442649f080SLars Ellenberg else 23450f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 23460f0601f4SLars Ellenberg 23470f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 23480f0601f4SLars Ellenberg if (!dt) 23490f0601f4SLars Ellenberg dt++; 23500f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 23510f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 23520f0601f4SLars Ellenberg 2353daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 23540f0601f4SLars Ellenberg throttle = 1; 23550f0601f4SLars Ellenberg } 23560f0601f4SLars Ellenberg return throttle; 23570f0601f4SLars Ellenberg } 23580f0601f4SLars Ellenberg 23590f0601f4SLars Ellenberg 23604a76b161SAndreas Gruenbacher static int receive_DataRequest(struct drbd_tconn *tconn, struct packet_info *pi) 2361b411b363SPhilipp Reisner { 23624a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2363b411b363SPhilipp Reisner sector_t sector; 23644a76b161SAndreas Gruenbacher sector_t capacity; 2365db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2366b411b363SPhilipp Reisner struct digest_info *di = NULL; 2367b18b37beSPhilipp Reisner int size, verb; 2368b411b363SPhilipp Reisner unsigned int fault_type; 2369e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 23704a76b161SAndreas Gruenbacher 23714a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 23724a76b161SAndreas Gruenbacher if (!mdev) 23734a76b161SAndreas Gruenbacher return -EIO; 23744a76b161SAndreas Gruenbacher capacity = drbd_get_capacity(mdev->this_bdev); 2375b411b363SPhilipp Reisner 2376b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2377b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2378b411b363SPhilipp Reisner 2379c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2380b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2381b411b363SPhilipp Reisner (unsigned long long)sector, size); 238282bc0194SAndreas Gruenbacher return -EINVAL; 2383b411b363SPhilipp Reisner } 2384b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2385b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2386b411b363SPhilipp Reisner (unsigned long long)sector, size); 238782bc0194SAndreas Gruenbacher return -EINVAL; 2388b411b363SPhilipp Reisner } 2389b411b363SPhilipp Reisner 2390b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2391b18b37beSPhilipp Reisner verb = 1; 2392e2857216SAndreas Gruenbacher switch (pi->cmd) { 2393b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2394b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2395b18b37beSPhilipp Reisner break; 2396b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2397b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2398b18b37beSPhilipp Reisner case P_OV_REQUEST: 2399b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2400b18b37beSPhilipp Reisner break; 2401b18b37beSPhilipp Reisner case P_OV_REPLY: 2402b18b37beSPhilipp Reisner verb = 0; 2403b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2404b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2405b18b37beSPhilipp Reisner break; 2406b18b37beSPhilipp Reisner default: 240749ba9b1bSAndreas Gruenbacher BUG(); 2408b18b37beSPhilipp Reisner } 2409b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2410b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2411b411b363SPhilipp Reisner "no local data.\n"); 2412b18b37beSPhilipp Reisner 2413a821cc4aSLars Ellenberg /* drain possibly payload */ 2414e2857216SAndreas Gruenbacher return drbd_drain_block(mdev, pi->size); 2415b411b363SPhilipp Reisner } 2416b411b363SPhilipp Reisner 2417b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2418b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2419b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 24200db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, p->block_id, sector, size, GFP_NOIO); 2421db830c46SAndreas Gruenbacher if (!peer_req) { 2422b411b363SPhilipp Reisner put_ldev(mdev); 242382bc0194SAndreas Gruenbacher return -ENOMEM; 2424b411b363SPhilipp Reisner } 2425b411b363SPhilipp Reisner 2426e2857216SAndreas Gruenbacher switch (pi->cmd) { 2427b411b363SPhilipp Reisner case P_DATA_REQUEST: 2428db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2429b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 243080a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 243180a40e43SLars Ellenberg goto submit; 243280a40e43SLars Ellenberg 2433b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2434db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2435b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 24365f9915bbSLars Ellenberg /* used in the sector offset progress display */ 24375f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2438b411b363SPhilipp Reisner break; 2439b411b363SPhilipp Reisner 2440b411b363SPhilipp Reisner case P_OV_REPLY: 2441b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2442b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2443e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2444b411b363SPhilipp Reisner if (!di) 2445b411b363SPhilipp Reisner goto out_free_e; 2446b411b363SPhilipp Reisner 2447e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2448b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2449b411b363SPhilipp Reisner 2450db830c46SAndreas Gruenbacher peer_req->digest = di; 2451db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2452c36c3cedSLars Ellenberg 2453e2857216SAndreas Gruenbacher if (drbd_recv_all(mdev->tconn, di->digest, pi->size)) 2454b411b363SPhilipp Reisner goto out_free_e; 2455b411b363SPhilipp Reisner 2456e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 245731890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2458db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 24595f9915bbSLars Ellenberg /* used in the sector offset progress display */ 24605f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2461e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 24622649f080SLars Ellenberg /* track progress, we may need to throttle */ 24632649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2464db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2465b411b363SPhilipp Reisner dec_rs_pending(mdev); 24660f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 24670f0601f4SLars Ellenberg * but accounting still needs to be done. */ 24680f0601f4SLars Ellenberg goto submit_for_resync; 2469b411b363SPhilipp Reisner } 2470b411b363SPhilipp Reisner break; 2471b411b363SPhilipp Reisner 2472b411b363SPhilipp Reisner case P_OV_REQUEST: 2473b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 247431890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2475de228bbaSLars Ellenberg unsigned long now = jiffies; 2476de228bbaSLars Ellenberg int i; 2477b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2478b411b363SPhilipp Reisner mdev->ov_position = sector; 247930b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 248030b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2481de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2482de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2483de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2484de228bbaSLars Ellenberg } 2485b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2486b411b363SPhilipp Reisner (unsigned long long)sector); 2487b411b363SPhilipp Reisner } 2488db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2489b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2490b411b363SPhilipp Reisner break; 2491b411b363SPhilipp Reisner 2492b411b363SPhilipp Reisner default: 249349ba9b1bSAndreas Gruenbacher BUG(); 2494b411b363SPhilipp Reisner } 2495b411b363SPhilipp Reisner 24960f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 24970f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 24980f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 24990f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 25000f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 25010f0601f4SLars Ellenberg * 25020f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 25030f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 25040f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 25050f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 25060f0601f4SLars Ellenberg * a while, anyways. 25070f0601f4SLars Ellenberg */ 2508b411b363SPhilipp Reisner 25090f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 25100f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 25110f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 25120f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 25130f0601f4SLars Ellenberg * 25140f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 25150f0601f4SLars Ellenberg * we would also throttle its application reads. 25160f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 25170f0601f4SLars Ellenberg */ 2518e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2519e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2520e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 252180a40e43SLars Ellenberg goto out_free_e; 2522b411b363SPhilipp Reisner 25230f0601f4SLars Ellenberg submit_for_resync: 25240f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 25250f0601f4SLars Ellenberg 252680a40e43SLars Ellenberg submit: 2527b411b363SPhilipp Reisner inc_unacked(mdev); 252887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2529db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 253087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2531b411b363SPhilipp Reisner 2532fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 253382bc0194SAndreas Gruenbacher return 0; 2534b411b363SPhilipp Reisner 253510f6d992SLars Ellenberg /* don't care for the reason here */ 253610f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 253787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2538db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 253987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 254022cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 254122cc37a9SLars Ellenberg 2542b411b363SPhilipp Reisner out_free_e: 2543b411b363SPhilipp Reisner put_ldev(mdev); 25443967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 254582bc0194SAndreas Gruenbacher return -EIO; 2546b411b363SPhilipp Reisner } 2547b411b363SPhilipp Reisner 2548b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2549b411b363SPhilipp Reisner { 2550b411b363SPhilipp Reisner int self, peer, rv = -100; 2551b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 255244ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2553b411b363SPhilipp Reisner 2554b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2555b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2556b411b363SPhilipp Reisner 2557b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2558b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2559b411b363SPhilipp Reisner 256044ed167dSPhilipp Reisner rcu_read_lock(); 256144ed167dSPhilipp Reisner after_sb_0p = rcu_dereference(mdev->tconn->net_conf)->after_sb_0p; 256244ed167dSPhilipp Reisner rcu_read_unlock(); 256344ed167dSPhilipp Reisner switch (after_sb_0p) { 2564b411b363SPhilipp Reisner case ASB_CONSENSUS: 2565b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2566b411b363SPhilipp Reisner case ASB_CALL_HELPER: 256744ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2568b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2569b411b363SPhilipp Reisner break; 2570b411b363SPhilipp Reisner case ASB_DISCONNECT: 2571b411b363SPhilipp Reisner break; 2572b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2573b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2574b411b363SPhilipp Reisner rv = -1; 2575b411b363SPhilipp Reisner break; 2576b411b363SPhilipp Reisner } 2577b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2578b411b363SPhilipp Reisner rv = 1; 2579b411b363SPhilipp Reisner break; 2580b411b363SPhilipp Reisner } 2581b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2582b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2583b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2584b411b363SPhilipp Reisner rv = 1; 2585b411b363SPhilipp Reisner break; 2586b411b363SPhilipp Reisner } 2587b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2588b411b363SPhilipp Reisner rv = -1; 2589b411b363SPhilipp Reisner break; 2590b411b363SPhilipp Reisner } 2591b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2592ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2593b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2594b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2595b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 2596427c0434SLars Ellenberg rv = test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags) 2597b411b363SPhilipp Reisner ? -1 : 1; 2598b411b363SPhilipp Reisner break; 2599b411b363SPhilipp Reisner } else { 2600b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2601b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2602b411b363SPhilipp Reisner } 260344ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2604b411b363SPhilipp Reisner break; 2605b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2606b411b363SPhilipp Reisner if (ch_self < ch_peer) 2607b411b363SPhilipp Reisner rv = -1; 2608b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2609b411b363SPhilipp Reisner rv = 1; 2610b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2611b411b363SPhilipp Reisner /* Well, then use something else. */ 2612427c0434SLars Ellenberg rv = test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags) 2613b411b363SPhilipp Reisner ? -1 : 1; 2614b411b363SPhilipp Reisner break; 2615b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2616b411b363SPhilipp Reisner rv = -1; 2617b411b363SPhilipp Reisner break; 2618b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2619b411b363SPhilipp Reisner rv = 1; 2620b411b363SPhilipp Reisner } 2621b411b363SPhilipp Reisner 2622b411b363SPhilipp Reisner return rv; 2623b411b363SPhilipp Reisner } 2624b411b363SPhilipp Reisner 2625b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2626b411b363SPhilipp Reisner { 26276184ea21SAndreas Gruenbacher int hg, rv = -100; 262844ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2629b411b363SPhilipp Reisner 263044ed167dSPhilipp Reisner rcu_read_lock(); 263144ed167dSPhilipp Reisner after_sb_1p = rcu_dereference(mdev->tconn->net_conf)->after_sb_1p; 263244ed167dSPhilipp Reisner rcu_read_unlock(); 263344ed167dSPhilipp Reisner switch (after_sb_1p) { 2634b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2635b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2636b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2637b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2638b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 263944ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2640b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2641b411b363SPhilipp Reisner break; 2642b411b363SPhilipp Reisner case ASB_DISCONNECT: 2643b411b363SPhilipp Reisner break; 2644b411b363SPhilipp Reisner case ASB_CONSENSUS: 2645b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2646b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2647b411b363SPhilipp Reisner rv = hg; 2648b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2649b411b363SPhilipp Reisner rv = hg; 2650b411b363SPhilipp Reisner break; 2651b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2652b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2653b411b363SPhilipp Reisner break; 2654b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2655b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2656b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2657b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2658b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2659bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2660bb437946SAndreas Gruenbacher 2661b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2662b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2663b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2664bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2665bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2666b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2667b411b363SPhilipp Reisner } else { 2668b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2669b411b363SPhilipp Reisner rv = hg; 2670b411b363SPhilipp Reisner } 2671b411b363SPhilipp Reisner } else 2672b411b363SPhilipp Reisner rv = hg; 2673b411b363SPhilipp Reisner } 2674b411b363SPhilipp Reisner 2675b411b363SPhilipp Reisner return rv; 2676b411b363SPhilipp Reisner } 2677b411b363SPhilipp Reisner 2678b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2679b411b363SPhilipp Reisner { 26806184ea21SAndreas Gruenbacher int hg, rv = -100; 268144ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2682b411b363SPhilipp Reisner 268344ed167dSPhilipp Reisner rcu_read_lock(); 268444ed167dSPhilipp Reisner after_sb_2p = rcu_dereference(mdev->tconn->net_conf)->after_sb_2p; 268544ed167dSPhilipp Reisner rcu_read_unlock(); 268644ed167dSPhilipp Reisner switch (after_sb_2p) { 2687b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2688b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2689b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2690b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2691b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2692b411b363SPhilipp Reisner case ASB_CONSENSUS: 2693b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 269444ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2695b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2696b411b363SPhilipp Reisner break; 2697b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2698b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2699b411b363SPhilipp Reisner break; 2700b411b363SPhilipp Reisner case ASB_DISCONNECT: 2701b411b363SPhilipp Reisner break; 2702b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2703b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2704b411b363SPhilipp Reisner if (hg == -1) { 2705bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2706bb437946SAndreas Gruenbacher 2707b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2708b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2709b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2710bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2711bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2712b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2713b411b363SPhilipp Reisner } else { 2714b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2715b411b363SPhilipp Reisner rv = hg; 2716b411b363SPhilipp Reisner } 2717b411b363SPhilipp Reisner } else 2718b411b363SPhilipp Reisner rv = hg; 2719b411b363SPhilipp Reisner } 2720b411b363SPhilipp Reisner 2721b411b363SPhilipp Reisner return rv; 2722b411b363SPhilipp Reisner } 2723b411b363SPhilipp Reisner 2724b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2725b411b363SPhilipp Reisner u64 bits, u64 flags) 2726b411b363SPhilipp Reisner { 2727b411b363SPhilipp Reisner if (!uuid) { 2728b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2729b411b363SPhilipp Reisner return; 2730b411b363SPhilipp Reisner } 2731b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2732b411b363SPhilipp Reisner text, 2733b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2734b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2735b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2736b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2737b411b363SPhilipp Reisner (unsigned long long)bits, 2738b411b363SPhilipp Reisner (unsigned long long)flags); 2739b411b363SPhilipp Reisner } 2740b411b363SPhilipp Reisner 2741b411b363SPhilipp Reisner /* 2742b411b363SPhilipp Reisner 100 after split brain try auto recover 2743b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2744b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2745b411b363SPhilipp Reisner 0 no Sync 2746b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2747b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2748b411b363SPhilipp Reisner -100 after split brain, disconnect 2749b411b363SPhilipp Reisner -1000 unrelated data 27504a23f264SPhilipp Reisner -1091 requires proto 91 27514a23f264SPhilipp Reisner -1096 requires proto 96 2752b411b363SPhilipp Reisner */ 2753b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2754b411b363SPhilipp Reisner { 2755b411b363SPhilipp Reisner u64 self, peer; 2756b411b363SPhilipp Reisner int i, j; 2757b411b363SPhilipp Reisner 2758b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2759b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2760b411b363SPhilipp Reisner 2761b411b363SPhilipp Reisner *rule_nr = 10; 2762b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2763b411b363SPhilipp Reisner return 0; 2764b411b363SPhilipp Reisner 2765b411b363SPhilipp Reisner *rule_nr = 20; 2766b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2767b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2768b411b363SPhilipp Reisner return -2; 2769b411b363SPhilipp Reisner 2770b411b363SPhilipp Reisner *rule_nr = 30; 2771b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2772b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2773b411b363SPhilipp Reisner return 2; 2774b411b363SPhilipp Reisner 2775b411b363SPhilipp Reisner if (self == peer) { 2776b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2777b411b363SPhilipp Reisner 2778b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2779b411b363SPhilipp Reisner 278031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27814a23f264SPhilipp Reisner return -1091; 2782b411b363SPhilipp Reisner 2783b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2784b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2785b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 27869f2247bbSPhilipp Reisner drbd_uuid_move_history(mdev); 27879f2247bbSPhilipp Reisner mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[UI_BITMAP]; 27889f2247bbSPhilipp Reisner mdev->ldev->md.uuid[UI_BITMAP] = 0; 2789b411b363SPhilipp Reisner 2790b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2791b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2792b411b363SPhilipp Reisner *rule_nr = 34; 2793b411b363SPhilipp Reisner } else { 2794b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2795b411b363SPhilipp Reisner *rule_nr = 36; 2796b411b363SPhilipp Reisner } 2797b411b363SPhilipp Reisner 2798b411b363SPhilipp Reisner return 1; 2799b411b363SPhilipp Reisner } 2800b411b363SPhilipp Reisner 2801b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2802b411b363SPhilipp Reisner 280331890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28044a23f264SPhilipp Reisner return -1091; 2805b411b363SPhilipp Reisner 2806b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2807b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2808b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2809b411b363SPhilipp Reisner 2810b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2811b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2812b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2813b411b363SPhilipp Reisner 2814b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2815b411b363SPhilipp Reisner *rule_nr = 35; 2816b411b363SPhilipp Reisner } else { 2817b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2818b411b363SPhilipp Reisner *rule_nr = 37; 2819b411b363SPhilipp Reisner } 2820b411b363SPhilipp Reisner 2821b411b363SPhilipp Reisner return -1; 2822b411b363SPhilipp Reisner } 2823b411b363SPhilipp Reisner 2824b411b363SPhilipp Reisner /* Common power [off|failure] */ 2825b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2826b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2827b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2828b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2829b411b363SPhilipp Reisner *rule_nr = 40; 2830b411b363SPhilipp Reisner 2831b411b363SPhilipp Reisner switch (rct) { 2832b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2833b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2834b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2835b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 2836427c0434SLars Ellenberg dc = test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags); 2837b411b363SPhilipp Reisner return dc ? -1 : 1; 2838b411b363SPhilipp Reisner } 2839b411b363SPhilipp Reisner } 2840b411b363SPhilipp Reisner 2841b411b363SPhilipp Reisner *rule_nr = 50; 2842b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2843b411b363SPhilipp Reisner if (self == peer) 2844b411b363SPhilipp Reisner return -1; 2845b411b363SPhilipp Reisner 2846b411b363SPhilipp Reisner *rule_nr = 51; 2847b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2848b411b363SPhilipp Reisner if (self == peer) { 284931890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 28504a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 28514a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 28524a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2853b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2854b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2855b411b363SPhilipp Reisner 285631890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28574a23f264SPhilipp Reisner return -1091; 2858b411b363SPhilipp Reisner 2859b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2860b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 28614a23f264SPhilipp Reisner 286292b4ca29SLars Ellenberg dev_info(DEV, "Lost last syncUUID packet, corrected:\n"); 28634a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 28644a23f264SPhilipp Reisner 2865b411b363SPhilipp Reisner return -1; 2866b411b363SPhilipp Reisner } 2867b411b363SPhilipp Reisner } 2868b411b363SPhilipp Reisner 2869b411b363SPhilipp Reisner *rule_nr = 60; 2870b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2871b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2872b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2873b411b363SPhilipp Reisner if (self == peer) 2874b411b363SPhilipp Reisner return -2; 2875b411b363SPhilipp Reisner } 2876b411b363SPhilipp Reisner 2877b411b363SPhilipp Reisner *rule_nr = 70; 2878b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2879b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2880b411b363SPhilipp Reisner if (self == peer) 2881b411b363SPhilipp Reisner return 1; 2882b411b363SPhilipp Reisner 2883b411b363SPhilipp Reisner *rule_nr = 71; 2884b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2885b411b363SPhilipp Reisner if (self == peer) { 288631890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 28874a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 28884a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 28894a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2890b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2891b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2892b411b363SPhilipp Reisner 289331890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28944a23f264SPhilipp Reisner return -1091; 2895b411b363SPhilipp Reisner 28969f2247bbSPhilipp Reisner __drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 28979f2247bbSPhilipp Reisner __drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2898b411b363SPhilipp Reisner 28994a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2900b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2901b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2902b411b363SPhilipp Reisner 2903b411b363SPhilipp Reisner return 1; 2904b411b363SPhilipp Reisner } 2905b411b363SPhilipp Reisner } 2906b411b363SPhilipp Reisner 2907b411b363SPhilipp Reisner 2908b411b363SPhilipp Reisner *rule_nr = 80; 2909d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2910b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2911b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2912b411b363SPhilipp Reisner if (self == peer) 2913b411b363SPhilipp Reisner return 2; 2914b411b363SPhilipp Reisner } 2915b411b363SPhilipp Reisner 2916b411b363SPhilipp Reisner *rule_nr = 90; 2917b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2918b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2919b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2920b411b363SPhilipp Reisner return 100; 2921b411b363SPhilipp Reisner 2922b411b363SPhilipp Reisner *rule_nr = 100; 2923b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2924b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2925b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2926b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2927b411b363SPhilipp Reisner if (self == peer) 2928b411b363SPhilipp Reisner return -100; 2929b411b363SPhilipp Reisner } 2930b411b363SPhilipp Reisner } 2931b411b363SPhilipp Reisner 2932b411b363SPhilipp Reisner return -1000; 2933b411b363SPhilipp Reisner } 2934b411b363SPhilipp Reisner 2935b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2936b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2937b411b363SPhilipp Reisner */ 2938b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2939b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2940b411b363SPhilipp Reisner { 2941b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2942b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 294344ed167dSPhilipp Reisner struct net_conf *nc; 29446dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 2945b411b363SPhilipp Reisner 2946b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2947b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2948b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2949b411b363SPhilipp Reisner 2950b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 29519f2247bbSPhilipp Reisner 29529f2247bbSPhilipp Reisner spin_lock_irq(&mdev->ldev->md.uuid_lock); 2953b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2954b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2955b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2956b411b363SPhilipp Reisner 2957b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 29589f2247bbSPhilipp Reisner spin_unlock_irq(&mdev->ldev->md.uuid_lock); 2959b411b363SPhilipp Reisner 2960b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2961b411b363SPhilipp Reisner 2962b411b363SPhilipp Reisner if (hg == -1000) { 2963b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2964b411b363SPhilipp Reisner return C_MASK; 2965b411b363SPhilipp Reisner } 29664a23f264SPhilipp Reisner if (hg < -1000) { 29674a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2968b411b363SPhilipp Reisner return C_MASK; 2969b411b363SPhilipp Reisner } 2970b411b363SPhilipp Reisner 2971b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2972b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2973b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2974b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2975b411b363SPhilipp Reisner if (f) 2976b411b363SPhilipp Reisner hg = hg*2; 2977b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2978b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2979b411b363SPhilipp Reisner } 2980b411b363SPhilipp Reisner 29813a11a487SAdam Gandelman if (abs(hg) == 100) 29823a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 29833a11a487SAdam Gandelman 298444ed167dSPhilipp Reisner rcu_read_lock(); 298544ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 298644ed167dSPhilipp Reisner 298744ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 2988b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2989b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2990b411b363SPhilipp Reisner int forced = (hg == -100); 2991b411b363SPhilipp Reisner 2992b411b363SPhilipp Reisner switch (pcount) { 2993b411b363SPhilipp Reisner case 0: 2994b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2995b411b363SPhilipp Reisner break; 2996b411b363SPhilipp Reisner case 1: 2997b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2998b411b363SPhilipp Reisner break; 2999b411b363SPhilipp Reisner case 2: 3000b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 3001b411b363SPhilipp Reisner break; 3002b411b363SPhilipp Reisner } 3003b411b363SPhilipp Reisner if (abs(hg) < 100) { 3004b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 3005b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3006b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3007b411b363SPhilipp Reisner if (forced) { 3008b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 3009b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3010b411b363SPhilipp Reisner hg = hg*2; 3011b411b363SPhilipp Reisner } 3012b411b363SPhilipp Reisner } 3013b411b363SPhilipp Reisner } 3014b411b363SPhilipp Reisner 3015b411b363SPhilipp Reisner if (hg == -100) { 301608b165baSPhilipp Reisner if (test_bit(DISCARD_MY_DATA, &mdev->flags) && !(mdev->p_uuid[UI_FLAGS]&1)) 3017b411b363SPhilipp Reisner hg = -1; 301808b165baSPhilipp Reisner if (!test_bit(DISCARD_MY_DATA, &mdev->flags) && (mdev->p_uuid[UI_FLAGS]&1)) 3019b411b363SPhilipp Reisner hg = 1; 3020b411b363SPhilipp Reisner 3021b411b363SPhilipp Reisner if (abs(hg) < 100) 3022b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 3023b411b363SPhilipp Reisner "Sync from %s node\n", 3024b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3025b411b363SPhilipp Reisner } 302644ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 30276dff2902SAndreas Gruenbacher tentative = nc->tentative; 302844ed167dSPhilipp Reisner rcu_read_unlock(); 3029b411b363SPhilipp Reisner 3030b411b363SPhilipp Reisner if (hg == -100) { 3031580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3032580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3033580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3034580b9767SLars Ellenberg * to that disk, in a way... */ 30353a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 3036b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 3037b411b363SPhilipp Reisner return C_MASK; 3038b411b363SPhilipp Reisner } 3039b411b363SPhilipp Reisner 3040b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3041b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 3042b411b363SPhilipp Reisner return C_MASK; 3043b411b363SPhilipp Reisner } 3044b411b363SPhilipp Reisner 3045b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3046b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 304744ed167dSPhilipp Reisner switch (rr_conflict) { 3048b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3049b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 3050b411b363SPhilipp Reisner /* fall through */ 3051b411b363SPhilipp Reisner case ASB_DISCONNECT: 3052b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 3053b411b363SPhilipp Reisner return C_MASK; 3054b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3055b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 3056b411b363SPhilipp Reisner "assumption\n"); 3057b411b363SPhilipp Reisner } 3058b411b363SPhilipp Reisner } 3059b411b363SPhilipp Reisner 30606dff2902SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 3061cf14c2e9SPhilipp Reisner if (hg == 0) 3062cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 3063cf14c2e9SPhilipp Reisner else 3064cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 3065cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3066cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3067cf14c2e9SPhilipp Reisner return C_MASK; 3068cf14c2e9SPhilipp Reisner } 3069cf14c2e9SPhilipp Reisner 3070b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3071b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 307220ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 307320ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3074b411b363SPhilipp Reisner return C_MASK; 3075b411b363SPhilipp Reisner } 3076b411b363SPhilipp Reisner 3077b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3078b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3079b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3080b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3081b411b363SPhilipp Reisner } else { 3082b411b363SPhilipp Reisner rv = C_CONNECTED; 3083b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 3084b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 3085b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 3086b411b363SPhilipp Reisner } 3087b411b363SPhilipp Reisner } 3088b411b363SPhilipp Reisner 3089b411b363SPhilipp Reisner return rv; 3090b411b363SPhilipp Reisner } 3091b411b363SPhilipp Reisner 3092f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3093b411b363SPhilipp Reisner { 3094b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3095f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3096f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3097b411b363SPhilipp Reisner 3098b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3099f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3100f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3101b411b363SPhilipp Reisner 3102b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3103f179d76dSPhilipp Reisner return peer; 3104b411b363SPhilipp Reisner } 3105b411b363SPhilipp Reisner 3106e2857216SAndreas Gruenbacher static int receive_protocol(struct drbd_tconn *tconn, struct packet_info *pi) 3107b411b363SPhilipp Reisner { 3108e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3109036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3110036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3111036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3112036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 3113accdbcc5SAndreas Gruenbacher struct crypto_hash *peer_integrity_tfm = NULL; 31147aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3115b411b363SPhilipp Reisner 3116b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3117b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3118b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3119b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3120b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3121cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 31226139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3123cf14c2e9SPhilipp Reisner 312486db0618SAndreas Gruenbacher if (tconn->agreed_pro_version >= 87) { 312586db0618SAndreas Gruenbacher int err; 312686db0618SAndreas Gruenbacher 312788104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 312886db0618SAndreas Gruenbacher return -EIO; 312988104ca4SAndreas Gruenbacher err = drbd_recv_all(tconn, integrity_alg, pi->size); 313086db0618SAndreas Gruenbacher if (err) 313186db0618SAndreas Gruenbacher return err; 313288104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3133036b17eaSPhilipp Reisner } 313486db0618SAndreas Gruenbacher 31357d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 31367204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 3137cf14c2e9SPhilipp Reisner 3138cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 31397204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 3140b411b363SPhilipp Reisner 314144ed167dSPhilipp Reisner rcu_read_lock(); 314244ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 314344ed167dSPhilipp Reisner 3144036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 3145d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "protocol"); 314644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3147b411b363SPhilipp Reisner } 3148b411b363SPhilipp Reisner 3149f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 3150d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-0pri"); 315144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3152b411b363SPhilipp Reisner } 3153b411b363SPhilipp Reisner 3154f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 3155d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-1pri"); 315644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3157b411b363SPhilipp Reisner } 3158b411b363SPhilipp Reisner 3159f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 3160d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-2pri"); 316144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3162b411b363SPhilipp Reisner } 3163b411b363SPhilipp Reisner 31646139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 3165d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "discard-my-data"); 316644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3167b411b363SPhilipp Reisner } 3168b411b363SPhilipp Reisner 316944ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 3170d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "allow-two-primaries"); 317144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3172b411b363SPhilipp Reisner } 3173b411b363SPhilipp Reisner 3174036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 3175d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "data-integrity-alg"); 3176036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3177036b17eaSPhilipp Reisner } 3178036b17eaSPhilipp Reisner 317986db0618SAndreas Gruenbacher rcu_read_unlock(); 3180fbc12f45SAndreas Gruenbacher } 31817d4c782cSAndreas Gruenbacher 31827d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 31837d4c782cSAndreas Gruenbacher int hash_size; 31847d4c782cSAndreas Gruenbacher 31857d4c782cSAndreas Gruenbacher /* 31867d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 31877d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 31887d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 31897d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 31907d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 31917d4c782cSAndreas Gruenbacher * change. 31927d4c782cSAndreas Gruenbacher */ 31937d4c782cSAndreas Gruenbacher 31947d4c782cSAndreas Gruenbacher peer_integrity_tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 31957d4c782cSAndreas Gruenbacher if (!peer_integrity_tfm) { 31967d4c782cSAndreas Gruenbacher conn_err(tconn, "peer data-integrity-alg %s not supported\n", 31977d4c782cSAndreas Gruenbacher integrity_alg); 3198b411b363SPhilipp Reisner goto disconnect; 3199b411b363SPhilipp Reisner } 3200b411b363SPhilipp Reisner 32017d4c782cSAndreas Gruenbacher hash_size = crypto_hash_digestsize(peer_integrity_tfm); 32027d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 32037d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 32047d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 32057d4c782cSAndreas Gruenbacher conn_err(tconn, "Allocation of buffers for data integrity checking failed\n"); 32067d4c782cSAndreas Gruenbacher goto disconnect; 32077d4c782cSAndreas Gruenbacher } 32087d4c782cSAndreas Gruenbacher } 32097d4c782cSAndreas Gruenbacher 32107d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 32117d4c782cSAndreas Gruenbacher if (!new_net_conf) { 32127d4c782cSAndreas Gruenbacher conn_err(tconn, "Allocation of new net_conf failed\n"); 3213b411b363SPhilipp Reisner goto disconnect; 3214b411b363SPhilipp Reisner } 3215b411b363SPhilipp Reisner 32167d4c782cSAndreas Gruenbacher mutex_lock(&tconn->data.mutex); 32177d4c782cSAndreas Gruenbacher mutex_lock(&tconn->conf_update); 32187d4c782cSAndreas Gruenbacher old_net_conf = tconn->net_conf; 32197d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 3220b411b363SPhilipp Reisner 32217d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 32227d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 32237d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 32247d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 32257d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 3226b411b363SPhilipp Reisner 32277d4c782cSAndreas Gruenbacher rcu_assign_pointer(tconn->net_conf, new_net_conf); 32287d4c782cSAndreas Gruenbacher mutex_unlock(&tconn->conf_update); 32297d4c782cSAndreas Gruenbacher mutex_unlock(&tconn->data.mutex); 3230b411b363SPhilipp Reisner 32317d4c782cSAndreas Gruenbacher crypto_free_hash(tconn->peer_integrity_tfm); 32327d4c782cSAndreas Gruenbacher kfree(tconn->int_dig_in); 32337d4c782cSAndreas Gruenbacher kfree(tconn->int_dig_vv); 32347d4c782cSAndreas Gruenbacher tconn->peer_integrity_tfm = peer_integrity_tfm; 32357d4c782cSAndreas Gruenbacher tconn->int_dig_in = int_dig_in; 32367d4c782cSAndreas Gruenbacher tconn->int_dig_vv = int_dig_vv; 3237b411b363SPhilipp Reisner 32387d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 32397d4c782cSAndreas Gruenbacher conn_info(tconn, "peer data-integrity-alg: %s\n", 32407d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 3241b411b363SPhilipp Reisner 32427d4c782cSAndreas Gruenbacher synchronize_rcu(); 32437d4c782cSAndreas Gruenbacher kfree(old_net_conf); 324482bc0194SAndreas Gruenbacher return 0; 3245b411b363SPhilipp Reisner 324644ed167dSPhilipp Reisner disconnect_rcu_unlock: 324744ed167dSPhilipp Reisner rcu_read_unlock(); 3248b411b363SPhilipp Reisner disconnect: 3249b792c35cSAndreas Gruenbacher crypto_free_hash(peer_integrity_tfm); 3250036b17eaSPhilipp Reisner kfree(int_dig_in); 3251036b17eaSPhilipp Reisner kfree(int_dig_vv); 32527204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 325382bc0194SAndreas Gruenbacher return -EIO; 3254b411b363SPhilipp Reisner } 3255b411b363SPhilipp Reisner 3256b411b363SPhilipp Reisner /* helper function 3257b411b363SPhilipp Reisner * input: alg name, feature name 3258b411b363SPhilipp Reisner * return: NULL (alg name was "") 3259b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3260b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 3261f63e631aSRashika Kheria static 3262b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 3263b411b363SPhilipp Reisner const char *alg, const char *name) 3264b411b363SPhilipp Reisner { 3265b411b363SPhilipp Reisner struct crypto_hash *tfm; 3266b411b363SPhilipp Reisner 3267b411b363SPhilipp Reisner if (!alg[0]) 3268b411b363SPhilipp Reisner return NULL; 3269b411b363SPhilipp Reisner 3270b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3271b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3272b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3273b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3274b411b363SPhilipp Reisner return tfm; 3275b411b363SPhilipp Reisner } 3276b411b363SPhilipp Reisner return tfm; 3277b411b363SPhilipp Reisner } 3278b411b363SPhilipp Reisner 32794a76b161SAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_tconn *tconn, struct packet_info *pi) 3280b411b363SPhilipp Reisner { 32814a76b161SAndreas Gruenbacher void *buffer = tconn->data.rbuf; 32824a76b161SAndreas Gruenbacher int size = pi->size; 32834a76b161SAndreas Gruenbacher 32844a76b161SAndreas Gruenbacher while (size) { 32854a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 32864a76b161SAndreas Gruenbacher s = drbd_recv(tconn, buffer, s); 32874a76b161SAndreas Gruenbacher if (s <= 0) { 32884a76b161SAndreas Gruenbacher if (s < 0) 32894a76b161SAndreas Gruenbacher return s; 32904a76b161SAndreas Gruenbacher break; 32914a76b161SAndreas Gruenbacher } 32924a76b161SAndreas Gruenbacher size -= s; 32934a76b161SAndreas Gruenbacher } 32944a76b161SAndreas Gruenbacher if (size) 32954a76b161SAndreas Gruenbacher return -EIO; 32964a76b161SAndreas Gruenbacher return 0; 32974a76b161SAndreas Gruenbacher } 32984a76b161SAndreas Gruenbacher 32994a76b161SAndreas Gruenbacher /* 33004a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 33014a76b161SAndreas Gruenbacher * 33024a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 33034a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 33044a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 33054a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 33064a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 33074a76b161SAndreas Gruenbacher * 33084a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 33094a76b161SAndreas Gruenbacher */ 33104a76b161SAndreas Gruenbacher static int config_unknown_volume(struct drbd_tconn *tconn, struct packet_info *pi) 33114a76b161SAndreas Gruenbacher { 33122fcb8f30SAndreas Gruenbacher conn_warn(tconn, "%s packet received for volume %u, which is not configured locally\n", 33132fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 33144a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 33154a76b161SAndreas Gruenbacher } 33164a76b161SAndreas Gruenbacher 33174a76b161SAndreas Gruenbacher static int receive_SyncParam(struct drbd_tconn *tconn, struct packet_info *pi) 33184a76b161SAndreas Gruenbacher { 33194a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3320e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3321b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3322b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3323b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 33242ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3325813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 33264a76b161SAndreas Gruenbacher const int apv = tconn->agreed_pro_version; 3327813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3328778f271dSPhilipp Reisner int fifo_size = 0; 332982bc0194SAndreas Gruenbacher int err; 3330b411b363SPhilipp Reisner 33314a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 33324a76b161SAndreas Gruenbacher if (!mdev) 33334a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 3334b411b363SPhilipp Reisner 3335b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3336b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3337b411b363SPhilipp Reisner + SHARED_SECRET_MAX 33388e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 33398e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3340b411b363SPhilipp Reisner 3341e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3342b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3343e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 334482bc0194SAndreas Gruenbacher return -EIO; 3345b411b363SPhilipp Reisner } 3346b411b363SPhilipp Reisner 3347b411b363SPhilipp Reisner if (apv <= 88) { 3348e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3349e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 33508e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3351e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3352e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3353b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 33548e26f9ccSPhilipp Reisner } else { 3355e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3356e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3357b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 3358b411b363SPhilipp Reisner } 3359b411b363SPhilipp Reisner 3360b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3361e658983aSAndreas Gruenbacher p = pi->data; 3362b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3363b411b363SPhilipp Reisner 3364e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, header_size); 336582bc0194SAndreas Gruenbacher if (err) 336682bc0194SAndreas Gruenbacher return err; 3367b411b363SPhilipp Reisner 3368813472ceSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3369813472ceSPhilipp Reisner old_net_conf = mdev->tconn->net_conf; 3370813472ceSPhilipp Reisner if (get_ldev(mdev)) { 3371daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3372daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3373813472ceSPhilipp Reisner put_ldev(mdev); 3374813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3375daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3376daeda1ccSPhilipp Reisner return -ENOMEM; 3377f399002eSLars Ellenberg } 3378b411b363SPhilipp Reisner 3379daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3380daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3381daeda1ccSPhilipp Reisner 33826394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3383813472ceSPhilipp Reisner } 3384b411b363SPhilipp Reisner 3385b411b363SPhilipp Reisner if (apv >= 88) { 3386b411b363SPhilipp Reisner if (apv == 88) { 33875de73827SPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 33885de73827SPhilipp Reisner dev_err(DEV, "verify-alg of wrong size, " 33895de73827SPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3390b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3391813472ceSPhilipp Reisner err = -EIO; 3392813472ceSPhilipp Reisner goto reconnect; 3393b411b363SPhilipp Reisner } 3394b411b363SPhilipp Reisner 339582bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size); 3396813472ceSPhilipp Reisner if (err) 3397813472ceSPhilipp Reisner goto reconnect; 3398b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3399b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3400b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3401b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3402b411b363SPhilipp Reisner 3403b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3404b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3405b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3406b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3407b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3408b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3409b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3410b411b363SPhilipp Reisner } 3411b411b363SPhilipp Reisner 34122ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3413b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3414b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 34152ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3416b411b363SPhilipp Reisner goto disconnect; 3417b411b363SPhilipp Reisner } 3418b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3419b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3420b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3421b411b363SPhilipp Reisner verify_tfm = NULL; 3422b411b363SPhilipp Reisner goto disconnect; 3423b411b363SPhilipp Reisner } 3424b411b363SPhilipp Reisner } 3425b411b363SPhilipp Reisner 34262ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3427b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3428b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 34292ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3430b411b363SPhilipp Reisner goto disconnect; 3431b411b363SPhilipp Reisner } 3432b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3433b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3434b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3435b411b363SPhilipp Reisner csums_tfm = NULL; 3436b411b363SPhilipp Reisner goto disconnect; 3437b411b363SPhilipp Reisner } 3438b411b363SPhilipp Reisner } 3439b411b363SPhilipp Reisner 3440813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3441daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3442daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3443daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3444daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3445778f271dSPhilipp Reisner 3446daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 34479958c857SPhilipp Reisner if (fifo_size != mdev->rs_plan_s->size) { 3448813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3449813472ceSPhilipp Reisner if (!new_plan) { 3450778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3451f399002eSLars Ellenberg put_ldev(mdev); 3452778f271dSPhilipp Reisner goto disconnect; 3453778f271dSPhilipp Reisner } 3454778f271dSPhilipp Reisner } 34558e26f9ccSPhilipp Reisner } 3456b411b363SPhilipp Reisner 345791fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 34582ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 34592ec91e0eSPhilipp Reisner if (!new_net_conf) { 346091fd4dadSPhilipp Reisner dev_err(DEV, "Allocation of new net_conf failed\n"); 346191fd4dadSPhilipp Reisner goto disconnect; 346291fd4dadSPhilipp Reisner } 346391fd4dadSPhilipp Reisner 34642ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 346591fd4dadSPhilipp Reisner 3466b411b363SPhilipp Reisner if (verify_tfm) { 34672ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 34682ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3469f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3470f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3471b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3472b411b363SPhilipp Reisner } 3473b411b363SPhilipp Reisner if (csums_tfm) { 34742ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 34752ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3476f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3477f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3478b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3479b411b363SPhilipp Reisner } 34802ec91e0eSPhilipp Reisner rcu_assign_pointer(tconn->net_conf, new_net_conf); 3481778f271dSPhilipp Reisner } 3482b411b363SPhilipp Reisner } 3483b411b363SPhilipp Reisner 3484813472ceSPhilipp Reisner if (new_disk_conf) { 3485daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3486813472ceSPhilipp Reisner put_ldev(mdev); 3487b411b363SPhilipp Reisner } 3488813472ceSPhilipp Reisner 3489813472ceSPhilipp Reisner if (new_plan) { 3490813472ceSPhilipp Reisner old_plan = mdev->rs_plan_s; 3491813472ceSPhilipp Reisner rcu_assign_pointer(mdev->rs_plan_s, new_plan); 3492813472ceSPhilipp Reisner } 3493daeda1ccSPhilipp Reisner 3494daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3495daeda1ccSPhilipp Reisner synchronize_rcu(); 3496daeda1ccSPhilipp Reisner if (new_net_conf) 3497daeda1ccSPhilipp Reisner kfree(old_net_conf); 3498daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3499813472ceSPhilipp Reisner kfree(old_plan); 3500daeda1ccSPhilipp Reisner 350182bc0194SAndreas Gruenbacher return 0; 3502b411b363SPhilipp Reisner 3503813472ceSPhilipp Reisner reconnect: 3504813472ceSPhilipp Reisner if (new_disk_conf) { 3505813472ceSPhilipp Reisner put_ldev(mdev); 3506813472ceSPhilipp Reisner kfree(new_disk_conf); 3507813472ceSPhilipp Reisner } 3508813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3509813472ceSPhilipp Reisner return -EIO; 3510813472ceSPhilipp Reisner 3511b411b363SPhilipp Reisner disconnect: 3512813472ceSPhilipp Reisner kfree(new_plan); 3513813472ceSPhilipp Reisner if (new_disk_conf) { 3514813472ceSPhilipp Reisner put_ldev(mdev); 3515813472ceSPhilipp Reisner kfree(new_disk_conf); 3516813472ceSPhilipp Reisner } 3517a0095508SPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3518b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3519b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3520b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3521b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3522b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 352338fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 352482bc0194SAndreas Gruenbacher return -EIO; 3525b411b363SPhilipp Reisner } 3526b411b363SPhilipp Reisner 3527b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3528b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3529b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3530b411b363SPhilipp Reisner { 3531b411b363SPhilipp Reisner sector_t d; 3532b411b363SPhilipp Reisner if (a == 0 || b == 0) 3533b411b363SPhilipp Reisner return; 3534b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3535b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3536b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3537b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3538b411b363SPhilipp Reisner } 3539b411b363SPhilipp Reisner 35404a76b161SAndreas Gruenbacher static int receive_sizes(struct drbd_tconn *tconn, struct packet_info *pi) 3541b411b363SPhilipp Reisner { 35424a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3543e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3544e96c9633SPhilipp Reisner enum determine_dev_size dd = DS_UNCHANGED; 3545b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3546b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3547e89b591cSPhilipp Reisner enum dds_flags ddsf; 3548b411b363SPhilipp Reisner 35494a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 35504a76b161SAndreas Gruenbacher if (!mdev) 35514a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 35524a76b161SAndreas Gruenbacher 3553b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3554b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3555b411b363SPhilipp Reisner 3556b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3557b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3558b411b363SPhilipp Reisner mdev->p_size = p_size; 3559b411b363SPhilipp Reisner 3560b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3561daeda1ccSPhilipp Reisner rcu_read_lock(); 3562daeda1ccSPhilipp Reisner my_usize = rcu_dereference(mdev->ldev->disk_conf)->disk_size; 3563daeda1ccSPhilipp Reisner rcu_read_unlock(); 3564daeda1ccSPhilipp Reisner 3565b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3566b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3567b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3568daeda1ccSPhilipp Reisner p_usize, my_usize); 3569b411b363SPhilipp Reisner 3570b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3571b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3572b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3573daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3574b411b363SPhilipp Reisner 3575b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3576b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3577ef5e44a6SPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, p_usize, 0) < 3578b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3579b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3580b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3581b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 358238fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3583b411b363SPhilipp Reisner put_ldev(mdev); 358482bc0194SAndreas Gruenbacher return -EIO; 3585b411b363SPhilipp Reisner } 3586daeda1ccSPhilipp Reisner 3587daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3588daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3589daeda1ccSPhilipp Reisner 3590daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3591daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3592daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3593daeda1ccSPhilipp Reisner put_ldev(mdev); 3594daeda1ccSPhilipp Reisner return -ENOMEM; 3595daeda1ccSPhilipp Reisner } 3596daeda1ccSPhilipp Reisner 3597daeda1ccSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3598daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3599daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3600daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3601daeda1ccSPhilipp Reisner 3602daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3603daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3604daeda1ccSPhilipp Reisner synchronize_rcu(); 3605daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3606daeda1ccSPhilipp Reisner 3607daeda1ccSPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3608daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3609daeda1ccSPhilipp Reisner } 3610daeda1ccSPhilipp Reisner 3611b411b363SPhilipp Reisner put_ldev(mdev); 3612b411b363SPhilipp Reisner } 3613b411b363SPhilipp Reisner 3614e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3615b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3616d752b269SPhilipp Reisner dd = drbd_determine_dev_size(mdev, ddsf, NULL); 3617b411b363SPhilipp Reisner put_ldev(mdev); 3618e96c9633SPhilipp Reisner if (dd == DS_ERROR) 361982bc0194SAndreas Gruenbacher return -EIO; 3620b411b363SPhilipp Reisner drbd_md_sync(mdev); 3621b411b363SPhilipp Reisner } else { 3622b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3623b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3624b411b363SPhilipp Reisner } 3625b411b363SPhilipp Reisner 362699432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 362799432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 362899432fccSPhilipp Reisner 3629b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3630b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3631b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3632b411b363SPhilipp Reisner ldsc = 1; 3633b411b363SPhilipp Reisner } 3634b411b363SPhilipp Reisner 3635b411b363SPhilipp Reisner put_ldev(mdev); 3636b411b363SPhilipp Reisner } 3637b411b363SPhilipp Reisner 3638b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3639b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3640b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3641b411b363SPhilipp Reisner /* we have different sizes, probably peer 3642b411b363SPhilipp Reisner * needs to know my new size... */ 3643e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3644b411b363SPhilipp Reisner } 3645b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3646e96c9633SPhilipp Reisner (dd == DS_GREW && mdev->state.conn == C_CONNECTED)) { 3647b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3648e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3649e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3650e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3651b411b363SPhilipp Reisner else 3652e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3653e89b591cSPhilipp Reisner } else 3654b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3655b411b363SPhilipp Reisner } 3656b411b363SPhilipp Reisner } 3657b411b363SPhilipp Reisner 365882bc0194SAndreas Gruenbacher return 0; 3659b411b363SPhilipp Reisner } 3660b411b363SPhilipp Reisner 36614a76b161SAndreas Gruenbacher static int receive_uuids(struct drbd_tconn *tconn, struct packet_info *pi) 3662b411b363SPhilipp Reisner { 36634a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3664e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3665b411b363SPhilipp Reisner u64 *p_uuid; 366662b0da3aSLars Ellenberg int i, updated_uuids = 0; 3667b411b363SPhilipp Reisner 36684a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 36694a76b161SAndreas Gruenbacher if (!mdev) 36704a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 36714a76b161SAndreas Gruenbacher 3672b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3673063eacf8SJing Wang if (!p_uuid) { 3674063eacf8SJing Wang dev_err(DEV, "kmalloc of p_uuid failed\n"); 3675063eacf8SJing Wang return false; 3676063eacf8SJing Wang } 3677b411b363SPhilipp Reisner 3678b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3679b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3680b411b363SPhilipp Reisner 3681b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3682b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3683b411b363SPhilipp Reisner 3684b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3685b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3686b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3687b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3688b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3689b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 369038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 369182bc0194SAndreas Gruenbacher return -EIO; 3692b411b363SPhilipp Reisner } 3693b411b363SPhilipp Reisner 3694b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3695b411b363SPhilipp Reisner int skip_initial_sync = 3696b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 369731890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3698b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3699b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3700b411b363SPhilipp Reisner if (skip_initial_sync) { 3701b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3702b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 370320ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 370420ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3705b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3706b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3707b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3708b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3709b411b363SPhilipp Reisner drbd_md_sync(mdev); 371062b0da3aSLars Ellenberg updated_uuids = 1; 3711b411b363SPhilipp Reisner } 3712b411b363SPhilipp Reisner put_ldev(mdev); 371318a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 371418a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 371518a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 371618a50fa2SPhilipp Reisner for me. */ 371762b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3718b411b363SPhilipp Reisner } 3719b411b363SPhilipp Reisner 3720b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3721b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3722b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3723b411b363SPhilipp Reisner new disk state... */ 37248410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 37258410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3726b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 372762b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 372862b0da3aSLars Ellenberg 372962b0da3aSLars Ellenberg if (updated_uuids) 373062b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3731b411b363SPhilipp Reisner 373282bc0194SAndreas Gruenbacher return 0; 3733b411b363SPhilipp Reisner } 3734b411b363SPhilipp Reisner 3735b411b363SPhilipp Reisner /** 3736b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3737b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3738b411b363SPhilipp Reisner */ 3739b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3740b411b363SPhilipp Reisner { 3741b411b363SPhilipp Reisner union drbd_state ms; 3742b411b363SPhilipp Reisner 3743b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3744369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 3745b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3746b411b363SPhilipp Reisner 3747b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3748b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3749b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3750b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3751b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3752b411b363SPhilipp Reisner }; 3753b411b363SPhilipp Reisner 3754b411b363SPhilipp Reisner ms.i = ps.i; 3755b411b363SPhilipp Reisner 3756b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3757b411b363SPhilipp Reisner ms.peer = ps.role; 3758b411b363SPhilipp Reisner ms.role = ps.peer; 3759b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3760b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3761b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3762b411b363SPhilipp Reisner 3763b411b363SPhilipp Reisner return ms; 3764b411b363SPhilipp Reisner } 3765b411b363SPhilipp Reisner 37664a76b161SAndreas Gruenbacher static int receive_req_state(struct drbd_tconn *tconn, struct packet_info *pi) 3767b411b363SPhilipp Reisner { 37684a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3769e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3770b411b363SPhilipp Reisner union drbd_state mask, val; 3771bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3772b411b363SPhilipp Reisner 37734a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 37744a76b161SAndreas Gruenbacher if (!mdev) 37754a76b161SAndreas Gruenbacher return -EIO; 37764a76b161SAndreas Gruenbacher 3777b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3778b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3779b411b363SPhilipp Reisner 3780427c0434SLars Ellenberg if (test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags) && 37818410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3782b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 378382bc0194SAndreas Gruenbacher return 0; 3784b411b363SPhilipp Reisner } 3785b411b363SPhilipp Reisner 3786b411b363SPhilipp Reisner mask = convert_state(mask); 3787b411b363SPhilipp Reisner val = convert_state(val); 3788b411b363SPhilipp Reisner 3789b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3790b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3791047cd4a6SPhilipp Reisner 3792b411b363SPhilipp Reisner drbd_md_sync(mdev); 3793b411b363SPhilipp Reisner 379482bc0194SAndreas Gruenbacher return 0; 3795b411b363SPhilipp Reisner } 3796b411b363SPhilipp Reisner 3797e2857216SAndreas Gruenbacher static int receive_req_conn_state(struct drbd_tconn *tconn, struct packet_info *pi) 3798b411b363SPhilipp Reisner { 3799e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3800dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3801dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3802dfafcc8aSPhilipp Reisner 3803dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3804dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3805dfafcc8aSPhilipp Reisner 3806427c0434SLars Ellenberg if (test_bit(RESOLVE_CONFLICTS, &tconn->flags) && 3807dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3808dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 380982bc0194SAndreas Gruenbacher return 0; 3810dfafcc8aSPhilipp Reisner } 3811dfafcc8aSPhilipp Reisner 3812dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3813dfafcc8aSPhilipp Reisner val = convert_state(val); 3814dfafcc8aSPhilipp Reisner 3815778bcf2eSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3816dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3817dfafcc8aSPhilipp Reisner 381882bc0194SAndreas Gruenbacher return 0; 3819dfafcc8aSPhilipp Reisner } 3820dfafcc8aSPhilipp Reisner 38214a76b161SAndreas Gruenbacher static int receive_state(struct drbd_tconn *tconn, struct packet_info *pi) 3822b411b363SPhilipp Reisner { 38234a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3824e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 38254ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3826b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 382765d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3828b411b363SPhilipp Reisner int rv; 3829b411b363SPhilipp Reisner 38304a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 38314a76b161SAndreas Gruenbacher if (!mdev) 38324a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 38334a76b161SAndreas Gruenbacher 3834b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3835b411b363SPhilipp Reisner 3836b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3837b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3838b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3839b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3840b411b363SPhilipp Reisner } 3841b411b363SPhilipp Reisner 384287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3843b411b363SPhilipp Reisner retry: 384478bae59bSPhilipp Reisner os = ns = drbd_read_state(mdev); 384587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3846b411b363SPhilipp Reisner 3847545752d5SLars Ellenberg /* If some other part of the code (asender thread, timeout) 3848545752d5SLars Ellenberg * already decided to close the connection again, 3849545752d5SLars Ellenberg * we must not "re-establish" it here. */ 3850545752d5SLars Ellenberg if (os.conn <= C_TEAR_DOWN) 385158ffa580SLars Ellenberg return -ECONNRESET; 3852545752d5SLars Ellenberg 385340424e4aSLars Ellenberg /* If this is the "end of sync" confirmation, usually the peer disk 385440424e4aSLars Ellenberg * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 385540424e4aSLars Ellenberg * set) resync started in PausedSyncT, or if the timing of pause-/ 385640424e4aSLars Ellenberg * unpause-sync events has been "just right", the peer disk may 385740424e4aSLars Ellenberg * transition from D_CONSISTENT to D_UP_TO_DATE as well. 385840424e4aSLars Ellenberg */ 385940424e4aSLars Ellenberg if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 386040424e4aSLars Ellenberg real_peer_disk == D_UP_TO_DATE && 3861e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3862e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3863e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3864e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3865e9ef7bb6SLars Ellenberg * syncing states. 3866e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3867e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3868e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3869e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3870e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3871e9ef7bb6SLars Ellenberg 3872e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3873e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3874e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3875e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3876e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3877e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3878e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 387982bc0194SAndreas Gruenbacher return 0; 3880e9ef7bb6SLars Ellenberg } 3881e9ef7bb6SLars Ellenberg } 3882e9ef7bb6SLars Ellenberg 388302b91b55SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 388402b91b55SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 388502b91b55SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 388658ffa580SLars Ellenberg ov_out_of_sync_print(mdev); 388702b91b55SLars Ellenberg drbd_resync_finished(mdev); 388858ffa580SLars Ellenberg return 0; 388902b91b55SLars Ellenberg } 389002b91b55SLars Ellenberg 3891e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3892e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3893e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3894e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3895e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3896e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3897e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3898e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3899e9ef7bb6SLars Ellenberg 39004ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 39014ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3902b411b363SPhilipp Reisner 390367531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 390467531718SPhilipp Reisner ns.conn = C_BEHIND; 390567531718SPhilipp Reisner 3906b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3907b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3908b411b363SPhilipp Reisner int cr; /* consider resync */ 3909b411b363SPhilipp Reisner 3910b411b363SPhilipp Reisner /* if we established a new connection */ 39114ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3912b411b363SPhilipp Reisner /* if we had an established connection 3913b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 39144ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3915b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 39164ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3917b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3918b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3919b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3920b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3921b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 39224ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3923b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3924b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3925b411b363SPhilipp Reisner 3926b411b363SPhilipp Reisner if (cr) 39274ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3928b411b363SPhilipp Reisner 3929b411b363SPhilipp Reisner put_ldev(mdev); 39304ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 39314ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3932b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 393382f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3934b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3935b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3936b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3937580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3938b411b363SPhilipp Reisner } else { 39398169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 394082bc0194SAndreas Gruenbacher return -EIO; 39414ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 394238fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 394382bc0194SAndreas Gruenbacher return -EIO; 3944b411b363SPhilipp Reisner } 3945b411b363SPhilipp Reisner } 3946b411b363SPhilipp Reisner } 3947b411b363SPhilipp Reisner 394887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 394978bae59bSPhilipp Reisner if (os.i != drbd_read_state(mdev).i) 3950b411b363SPhilipp Reisner goto retry; 3951b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3952b411b363SPhilipp Reisner ns.peer = peer_state.role; 3953b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3954b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 39554ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3956b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 39574ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 39582aebfabbSPhilipp Reisner if (ns.pdsk == D_CONSISTENT && drbd_suspended(mdev) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3959481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 39608554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3961481c6f50SPhilipp Reisner for temporal network outages! */ 396287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3963481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 39642f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3965481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3966481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 396738fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 396882bc0194SAndreas Gruenbacher return -EIO; 3969481c6f50SPhilipp Reisner } 397065d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 397178bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 397287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3973b411b363SPhilipp Reisner 3974b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 397538fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 397682bc0194SAndreas Gruenbacher return -EIO; 3977b411b363SPhilipp Reisner } 3978b411b363SPhilipp Reisner 39794ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 39804ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3981b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3982b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3983b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3984b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3985b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3986f479ea06SLars Ellenberg drbd_send_current_state(mdev); 3987b411b363SPhilipp Reisner } 3988b411b363SPhilipp Reisner } 3989b411b363SPhilipp Reisner 399008b165baSPhilipp Reisner clear_bit(DISCARD_MY_DATA, &mdev->flags); 3991b411b363SPhilipp Reisner 3992cccac985SLars Ellenberg drbd_md_sync(mdev); /* update connected indicator, la_size_sect, ... */ 3993b411b363SPhilipp Reisner 399482bc0194SAndreas Gruenbacher return 0; 3995b411b363SPhilipp Reisner } 3996b411b363SPhilipp Reisner 39974a76b161SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_tconn *tconn, struct packet_info *pi) 3998b411b363SPhilipp Reisner { 39994a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4000e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 40014a76b161SAndreas Gruenbacher 40024a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 40034a76b161SAndreas Gruenbacher if (!mdev) 40044a76b161SAndreas Gruenbacher return -EIO; 4005b411b363SPhilipp Reisner 4006b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 4007b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 4008c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 4009b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 4010b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 4011b411b363SPhilipp Reisner 4012b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 4013b411b363SPhilipp Reisner 4014b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4015b411b363SPhilipp Reisner _not_ be rotated into the history */ 4016b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 4017b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 4018b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 4019b411b363SPhilipp Reisner 402062b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 4021b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 4022b411b363SPhilipp Reisner 4023b411b363SPhilipp Reisner put_ldev(mdev); 4024b411b363SPhilipp Reisner } else 4025b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 4026b411b363SPhilipp Reisner 402782bc0194SAndreas Gruenbacher return 0; 4028b411b363SPhilipp Reisner } 4029b411b363SPhilipp Reisner 40302c46407dSAndreas Gruenbacher /** 40312c46407dSAndreas Gruenbacher * receive_bitmap_plain 40322c46407dSAndreas Gruenbacher * 40332c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40342c46407dSAndreas Gruenbacher * code upon failure. 40352c46407dSAndreas Gruenbacher */ 40362c46407dSAndreas Gruenbacher static int 403750d0b1adSAndreas Gruenbacher receive_bitmap_plain(struct drbd_conf *mdev, unsigned int size, 4038e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4039b411b363SPhilipp Reisner { 404050d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 404150d0b1adSAndreas Gruenbacher drbd_header_size(mdev->tconn); 4042e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 404350d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4044e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 40452c46407dSAndreas Gruenbacher int err; 4046b411b363SPhilipp Reisner 404750d0b1adSAndreas Gruenbacher if (want != size) { 404850d0b1adSAndreas Gruenbacher dev_err(DEV, "%s:want (%u) != size (%u)\n", __func__, want, size); 40492c46407dSAndreas Gruenbacher return -EIO; 4050b411b363SPhilipp Reisner } 4051b411b363SPhilipp Reisner if (want == 0) 40522c46407dSAndreas Gruenbacher return 0; 4053e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, want); 405482bc0194SAndreas Gruenbacher if (err) 40552c46407dSAndreas Gruenbacher return err; 4056b411b363SPhilipp Reisner 4057e658983aSAndreas Gruenbacher drbd_bm_merge_lel(mdev, c->word_offset, num_words, p); 4058b411b363SPhilipp Reisner 4059b411b363SPhilipp Reisner c->word_offset += num_words; 4060b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4061b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4062b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4063b411b363SPhilipp Reisner 40642c46407dSAndreas Gruenbacher return 1; 4065b411b363SPhilipp Reisner } 4066b411b363SPhilipp Reisner 4067a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4068a02d1240SAndreas Gruenbacher { 4069a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4070a02d1240SAndreas Gruenbacher } 4071a02d1240SAndreas Gruenbacher 4072a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4073a02d1240SAndreas Gruenbacher { 4074a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4075a02d1240SAndreas Gruenbacher } 4076a02d1240SAndreas Gruenbacher 4077a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4078a02d1240SAndreas Gruenbacher { 4079a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4080a02d1240SAndreas Gruenbacher } 4081a02d1240SAndreas Gruenbacher 40822c46407dSAndreas Gruenbacher /** 40832c46407dSAndreas Gruenbacher * recv_bm_rle_bits 40842c46407dSAndreas Gruenbacher * 40852c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40862c46407dSAndreas Gruenbacher * code upon failure. 40872c46407dSAndreas Gruenbacher */ 40882c46407dSAndreas Gruenbacher static int 4089b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 4090b411b363SPhilipp Reisner struct p_compressed_bm *p, 4091c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4092c6d25cfeSPhilipp Reisner unsigned int len) 4093b411b363SPhilipp Reisner { 4094b411b363SPhilipp Reisner struct bitstream bs; 4095b411b363SPhilipp Reisner u64 look_ahead; 4096b411b363SPhilipp Reisner u64 rl; 4097b411b363SPhilipp Reisner u64 tmp; 4098b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4099b411b363SPhilipp Reisner unsigned long e; 4100a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4101b411b363SPhilipp Reisner int have; 4102b411b363SPhilipp Reisner int bits; 4103b411b363SPhilipp Reisner 4104a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4105b411b363SPhilipp Reisner 4106b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4107b411b363SPhilipp Reisner if (bits < 0) 41082c46407dSAndreas Gruenbacher return -EIO; 4109b411b363SPhilipp Reisner 4110b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4111b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4112b411b363SPhilipp Reisner if (bits <= 0) 41132c46407dSAndreas Gruenbacher return -EIO; 4114b411b363SPhilipp Reisner 4115b411b363SPhilipp Reisner if (toggle) { 4116b411b363SPhilipp Reisner e = s + rl -1; 4117b411b363SPhilipp Reisner if (e >= c->bm_bits) { 4118b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 41192c46407dSAndreas Gruenbacher return -EIO; 4120b411b363SPhilipp Reisner } 4121b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 4122b411b363SPhilipp Reisner } 4123b411b363SPhilipp Reisner 4124b411b363SPhilipp Reisner if (have < bits) { 4125b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4126b411b363SPhilipp Reisner have, bits, look_ahead, 4127b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4128b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 41292c46407dSAndreas Gruenbacher return -EIO; 4130b411b363SPhilipp Reisner } 4131d2da5b0cSLars Ellenberg /* if we consumed all 64 bits, assign 0; >> 64 is "undefined"; */ 4132d2da5b0cSLars Ellenberg if (likely(bits < 64)) 4133b411b363SPhilipp Reisner look_ahead >>= bits; 4134d2da5b0cSLars Ellenberg else 4135d2da5b0cSLars Ellenberg look_ahead = 0; 4136b411b363SPhilipp Reisner have -= bits; 4137b411b363SPhilipp Reisner 4138b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4139b411b363SPhilipp Reisner if (bits < 0) 41402c46407dSAndreas Gruenbacher return -EIO; 4141b411b363SPhilipp Reisner look_ahead |= tmp << have; 4142b411b363SPhilipp Reisner have += bits; 4143b411b363SPhilipp Reisner } 4144b411b363SPhilipp Reisner 4145b411b363SPhilipp Reisner c->bit_offset = s; 4146b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4147b411b363SPhilipp Reisner 41482c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4149b411b363SPhilipp Reisner } 4150b411b363SPhilipp Reisner 41512c46407dSAndreas Gruenbacher /** 41522c46407dSAndreas Gruenbacher * decode_bitmap_c 41532c46407dSAndreas Gruenbacher * 41542c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 41552c46407dSAndreas Gruenbacher * code upon failure. 41562c46407dSAndreas Gruenbacher */ 41572c46407dSAndreas Gruenbacher static int 4158b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 4159b411b363SPhilipp Reisner struct p_compressed_bm *p, 4160c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4161c6d25cfeSPhilipp Reisner unsigned int len) 4162b411b363SPhilipp Reisner { 4163a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 4164e658983aSAndreas Gruenbacher return recv_bm_rle_bits(mdev, p, c, len - sizeof(*p)); 4165b411b363SPhilipp Reisner 4166b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4167b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4168b411b363SPhilipp Reisner * during all our tests. */ 4169b411b363SPhilipp Reisner 4170b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 417138fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 41722c46407dSAndreas Gruenbacher return -EIO; 4173b411b363SPhilipp Reisner } 4174b411b363SPhilipp Reisner 4175b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 4176b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4177b411b363SPhilipp Reisner { 4178b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 417950d0b1adSAndreas Gruenbacher unsigned int header_size = drbd_header_size(mdev->tconn); 418050d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 418150d0b1adSAndreas Gruenbacher unsigned int plain = 418250d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 418350d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 418450d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 418550d0b1adSAndreas Gruenbacher unsigned int r; 4186b411b363SPhilipp Reisner 4187b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4188b411b363SPhilipp Reisner if (total == 0) 4189b411b363SPhilipp Reisner return; 4190b411b363SPhilipp Reisner 4191b411b363SPhilipp Reisner /* don't report if not compressed */ 4192b411b363SPhilipp Reisner if (total >= plain) 4193b411b363SPhilipp Reisner return; 4194b411b363SPhilipp Reisner 4195b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4196b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4197b411b363SPhilipp Reisner : (1000 * total / plain); 4198b411b363SPhilipp Reisner 4199b411b363SPhilipp Reisner if (r > 1000) 4200b411b363SPhilipp Reisner r = 1000; 4201b411b363SPhilipp Reisner 4202b411b363SPhilipp Reisner r = 1000 - r; 4203b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4204b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4205b411b363SPhilipp Reisner direction, 4206b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4207b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4208b411b363SPhilipp Reisner total, r/10, r % 10); 4209b411b363SPhilipp Reisner } 4210b411b363SPhilipp Reisner 4211b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4212b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4213b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4214b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4215b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4216b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4217b411b363SPhilipp Reisner 4218b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 42194a76b161SAndreas Gruenbacher static int receive_bitmap(struct drbd_tconn *tconn, struct packet_info *pi) 4220b411b363SPhilipp Reisner { 42214a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4222b411b363SPhilipp Reisner struct bm_xfer_ctx c; 42232c46407dSAndreas Gruenbacher int err; 42244a76b161SAndreas Gruenbacher 42254a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 42264a76b161SAndreas Gruenbacher if (!mdev) 42274a76b161SAndreas Gruenbacher return -EIO; 4228b411b363SPhilipp Reisner 422920ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 423020ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 423120ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4232b411b363SPhilipp Reisner 4233b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4234b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 4235b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 4236b411b363SPhilipp Reisner }; 4237b411b363SPhilipp Reisner 42382c46407dSAndreas Gruenbacher for(;;) { 4239e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 4240e658983aSAndreas Gruenbacher err = receive_bitmap_plain(mdev, pi->size, pi->data, &c); 4241e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4242b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4243b411b363SPhilipp Reisner * and the feature is enabled! */ 4244e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4245b411b363SPhilipp Reisner 424650d0b1adSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(tconn)) { 4247b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 424882bc0194SAndreas Gruenbacher err = -EIO; 4249b411b363SPhilipp Reisner goto out; 4250b411b363SPhilipp Reisner } 4251e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4252e2857216SAndreas Gruenbacher dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", pi->size); 425382bc0194SAndreas Gruenbacher err = -EIO; 425478fcbdaeSAndreas Gruenbacher goto out; 4255b411b363SPhilipp Reisner } 4256e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, pi->size); 4257e658983aSAndreas Gruenbacher if (err) 4258e658983aSAndreas Gruenbacher goto out; 4259e2857216SAndreas Gruenbacher err = decode_bitmap_c(mdev, p, &c, pi->size); 4260b411b363SPhilipp Reisner } else { 4261e2857216SAndreas Gruenbacher dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 426282bc0194SAndreas Gruenbacher err = -EIO; 4263b411b363SPhilipp Reisner goto out; 4264b411b363SPhilipp Reisner } 4265b411b363SPhilipp Reisner 4266e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 426750d0b1adSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(tconn) + pi->size; 4268b411b363SPhilipp Reisner 42692c46407dSAndreas Gruenbacher if (err <= 0) { 42702c46407dSAndreas Gruenbacher if (err < 0) 42712c46407dSAndreas Gruenbacher goto out; 4272b411b363SPhilipp Reisner break; 42732c46407dSAndreas Gruenbacher } 4274e2857216SAndreas Gruenbacher err = drbd_recv_header(mdev->tconn, pi); 427582bc0194SAndreas Gruenbacher if (err) 4276b411b363SPhilipp Reisner goto out; 42772c46407dSAndreas Gruenbacher } 4278b411b363SPhilipp Reisner 4279b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 4280b411b363SPhilipp Reisner 4281b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 4282de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4283de1f8e4aSAndreas Gruenbacher 428482bc0194SAndreas Gruenbacher err = drbd_send_bitmap(mdev); 428582bc0194SAndreas Gruenbacher if (err) 4286b411b363SPhilipp Reisner goto out; 4287b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4288de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 4289de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 4290b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 4291b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4292b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4293b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 4294b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 4295b411b363SPhilipp Reisner } 429682bc0194SAndreas Gruenbacher err = 0; 4297b411b363SPhilipp Reisner 4298b411b363SPhilipp Reisner out: 429920ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 430082bc0194SAndreas Gruenbacher if (!err && mdev->state.conn == C_WF_BITMAP_S) 4301b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 430282bc0194SAndreas Gruenbacher return err; 4303b411b363SPhilipp Reisner } 4304b411b363SPhilipp Reisner 43054a76b161SAndreas Gruenbacher static int receive_skip(struct drbd_tconn *tconn, struct packet_info *pi) 4306b411b363SPhilipp Reisner { 43074a76b161SAndreas Gruenbacher conn_warn(tconn, "skipping unknown optional packet type %d, l: %d!\n", 4308e2857216SAndreas Gruenbacher pi->cmd, pi->size); 4309b411b363SPhilipp Reisner 43104a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 4311b411b363SPhilipp Reisner } 4312b411b363SPhilipp Reisner 43134a76b161SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_tconn *tconn, struct packet_info *pi) 4314b411b363SPhilipp Reisner { 4315b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4316b411b363SPhilipp Reisner * with the data requests being unplugged */ 43174a76b161SAndreas Gruenbacher drbd_tcp_quickack(tconn->data.socket); 4318b411b363SPhilipp Reisner 431982bc0194SAndreas Gruenbacher return 0; 4320b411b363SPhilipp Reisner } 4321b411b363SPhilipp Reisner 43224a76b161SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_tconn *tconn, struct packet_info *pi) 432373a01a18SPhilipp Reisner { 43244a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4325e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 43264a76b161SAndreas Gruenbacher 43274a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 43284a76b161SAndreas Gruenbacher if (!mdev) 43294a76b161SAndreas Gruenbacher return -EIO; 433073a01a18SPhilipp Reisner 4331f735e363SLars Ellenberg switch (mdev->state.conn) { 4332f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4333f735e363SLars Ellenberg case C_WF_BITMAP_T: 4334f735e363SLars Ellenberg case C_BEHIND: 4335f735e363SLars Ellenberg break; 4336f735e363SLars Ellenberg default: 4337f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4338f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 4339f735e363SLars Ellenberg } 4340f735e363SLars Ellenberg 434173a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 434273a01a18SPhilipp Reisner 434382bc0194SAndreas Gruenbacher return 0; 434473a01a18SPhilipp Reisner } 434573a01a18SPhilipp Reisner 434602918be2SPhilipp Reisner struct data_cmd { 434702918be2SPhilipp Reisner int expect_payload; 434802918be2SPhilipp Reisner size_t pkt_size; 43494a76b161SAndreas Gruenbacher int (*fn)(struct drbd_tconn *, struct packet_info *); 4350b411b363SPhilipp Reisner }; 4351b411b363SPhilipp Reisner 435202918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 435302918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 435402918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 435502918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 435602918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4357e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4358e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4359e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 436002918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 436102918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4362e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4363e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 436402918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 436502918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 436602918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 436702918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 436802918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 436902918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 437002918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 437102918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 437202918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 437302918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 437473a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 43754a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4376036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 437702918be2SPhilipp Reisner }; 437802918be2SPhilipp Reisner 4379eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 4380b411b363SPhilipp Reisner { 438177351055SPhilipp Reisner struct packet_info pi; 438202918be2SPhilipp Reisner size_t shs; /* sub header size */ 438382bc0194SAndreas Gruenbacher int err; 4384b411b363SPhilipp Reisner 4385eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 4386deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4387deebe195SAndreas Gruenbacher 4388eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 438969bc7bc3SAndreas Gruenbacher if (drbd_recv_header(tconn, &pi)) 439002918be2SPhilipp Reisner goto err_out; 439102918be2SPhilipp Reisner 4392deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 43934a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 43942fcb8f30SAndreas Gruenbacher conn_err(tconn, "Unexpected data packet %s (0x%04x)", 43952fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 439602918be2SPhilipp Reisner goto err_out; 43970b33a916SLars Ellenberg } 4398b411b363SPhilipp Reisner 4399e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4400e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 44012fcb8f30SAndreas Gruenbacher conn_err(tconn, "No payload expected %s l:%d\n", 44022fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4403c13f7e1aSLars Ellenberg goto err_out; 4404c13f7e1aSLars Ellenberg } 4405c13f7e1aSLars Ellenberg 4406c13f7e1aSLars Ellenberg if (shs) { 4407e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, pi.data, shs); 4408a5c31904SAndreas Gruenbacher if (err) 440902918be2SPhilipp Reisner goto err_out; 4410e2857216SAndreas Gruenbacher pi.size -= shs; 4411b411b363SPhilipp Reisner } 441202918be2SPhilipp Reisner 44134a76b161SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 44144a76b161SAndreas Gruenbacher if (err) { 44159f5bdc33SAndreas Gruenbacher conn_err(tconn, "error receiving %s, e: %d l: %d!\n", 44169f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 441702918be2SPhilipp Reisner goto err_out; 441802918be2SPhilipp Reisner } 441902918be2SPhilipp Reisner } 442082bc0194SAndreas Gruenbacher return; 442102918be2SPhilipp Reisner 442202918be2SPhilipp Reisner err_out: 4423bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4424b411b363SPhilipp Reisner } 4425b411b363SPhilipp Reisner 44260e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 4427b411b363SPhilipp Reisner { 4428b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4429b411b363SPhilipp Reisner 4430b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 44310e29d163SPhilipp Reisner barr.w.tconn = tconn; 4432b411b363SPhilipp Reisner init_completion(&barr.done); 4433d5b27b01SLars Ellenberg drbd_queue_work(&tconn->sender_work, &barr.w); 4434b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4435b411b363SPhilipp Reisner } 4436b411b363SPhilipp Reisner 443781fa2e67SPhilipp Reisner static void conn_disconnect(struct drbd_tconn *tconn) 4438f70b3511SPhilipp Reisner { 4439c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 4440bbeb641cSPhilipp Reisner enum drbd_conns oc; 4441376694a0SPhilipp Reisner int vnr; 4442f70b3511SPhilipp Reisner 4443bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4444b411b363SPhilipp Reisner return; 4445b411b363SPhilipp Reisner 4446545752d5SLars Ellenberg /* We are about to start the cleanup after connection loss. 4447545752d5SLars Ellenberg * Make sure drbd_make_request knows about that. 4448545752d5SLars Ellenberg * Usually we should be in some network failure state already, 4449545752d5SLars Ellenberg * but just in case we are not, we fix it up here. 4450545752d5SLars Ellenberg */ 4451b8853dbdSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4452545752d5SLars Ellenberg 4453b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4454360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4455360cc740SPhilipp Reisner drbd_free_sock(tconn); 4456360cc740SPhilipp Reisner 4457c141ebdaSPhilipp Reisner rcu_read_lock(); 4458c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 4459c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 4460c141ebdaSPhilipp Reisner rcu_read_unlock(); 4461c141ebdaSPhilipp Reisner drbd_disconnected(mdev); 4462c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 4463c141ebdaSPhilipp Reisner rcu_read_lock(); 4464c141ebdaSPhilipp Reisner } 4465c141ebdaSPhilipp Reisner rcu_read_unlock(); 4466c141ebdaSPhilipp Reisner 446712038a3aSPhilipp Reisner if (!list_empty(&tconn->current_epoch->list)) 446812038a3aSPhilipp Reisner conn_err(tconn, "ASSERTION FAILED: tconn->current_epoch->list not empty\n"); 446912038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 447012038a3aSPhilipp Reisner atomic_set(&tconn->current_epoch->epoch_size, 0); 4471b6dd1a89SLars Ellenberg tconn->send.seen_any_write_yet = false; 447212038a3aSPhilipp Reisner 4473360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4474360cc740SPhilipp Reisner 4475cb703454SPhilipp Reisner if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN) 4476cb703454SPhilipp Reisner conn_try_outdate_peer_async(tconn); 4477cb703454SPhilipp Reisner 4478360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4479bbeb641cSPhilipp Reisner oc = tconn->cstate; 4480bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4481376694a0SPhilipp Reisner _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4482bbeb641cSPhilipp Reisner 4483360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4484360cc740SPhilipp Reisner 4485f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4486d9cc6e23SLars Ellenberg conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4487360cc740SPhilipp Reisner } 4488360cc740SPhilipp Reisner 4489c141ebdaSPhilipp Reisner static int drbd_disconnected(struct drbd_conf *mdev) 4490360cc740SPhilipp Reisner { 4491360cc740SPhilipp Reisner unsigned int i; 4492b411b363SPhilipp Reisner 449385719573SPhilipp Reisner /* wait for current activity to cease. */ 449487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4495b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4496b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4497b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 449887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4499b411b363SPhilipp Reisner 4500b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4501b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4502b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4503b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4504b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4505b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4506b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4507b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4508b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4509b411b363SPhilipp Reisner * on the fly. */ 4510b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4511b411b363SPhilipp Reisner mdev->rs_total = 0; 4512b411b363SPhilipp Reisner mdev->rs_failed = 0; 4513b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4514b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4515b411b363SPhilipp Reisner 4516b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4517b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4518b411b363SPhilipp Reisner 4519b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4520b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4521b411b363SPhilipp Reisner * to be "canceled" */ 4522b411b363SPhilipp Reisner drbd_flush_workqueue(mdev); 4523b411b363SPhilipp Reisner 4524a990be46SAndreas Gruenbacher drbd_finish_peer_reqs(mdev); 4525b411b363SPhilipp Reisner 4526d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 4527d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 4528d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 4529d10b4ea3SPhilipp Reisner drbd_flush_workqueue(mdev); 4530d10b4ea3SPhilipp Reisner 453108332d73SLars Ellenberg /* need to do it again, drbd_finish_peer_reqs() may have populated it 453208332d73SLars Ellenberg * again via drbd_try_clear_on_disk_bm(). */ 453308332d73SLars Ellenberg drbd_rs_cancel_all(mdev); 4534b411b363SPhilipp Reisner 4535b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4536b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4537b411b363SPhilipp Reisner 45382aebfabbSPhilipp Reisner if (!drbd_suspended(mdev)) 45392f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4540b411b363SPhilipp Reisner 4541b411b363SPhilipp Reisner drbd_md_sync(mdev); 4542b411b363SPhilipp Reisner 454320ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 454420ceb2b2SLars Ellenberg * if any. */ 454520ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 454620ceb2b2SLars Ellenberg 4547b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4548b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4549b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4550b411b363SPhilipp Reisner * 4551b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4552b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4553b411b363SPhilipp Reisner */ 45547721f567SAndreas Gruenbacher i = drbd_free_peer_reqs(mdev, &mdev->net_ee); 4555b411b363SPhilipp Reisner if (i) 4556b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4557435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4558435f0740SLars Ellenberg if (i) 4559435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4560b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4561b411b363SPhilipp Reisner if (i) 456245bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4563b411b363SPhilipp Reisner 4564b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4565b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4566b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4567b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4568b411b363SPhilipp Reisner 4569360cc740SPhilipp Reisner return 0; 4570b411b363SPhilipp Reisner } 4571b411b363SPhilipp Reisner 4572b411b363SPhilipp Reisner /* 4573b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4574b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4575b411b363SPhilipp Reisner * 4576b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4577b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4578b411b363SPhilipp Reisner * 4579b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4580b411b363SPhilipp Reisner */ 45816038178eSAndreas Gruenbacher static int drbd_send_features(struct drbd_tconn *tconn) 4582b411b363SPhilipp Reisner { 45839f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 45849f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4585b411b363SPhilipp Reisner 45869f5bdc33SAndreas Gruenbacher sock = &tconn->data; 45879f5bdc33SAndreas Gruenbacher p = conn_prepare_command(tconn, sock); 45889f5bdc33SAndreas Gruenbacher if (!p) 4589e8d17b01SAndreas Gruenbacher return -EIO; 4590b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4591b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4592b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 45939f5bdc33SAndreas Gruenbacher return conn_send_command(tconn, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4594b411b363SPhilipp Reisner } 4595b411b363SPhilipp Reisner 4596b411b363SPhilipp Reisner /* 4597b411b363SPhilipp Reisner * return values: 4598b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4599b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4600b411b363SPhilipp Reisner * -1 peer talks different language, 4601b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4602b411b363SPhilipp Reisner */ 46036038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn) 4604b411b363SPhilipp Reisner { 460565d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 4606e658983aSAndreas Gruenbacher struct p_connection_features *p; 4607e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 460877351055SPhilipp Reisner struct packet_info pi; 4609a5c31904SAndreas Gruenbacher int err; 4610b411b363SPhilipp Reisner 46116038178eSAndreas Gruenbacher err = drbd_send_features(tconn); 4612e8d17b01SAndreas Gruenbacher if (err) 4613b411b363SPhilipp Reisner return 0; 4614b411b363SPhilipp Reisner 461569bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 461669bc7bc3SAndreas Gruenbacher if (err) 4617b411b363SPhilipp Reisner return 0; 4618b411b363SPhilipp Reisner 46196038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 46206038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 462177351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4622b411b363SPhilipp Reisner return -1; 4623b411b363SPhilipp Reisner } 4624b411b363SPhilipp Reisner 462577351055SPhilipp Reisner if (pi.size != expect) { 46266038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures length: %u, received: %u\n", 462777351055SPhilipp Reisner expect, pi.size); 4628b411b363SPhilipp Reisner return -1; 4629b411b363SPhilipp Reisner } 4630b411b363SPhilipp Reisner 4631e658983aSAndreas Gruenbacher p = pi.data; 4632e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, p, expect); 4633a5c31904SAndreas Gruenbacher if (err) 4634b411b363SPhilipp Reisner return 0; 4635b411b363SPhilipp Reisner 4636b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4637b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4638b411b363SPhilipp Reisner if (p->protocol_max == 0) 4639b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4640b411b363SPhilipp Reisner 4641b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4642b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4643b411b363SPhilipp Reisner goto incompat; 4644b411b363SPhilipp Reisner 464565d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4646b411b363SPhilipp Reisner 464765d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 464865d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4649b411b363SPhilipp Reisner 4650b411b363SPhilipp Reisner return 1; 4651b411b363SPhilipp Reisner 4652b411b363SPhilipp Reisner incompat: 465365d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4654b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4655b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4656b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4657b411b363SPhilipp Reisner return -1; 4658b411b363SPhilipp Reisner } 4659b411b363SPhilipp Reisner 4660b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 466113e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4662b411b363SPhilipp Reisner { 4663ef57f9e6SPhilipp Reisner conn_err(tconn, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4664ef57f9e6SPhilipp Reisner conn_err(tconn, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4665b10d96cbSJohannes Thoma return -1; 4666b411b363SPhilipp Reisner } 4667b411b363SPhilipp Reisner #else 4668b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4669b10d96cbSJohannes Thoma 4670b10d96cbSJohannes Thoma /* Return value: 4671b10d96cbSJohannes Thoma 1 - auth succeeded, 4672b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4673b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4674b10d96cbSJohannes Thoma */ 4675b10d96cbSJohannes Thoma 467613e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4677b411b363SPhilipp Reisner { 46789f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4679b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4680b411b363SPhilipp Reisner struct scatterlist sg; 4681b411b363SPhilipp Reisner char *response = NULL; 4682b411b363SPhilipp Reisner char *right_response = NULL; 4683b411b363SPhilipp Reisner char *peers_ch = NULL; 468444ed167dSPhilipp Reisner unsigned int key_len; 468544ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4686b411b363SPhilipp Reisner unsigned int resp_size; 4687b411b363SPhilipp Reisner struct hash_desc desc; 468877351055SPhilipp Reisner struct packet_info pi; 468944ed167dSPhilipp Reisner struct net_conf *nc; 469069bc7bc3SAndreas Gruenbacher int err, rv; 4691b411b363SPhilipp Reisner 46929f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 46939f5bdc33SAndreas Gruenbacher 469444ed167dSPhilipp Reisner rcu_read_lock(); 469544ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 469644ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 469744ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 469844ed167dSPhilipp Reisner rcu_read_unlock(); 469944ed167dSPhilipp Reisner 470013e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4701b411b363SPhilipp Reisner desc.flags = 0; 4702b411b363SPhilipp Reisner 470344ed167dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, (u8 *)secret, key_len); 4704b411b363SPhilipp Reisner if (rv) { 470513e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4706b10d96cbSJohannes Thoma rv = -1; 4707b411b363SPhilipp Reisner goto fail; 4708b411b363SPhilipp Reisner } 4709b411b363SPhilipp Reisner 4710b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4711b411b363SPhilipp Reisner 47129f5bdc33SAndreas Gruenbacher sock = &tconn->data; 47139f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 47149f5bdc33SAndreas Gruenbacher rv = 0; 47159f5bdc33SAndreas Gruenbacher goto fail; 47169f5bdc33SAndreas Gruenbacher } 4717e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_CHALLENGE, 0, 47189f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4719b411b363SPhilipp Reisner if (!rv) 4720b411b363SPhilipp Reisner goto fail; 4721b411b363SPhilipp Reisner 472269bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 472369bc7bc3SAndreas Gruenbacher if (err) { 4724b411b363SPhilipp Reisner rv = 0; 4725b411b363SPhilipp Reisner goto fail; 4726b411b363SPhilipp Reisner } 4727b411b363SPhilipp Reisner 472877351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 472913e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 473077351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4731b411b363SPhilipp Reisner rv = 0; 4732b411b363SPhilipp Reisner goto fail; 4733b411b363SPhilipp Reisner } 4734b411b363SPhilipp Reisner 473577351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 473613e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4737b10d96cbSJohannes Thoma rv = -1; 4738b411b363SPhilipp Reisner goto fail; 4739b411b363SPhilipp Reisner } 4740b411b363SPhilipp Reisner 474177351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4742b411b363SPhilipp Reisner if (peers_ch == NULL) { 474313e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4744b10d96cbSJohannes Thoma rv = -1; 4745b411b363SPhilipp Reisner goto fail; 4746b411b363SPhilipp Reisner } 4747b411b363SPhilipp Reisner 4748a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, peers_ch, pi.size); 4749a5c31904SAndreas Gruenbacher if (err) { 4750b411b363SPhilipp Reisner rv = 0; 4751b411b363SPhilipp Reisner goto fail; 4752b411b363SPhilipp Reisner } 4753b411b363SPhilipp Reisner 475413e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4755b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4756b411b363SPhilipp Reisner if (response == NULL) { 475713e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4758b10d96cbSJohannes Thoma rv = -1; 4759b411b363SPhilipp Reisner goto fail; 4760b411b363SPhilipp Reisner } 4761b411b363SPhilipp Reisner 4762b411b363SPhilipp Reisner sg_init_table(&sg, 1); 476377351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4764b411b363SPhilipp Reisner 4765b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4766b411b363SPhilipp Reisner if (rv) { 476713e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4768b10d96cbSJohannes Thoma rv = -1; 4769b411b363SPhilipp Reisner goto fail; 4770b411b363SPhilipp Reisner } 4771b411b363SPhilipp Reisner 47729f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 47739f5bdc33SAndreas Gruenbacher rv = 0; 47749f5bdc33SAndreas Gruenbacher goto fail; 47759f5bdc33SAndreas Gruenbacher } 4776e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_RESPONSE, 0, 47779f5bdc33SAndreas Gruenbacher response, resp_size); 4778b411b363SPhilipp Reisner if (!rv) 4779b411b363SPhilipp Reisner goto fail; 4780b411b363SPhilipp Reisner 478169bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 478269bc7bc3SAndreas Gruenbacher if (err) { 4783b411b363SPhilipp Reisner rv = 0; 4784b411b363SPhilipp Reisner goto fail; 4785b411b363SPhilipp Reisner } 4786b411b363SPhilipp Reisner 478777351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 478813e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 478977351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4790b411b363SPhilipp Reisner rv = 0; 4791b411b363SPhilipp Reisner goto fail; 4792b411b363SPhilipp Reisner } 4793b411b363SPhilipp Reisner 479477351055SPhilipp Reisner if (pi.size != resp_size) { 479513e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4796b411b363SPhilipp Reisner rv = 0; 4797b411b363SPhilipp Reisner goto fail; 4798b411b363SPhilipp Reisner } 4799b411b363SPhilipp Reisner 4800a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, response , resp_size); 4801a5c31904SAndreas Gruenbacher if (err) { 4802b411b363SPhilipp Reisner rv = 0; 4803b411b363SPhilipp Reisner goto fail; 4804b411b363SPhilipp Reisner } 4805b411b363SPhilipp Reisner 4806b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 48072d1ee87dSJulia Lawall if (right_response == NULL) { 480813e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4809b10d96cbSJohannes Thoma rv = -1; 4810b411b363SPhilipp Reisner goto fail; 4811b411b363SPhilipp Reisner } 4812b411b363SPhilipp Reisner 4813b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4814b411b363SPhilipp Reisner 4815b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4816b411b363SPhilipp Reisner if (rv) { 481713e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4818b10d96cbSJohannes Thoma rv = -1; 4819b411b363SPhilipp Reisner goto fail; 4820b411b363SPhilipp Reisner } 4821b411b363SPhilipp Reisner 4822b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4823b411b363SPhilipp Reisner 4824b411b363SPhilipp Reisner if (rv) 482544ed167dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes HMAC\n", 482644ed167dSPhilipp Reisner resp_size); 4827b10d96cbSJohannes Thoma else 4828b10d96cbSJohannes Thoma rv = -1; 4829b411b363SPhilipp Reisner 4830b411b363SPhilipp Reisner fail: 4831b411b363SPhilipp Reisner kfree(peers_ch); 4832b411b363SPhilipp Reisner kfree(response); 4833b411b363SPhilipp Reisner kfree(right_response); 4834b411b363SPhilipp Reisner 4835b411b363SPhilipp Reisner return rv; 4836b411b363SPhilipp Reisner } 4837b411b363SPhilipp Reisner #endif 4838b411b363SPhilipp Reisner 4839b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4840b411b363SPhilipp Reisner { 4841392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4842b411b363SPhilipp Reisner int h; 4843b411b363SPhilipp Reisner 48444d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4845b411b363SPhilipp Reisner 4846b411b363SPhilipp Reisner do { 484781fa2e67SPhilipp Reisner h = conn_connect(tconn); 4848b411b363SPhilipp Reisner if (h == 0) { 484981fa2e67SPhilipp Reisner conn_disconnect(tconn); 485020ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4851b411b363SPhilipp Reisner } 4852b411b363SPhilipp Reisner if (h == -1) { 48534d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4854bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4855b411b363SPhilipp Reisner } 4856b411b363SPhilipp Reisner } while (h == 0); 4857b411b363SPhilipp Reisner 485891fd4dadSPhilipp Reisner if (h > 0) 48594d641dd7SPhilipp Reisner drbdd(tconn); 4860b411b363SPhilipp Reisner 486181fa2e67SPhilipp Reisner conn_disconnect(tconn); 4862b411b363SPhilipp Reisner 48634d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4864b411b363SPhilipp Reisner return 0; 4865b411b363SPhilipp Reisner } 4866b411b363SPhilipp Reisner 4867b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4868b411b363SPhilipp Reisner 4869e05e1e59SAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4870b411b363SPhilipp Reisner { 4871e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4872b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4873b411b363SPhilipp Reisner 4874b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4875fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4876b411b363SPhilipp Reisner } else { 4877fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4878fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4879fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4880fc3b10a4SPhilipp Reisner } 4881fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4882e4f78edeSPhilipp Reisner 48832735a594SAndreas Gruenbacher return 0; 4884fc3b10a4SPhilipp Reisner } 4885e4f78edeSPhilipp Reisner 48861952e916SAndreas Gruenbacher static int got_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4887e4f78edeSPhilipp Reisner { 48881952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4889e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4890e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4891e4f78edeSPhilipp Reisner 48921952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48931952e916SAndreas Gruenbacher if (!mdev) 48942735a594SAndreas Gruenbacher return -EIO; 48951952e916SAndreas Gruenbacher 48964d0fc3fdSPhilipp Reisner if (test_bit(CONN_WD_ST_CHG_REQ, &tconn->flags)) { 48974d0fc3fdSPhilipp Reisner D_ASSERT(tconn->agreed_pro_version < 100); 48984d0fc3fdSPhilipp Reisner return got_conn_RqSReply(tconn, pi); 48994d0fc3fdSPhilipp Reisner } 49004d0fc3fdSPhilipp Reisner 4901e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4902e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4903e4f78edeSPhilipp Reisner } else { 4904e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4905b411b363SPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4906b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4907b411b363SPhilipp Reisner } 4908b411b363SPhilipp Reisner wake_up(&mdev->state_wait); 4909b411b363SPhilipp Reisner 49102735a594SAndreas Gruenbacher return 0; 4911b411b363SPhilipp Reisner } 4912b411b363SPhilipp Reisner 4913e05e1e59SAndreas Gruenbacher static int got_Ping(struct drbd_tconn *tconn, struct packet_info *pi) 4914b411b363SPhilipp Reisner { 49152735a594SAndreas Gruenbacher return drbd_send_ping_ack(tconn); 4916b411b363SPhilipp Reisner 4917b411b363SPhilipp Reisner } 4918b411b363SPhilipp Reisner 4919e05e1e59SAndreas Gruenbacher static int got_PingAck(struct drbd_tconn *tconn, struct packet_info *pi) 4920b411b363SPhilipp Reisner { 4921b411b363SPhilipp Reisner /* restore idle timeout */ 49222a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 49232a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 49242a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4925b411b363SPhilipp Reisner 49262735a594SAndreas Gruenbacher return 0; 4927b411b363SPhilipp Reisner } 4928b411b363SPhilipp Reisner 49291952e916SAndreas Gruenbacher static int got_IsInSync(struct drbd_tconn *tconn, struct packet_info *pi) 4930b411b363SPhilipp Reisner { 49311952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4932e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4933b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4934b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4935b411b363SPhilipp Reisner 49361952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49371952e916SAndreas Gruenbacher if (!mdev) 49382735a594SAndreas Gruenbacher return -EIO; 49391952e916SAndreas Gruenbacher 494031890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4941b411b363SPhilipp Reisner 4942b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4943b411b363SPhilipp Reisner 49441d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4945b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4946b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4947b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4948b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 49491d53f09eSLars Ellenberg put_ldev(mdev); 49501d53f09eSLars Ellenberg } 4951b411b363SPhilipp Reisner dec_rs_pending(mdev); 4952778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4953b411b363SPhilipp Reisner 49542735a594SAndreas Gruenbacher return 0; 4955b411b363SPhilipp Reisner } 4956b411b363SPhilipp Reisner 4957bc9c5c41SAndreas Gruenbacher static int 4958bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4959bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4960bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4961b411b363SPhilipp Reisner { 4962b411b363SPhilipp Reisner struct drbd_request *req; 4963b411b363SPhilipp Reisner struct bio_and_error m; 4964b411b363SPhilipp Reisner 496587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4966bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4967b411b363SPhilipp Reisner if (unlikely(!req)) { 496887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 496985997675SAndreas Gruenbacher return -EIO; 4970b411b363SPhilipp Reisner } 4971b411b363SPhilipp Reisner __req_mod(req, what, &m); 497287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4973b411b363SPhilipp Reisner 4974b411b363SPhilipp Reisner if (m.bio) 4975b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 497685997675SAndreas Gruenbacher return 0; 4977b411b363SPhilipp Reisner } 4978b411b363SPhilipp Reisner 49791952e916SAndreas Gruenbacher static int got_BlockAck(struct drbd_tconn *tconn, struct packet_info *pi) 4980b411b363SPhilipp Reisner { 49811952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4982e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4983b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4984b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4985b411b363SPhilipp Reisner enum drbd_req_event what; 4986b411b363SPhilipp Reisner 49871952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49881952e916SAndreas Gruenbacher if (!mdev) 49892735a594SAndreas Gruenbacher return -EIO; 49901952e916SAndreas Gruenbacher 4991b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4992b411b363SPhilipp Reisner 4993579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4994b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4995b411b363SPhilipp Reisner dec_rs_pending(mdev); 49962735a594SAndreas Gruenbacher return 0; 4997b411b363SPhilipp Reisner } 4998e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4999b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 50008554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 5001b411b363SPhilipp Reisner break; 5002b411b363SPhilipp Reisner case P_WRITE_ACK: 50038554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 5004b411b363SPhilipp Reisner break; 5005b411b363SPhilipp Reisner case P_RECV_ACK: 50068554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 5007b411b363SPhilipp Reisner break; 5008d4dabbe2SLars Ellenberg case P_SUPERSEDED: 5009d4dabbe2SLars Ellenberg what = CONFLICT_RESOLVED; 50107be8da07SAndreas Gruenbacher break; 50117be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 50127be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5013b411b363SPhilipp Reisner break; 5014b411b363SPhilipp Reisner default: 50152735a594SAndreas Gruenbacher BUG(); 5016b411b363SPhilipp Reisner } 5017b411b363SPhilipp Reisner 5018b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 5019bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 5020bc9c5c41SAndreas Gruenbacher what, false); 5021b411b363SPhilipp Reisner } 5022b411b363SPhilipp Reisner 50231952e916SAndreas Gruenbacher static int got_NegAck(struct drbd_tconn *tconn, struct packet_info *pi) 5024b411b363SPhilipp Reisner { 50251952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5026e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5027b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 50282deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 502985997675SAndreas Gruenbacher int err; 5030b411b363SPhilipp Reisner 50311952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50321952e916SAndreas Gruenbacher if (!mdev) 50332735a594SAndreas Gruenbacher return -EIO; 5034b411b363SPhilipp Reisner 5035b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5036b411b363SPhilipp Reisner 5037579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5038b411b363SPhilipp Reisner dec_rs_pending(mdev); 5039b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 50402735a594SAndreas Gruenbacher return 0; 5041b411b363SPhilipp Reisner } 50422deb8336SPhilipp Reisner 504385997675SAndreas Gruenbacher err = validate_req_change_req_state(mdev, p->block_id, sector, 5044bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 5045303d1448SPhilipp Reisner NEG_ACKED, true); 504685997675SAndreas Gruenbacher if (err) { 50472deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 50482deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5049c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 50502deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 50512deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 50522deb8336SPhilipp Reisner drbd_set_out_of_sync(mdev, sector, size); 50532deb8336SPhilipp Reisner } 50542735a594SAndreas Gruenbacher return 0; 5055b411b363SPhilipp Reisner } 5056b411b363SPhilipp Reisner 50571952e916SAndreas Gruenbacher static int got_NegDReply(struct drbd_tconn *tconn, struct packet_info *pi) 5058b411b363SPhilipp Reisner { 50591952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5060e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5061b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5062b411b363SPhilipp Reisner 50631952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50641952e916SAndreas Gruenbacher if (!mdev) 50652735a594SAndreas Gruenbacher return -EIO; 50661952e916SAndreas Gruenbacher 5067b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 50687be8da07SAndreas Gruenbacher 5069380207d0SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u.\n", 5070b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5071b411b363SPhilipp Reisner 5072b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 5073bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 50748554df1cSAndreas Gruenbacher NEG_ACKED, false); 5075b411b363SPhilipp Reisner } 5076b411b363SPhilipp Reisner 50771952e916SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_tconn *tconn, struct packet_info *pi) 5078b411b363SPhilipp Reisner { 50791952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5080b411b363SPhilipp Reisner sector_t sector; 5081b411b363SPhilipp Reisner int size; 5082e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 50831952e916SAndreas Gruenbacher 50841952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50851952e916SAndreas Gruenbacher if (!mdev) 50862735a594SAndreas Gruenbacher return -EIO; 5087b411b363SPhilipp Reisner 5088b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5089b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5090b411b363SPhilipp Reisner 5091b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5092b411b363SPhilipp Reisner 5093b411b363SPhilipp Reisner dec_rs_pending(mdev); 5094b411b363SPhilipp Reisner 5095b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 5096b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 5097e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5098d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5099b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 5100d612d309SPhilipp Reisner case P_RS_CANCEL: 5101d612d309SPhilipp Reisner break; 5102d612d309SPhilipp Reisner default: 51032735a594SAndreas Gruenbacher BUG(); 5104d612d309SPhilipp Reisner } 5105b411b363SPhilipp Reisner put_ldev(mdev); 5106b411b363SPhilipp Reisner } 5107b411b363SPhilipp Reisner 51082735a594SAndreas Gruenbacher return 0; 5109b411b363SPhilipp Reisner } 5110b411b363SPhilipp Reisner 51111952e916SAndreas Gruenbacher static int got_BarrierAck(struct drbd_tconn *tconn, struct packet_info *pi) 5112b411b363SPhilipp Reisner { 5113e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 51149ed57dcbSLars Ellenberg struct drbd_conf *mdev; 51159ed57dcbSLars Ellenberg int vnr; 5116b411b363SPhilipp Reisner 51179ed57dcbSLars Ellenberg tl_release(tconn, p->barrier, be32_to_cpu(p->set_size)); 5118b411b363SPhilipp Reisner 51199ed57dcbSLars Ellenberg rcu_read_lock(); 51209ed57dcbSLars Ellenberg idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5121c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 5122c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 512336baf611SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->flags)) { 5124370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 5125370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 5126c4752ef1SPhilipp Reisner } 51279ed57dcbSLars Ellenberg } 51289ed57dcbSLars Ellenberg rcu_read_unlock(); 5129c4752ef1SPhilipp Reisner 51302735a594SAndreas Gruenbacher return 0; 5131b411b363SPhilipp Reisner } 5132b411b363SPhilipp Reisner 51331952e916SAndreas Gruenbacher static int got_OVResult(struct drbd_tconn *tconn, struct packet_info *pi) 5134b411b363SPhilipp Reisner { 51351952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5136e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5137b411b363SPhilipp Reisner struct drbd_work *w; 5138b411b363SPhilipp Reisner sector_t sector; 5139b411b363SPhilipp Reisner int size; 5140b411b363SPhilipp Reisner 51411952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 51421952e916SAndreas Gruenbacher if (!mdev) 51432735a594SAndreas Gruenbacher return -EIO; 51441952e916SAndreas Gruenbacher 5145b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5146b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5147b411b363SPhilipp Reisner 5148b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5149b411b363SPhilipp Reisner 5150b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 51518f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 5152b411b363SPhilipp Reisner else 51538f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5154b411b363SPhilipp Reisner 51551d53f09eSLars Ellenberg if (!get_ldev(mdev)) 51562735a594SAndreas Gruenbacher return 0; 51571d53f09eSLars Ellenberg 5158b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 5159b411b363SPhilipp Reisner dec_rs_pending(mdev); 5160b411b363SPhilipp Reisner 5161ea5442afSLars Ellenberg --mdev->ov_left; 5162ea5442afSLars Ellenberg 5163ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5164ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 5165ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 5166ea5442afSLars Ellenberg 5167ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 5168b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 5169b411b363SPhilipp Reisner if (w) { 5170b411b363SPhilipp Reisner w->cb = w_ov_finished; 5171a21e9298SPhilipp Reisner w->mdev = mdev; 5172d5b27b01SLars Ellenberg drbd_queue_work(&mdev->tconn->sender_work, w); 5173b411b363SPhilipp Reisner } else { 5174b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 51758f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5176b411b363SPhilipp Reisner drbd_resync_finished(mdev); 5177b411b363SPhilipp Reisner } 5178b411b363SPhilipp Reisner } 51791d53f09eSLars Ellenberg put_ldev(mdev); 51802735a594SAndreas Gruenbacher return 0; 5181b411b363SPhilipp Reisner } 5182b411b363SPhilipp Reisner 51831952e916SAndreas Gruenbacher static int got_skip(struct drbd_tconn *tconn, struct packet_info *pi) 51840ced55a3SPhilipp Reisner { 51852735a594SAndreas Gruenbacher return 0; 51860ced55a3SPhilipp Reisner } 51870ced55a3SPhilipp Reisner 5188a990be46SAndreas Gruenbacher static int tconn_finish_peer_reqs(struct drbd_tconn *tconn) 518932862ec7SPhilipp Reisner { 5190082a3439SPhilipp Reisner struct drbd_conf *mdev; 5191c141ebdaSPhilipp Reisner int vnr, not_empty = 0; 519232862ec7SPhilipp Reisner 519332862ec7SPhilipp Reisner do { 519432862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 519532862ec7SPhilipp Reisner flush_signals(current); 5196c141ebdaSPhilipp Reisner 5197c141ebdaSPhilipp Reisner rcu_read_lock(); 5198c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5199c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 5200c141ebdaSPhilipp Reisner rcu_read_unlock(); 5201d3fcb490SPhilipp Reisner if (drbd_finish_peer_reqs(mdev)) { 5202c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5203c141ebdaSPhilipp Reisner return 1; 5204082a3439SPhilipp Reisner } 5205c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5206c141ebdaSPhilipp Reisner rcu_read_lock(); 5207d3fcb490SPhilipp Reisner } 520832862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 5209082a3439SPhilipp Reisner 5210082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 5211c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5212082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 5213082a3439SPhilipp Reisner if (not_empty) 5214082a3439SPhilipp Reisner break; 5215082a3439SPhilipp Reisner } 5216082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 5217c141ebdaSPhilipp Reisner rcu_read_unlock(); 521832862ec7SPhilipp Reisner } while (not_empty); 521932862ec7SPhilipp Reisner 522032862ec7SPhilipp Reisner return 0; 5221b411b363SPhilipp Reisner } 5222b411b363SPhilipp Reisner 5223b411b363SPhilipp Reisner struct asender_cmd { 5224b411b363SPhilipp Reisner size_t pkt_size; 52251952e916SAndreas Gruenbacher int (*fn)(struct drbd_tconn *tconn, struct packet_info *); 5226b411b363SPhilipp Reisner }; 5227b411b363SPhilipp Reisner 5228b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 5229e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5230e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 5231b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5232b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5233b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5234d4dabbe2SLars Ellenberg [P_SUPERSEDED] = { sizeof(struct p_block_ack), got_BlockAck }, 5235b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 5236b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 5237b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 5238b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 5239b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 5240b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 5241b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 524202918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 5243d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 52441952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 52451952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 5246b411b363SPhilipp Reisner }; 5247b411b363SPhilipp Reisner 5248b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5249b411b363SPhilipp Reisner { 5250392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 5251b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 525277351055SPhilipp Reisner struct packet_info pi; 5253257d0af6SPhilipp Reisner int rv; 5254e658983aSAndreas Gruenbacher void *buf = tconn->meta.rbuf; 5255b411b363SPhilipp Reisner int received = 0; 525652b061a4SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 525752b061a4SAndreas Gruenbacher int expect = header_size; 525844ed167dSPhilipp Reisner bool ping_timeout_active = false; 525944ed167dSPhilipp Reisner struct net_conf *nc; 5260bb77d34eSAndreas Gruenbacher int ping_timeo, tcp_cork, ping_int; 52613990e04dSPhilipp Reisner struct sched_param param = { .sched_priority = 2 }; 5262b411b363SPhilipp Reisner 52633990e04dSPhilipp Reisner rv = sched_setscheduler(current, SCHED_RR, ¶m); 52643990e04dSPhilipp Reisner if (rv < 0) 52653990e04dSPhilipp Reisner conn_err(tconn, "drbd_asender: ERROR set priority, ret=%d\n", rv); 5266b411b363SPhilipp Reisner 5267e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 526880822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 526944ed167dSPhilipp Reisner 527044ed167dSPhilipp Reisner rcu_read_lock(); 527144ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 527244ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 5273bb77d34eSAndreas Gruenbacher tcp_cork = nc->tcp_cork; 527444ed167dSPhilipp Reisner ping_int = nc->ping_int; 527544ed167dSPhilipp Reisner rcu_read_unlock(); 527644ed167dSPhilipp Reisner 527732862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 5278a17647aaSAndreas Gruenbacher if (drbd_send_ping(tconn)) { 527932862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 5280841ce241SAndreas Gruenbacher goto reconnect; 5281841ce241SAndreas Gruenbacher } 528244ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 528344ed167dSPhilipp Reisner ping_timeout_active = true; 5284b411b363SPhilipp Reisner } 5285b411b363SPhilipp Reisner 528632862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 528732862ec7SPhilipp Reisner much to send */ 5288bb77d34eSAndreas Gruenbacher if (tcp_cork) 528932862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 5290a990be46SAndreas Gruenbacher if (tconn_finish_peer_reqs(tconn)) { 5291a990be46SAndreas Gruenbacher conn_err(tconn, "tconn_finish_peer_reqs() failed\n"); 5292b411b363SPhilipp Reisner goto reconnect; 5293b411b363SPhilipp Reisner } 5294b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 5295bb77d34eSAndreas Gruenbacher if (tcp_cork) 529632862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 5297b411b363SPhilipp Reisner 5298b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5299b411b363SPhilipp Reisner if (signal_pending(current)) 5300b411b363SPhilipp Reisner continue; 5301b411b363SPhilipp Reisner 530232862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 530332862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5304b411b363SPhilipp Reisner 5305b411b363SPhilipp Reisner flush_signals(current); 5306b411b363SPhilipp Reisner 5307b411b363SPhilipp Reisner /* Note: 5308b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5309b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5310b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5311b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5312b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5313b411b363SPhilipp Reisner * rv == expected: full header or command 5314b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5315b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5316b411b363SPhilipp Reisner */ 5317b411b363SPhilipp Reisner if (likely(rv > 0)) { 5318b411b363SPhilipp Reisner received += rv; 5319b411b363SPhilipp Reisner buf += rv; 5320b411b363SPhilipp Reisner } else if (rv == 0) { 5321b66623e3SPhilipp Reisner if (test_bit(DISCONNECT_SENT, &tconn->flags)) { 5322b66623e3SPhilipp Reisner long t; 5323b66623e3SPhilipp Reisner rcu_read_lock(); 5324b66623e3SPhilipp Reisner t = rcu_dereference(tconn->net_conf)->ping_timeo * HZ/10; 5325b66623e3SPhilipp Reisner rcu_read_unlock(); 5326b66623e3SPhilipp Reisner 5327b66623e3SPhilipp Reisner t = wait_event_timeout(tconn->ping_wait, 5328b66623e3SPhilipp Reisner tconn->cstate < C_WF_REPORT_PARAMS, 5329b66623e3SPhilipp Reisner t); 5330599377acSPhilipp Reisner if (t) 5331599377acSPhilipp Reisner break; 5332599377acSPhilipp Reisner } 533332862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 5334b411b363SPhilipp Reisner goto reconnect; 5335b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5336cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5337cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 533832862ec7SPhilipp Reisner if (time_after(tconn->last_received, 533932862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 5340cb6518cbSLars Ellenberg continue; 5341f36af18cSLars Ellenberg if (ping_timeout_active) { 534232862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 5343b411b363SPhilipp Reisner goto reconnect; 5344b411b363SPhilipp Reisner } 534532862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 5346b411b363SPhilipp Reisner continue; 5347b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5348b411b363SPhilipp Reisner continue; 5349b411b363SPhilipp Reisner } else { 535032862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 5351b411b363SPhilipp Reisner goto reconnect; 5352b411b363SPhilipp Reisner } 5353b411b363SPhilipp Reisner 5354b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5355e658983aSAndreas Gruenbacher if (decode_header(tconn, tconn->meta.rbuf, &pi)) 5356b411b363SPhilipp Reisner goto reconnect; 53577201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 53581952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 53592fcb8f30SAndreas Gruenbacher conn_err(tconn, "Unexpected meta packet %s (0x%04x)\n", 53602fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5361b411b363SPhilipp Reisner goto disconnect; 5362b411b363SPhilipp Reisner } 5363e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 536452b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 536532862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 536677351055SPhilipp Reisner pi.cmd, pi.size); 5367b411b363SPhilipp Reisner goto reconnect; 5368b411b363SPhilipp Reisner } 5369257d0af6SPhilipp Reisner } 5370b411b363SPhilipp Reisner if (received == expect) { 53712735a594SAndreas Gruenbacher bool err; 5372a4fbda8eSPhilipp Reisner 53732735a594SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 53742735a594SAndreas Gruenbacher if (err) { 53751952e916SAndreas Gruenbacher conn_err(tconn, "%pf failed\n", cmd->fn); 5376b411b363SPhilipp Reisner goto reconnect; 53771952e916SAndreas Gruenbacher } 5378b411b363SPhilipp Reisner 5379a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 5380f36af18cSLars Ellenberg 538144ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 538244ed167dSPhilipp Reisner /* restore idle timeout */ 538344ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 538444ed167dSPhilipp Reisner ping_timeout_active = false; 538544ed167dSPhilipp Reisner } 5386b411b363SPhilipp Reisner 5387e658983aSAndreas Gruenbacher buf = tconn->meta.rbuf; 5388b411b363SPhilipp Reisner received = 0; 538952b061a4SAndreas Gruenbacher expect = header_size; 5390b411b363SPhilipp Reisner cmd = NULL; 5391b411b363SPhilipp Reisner } 5392b411b363SPhilipp Reisner } 5393b411b363SPhilipp Reisner 5394b411b363SPhilipp Reisner if (0) { 5395b411b363SPhilipp Reisner reconnect: 5396bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 539719fffd7bSPhilipp Reisner conn_md_sync(tconn); 5398b411b363SPhilipp Reisner } 5399b411b363SPhilipp Reisner if (0) { 5400b411b363SPhilipp Reisner disconnect: 5401bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 5402b411b363SPhilipp Reisner } 540332862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5404b411b363SPhilipp Reisner 540532862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 5406b411b363SPhilipp Reisner 5407b411b363SPhilipp Reisner return 0; 5408b411b363SPhilipp Reisner } 5409